text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Спящий режим и автономное питание ESP8266
Часто возникает вопрос с автономным питанием ныне уже популярного модуля ESP8266. Эта заметка без уникальных фотографий, но она рассказывает, как оно делается на Си и SDK от Espressif и сколько потребляет.
#### 1. Железное вмешательство
Для начала, если ESP-01 (а он самый популярный и разумный в данной ситуации), надо сделать перемычку с 8 ножки esp8266 на пин RST и убрать светодиод, как показано на фотографии выше. Если перемычку не сделать — модуль из режима Deep Sleep не выйдет.
#### 2. Программируем
Установку комплекта для Windows, производил по хорошей статье с [geektimes](http://geektimes.ru/post/241842/).
Для примера мы возьмём проект **examples\dht22\_thingspeak**. Он хорош тем, что его очень легко поправить под свои цели отправки температуры и влажности.
Со всего проекта нам нужны **user\_main.c**, который содержит основной пользовательский код, и **user\_config.h**, который содержит настройки.
```
#define USE_WIFI_MODE STATION_MODE
#define WIFI_CLIENTSSID "wifi_net_name"
#define WIFI_CLIENTPASSWORD "wifi_net_pass"
#define DATA_SEND_DELAY 1000 /* milliseconds */
#define THINGSPEAK_SERVER "narodmon.ru"
```
Это содержимое файла **user\_config.h**. Задержку отправки изменять не надо, но если хочется, то можно. Но для однократной отправки — не надо.
Если нужен не народный мониторинг, а что-то другое — пишете в строке сервер свое. У меня там указан IP моей Raspberry.
Далее вносим изменения в код файла **user\_main.c**, в процедуре **dht22\_cb**:
```
os_sprintf(data, "http://%s/post.php?ID=xx-xx-xx-xx-xx-xxx&T1=%s&H1=%s", THINGSPEAK_SERVER, temp, hum);
```
В этой строке задаётся всё, что нам необходимо для отправки. Для народного мониторинга можно сделать автоматическое получение MAC-адреса, но на мой взгляд это лишнее — проще один раз написать.
Далее в том же файле, но в процедуре **user\_init**, задаём таймер для процедуры спячки:
```
os_timer_disarm(&sleep_timer);
os_timer_setfn(&sleep_timer, sleep_cb, NULL);
os_timer_arm(&sleep_timer, 5000, 1); //5s
```
Здесь **5000** — время в миллисекундах, а 1 — повторять.
Ну и последняя, собственно, сама процедура спячки. В данном случае — 10 минут.
```
static ETSTimer sleep_timer;
LOCAL void ICACHE_FLASH_ATTR sleep_cb(void *arg)
{
os_timer_disarm(&sleep_timer);
system_deep_sleep(600*1000*1000);//second*1000*1000
}
```
В итоге мы имеем модуль, который спит 10 минут, просыпается, отправляет данные с DHT22 (GPIO2) куда надо и засыпает на следующие 10 минут.
Пока я не выяснил, с чем связано, но 10 минут плавают ±30 секунд.
#### 3. Замеряем
Лабораторий и мегатестеров не имею. Все замеры производил дешёвым китайским тестером с соответствующей точностью.
В активном режиме (от просыпания до засыпания) — от 240мА до 360мА. В среднем 300мА где-то в районе 5-10 секунд.
В спящем — <1mA.
На самом деле, тестер пытался показать какие-то циферки, но его точность менее 1мА под огромным сомнением. Но и 1мА при питании от пальчиковых батареек считаю достойным результатом.
#### 4. Итоги
Можно выкинуть очень многое из этого проекта, если планируется простой автономный датчик температуры. Как минимум, вывод в терминал лишний.
О реальной продолжительности жизни от батареек судить пока не берусь — слишком мало время такой эксплуатации.
Всё найдено на просторах интернета и является собственностью тех, кто писал. Я только собрал в кучку и показал, как нажимать кнопочки на клавиатуре.
#### Источники
[ESP8266 Community forum](http://www.esp8266.com/index.php)
[Low Power ESP8266 – Sleeping at 78 micro Amps](http://tim.jagenberg.info/2015/01/18/low-power-esp8266/)
[ESP8266 SDK API Guide v1.0.0](http://esp8266.ru/esp8266-iot-sdk-v1-0-0-at-v0-22/) | https://habr.com/ru/post/257141/ | null | ru | null |
# У спамеров утекла база на 1,37 млрд адресов почты из-за ошибки резервного копирования
4 марта 2017 года специалист по безопасности Крис Викери (Chris Vickery) из компании MacKeeper [заранее объявил](https://twitter.com/VickerySec/status/837795748309655552), что к понедельнику появятся подробности о массивной утечке базы личных данных на 1,37 млрд записей. Он сдержал обещание. Вчера MacKeeper [опубликовала](https://mackeeper.com/blog/post/339-spammergate-the-fall-of-an-empire) подробности этой утечки. Оказалось, что её жертвой стала не какая-то нормальная компания, а спамерская фирма River City Media (RCM).
Под руководством известных спамеров [Элвина Слокомбе](https://www.spamhaus.org/rokso/spammer/SPM1247/alvin-slocombe-cyber-world-internet-services) (Alvin Slocombe) и [Мэтта Ферриса](https://www.spamhaus.org/rokso/spammer/SPM1011/matt-ferris-river-city-media-acetech-usa) (Matt Ferris) эта компания выдаёт себя за приличную маркетинговую фирму, в то же время сама хвастает в документах, что рассылает **более миллиарда писем в день**. И это при десятке сотрудников.
Что и говорить, с такой базой кто угодно может заняться «эффективным маркетингом».
База содержит не только адреса электронной почты, но и реальные имена, фамилии пользователей, IP-адреса, а часто и физические адреса.
На самом деле такая информация может пригодиться не только спамерам, но и другим заинтересованным лицам. Скажем, в ней есть огромное количество почтовых адресов в доменной зоне .mil — с именами и IP-адресами. Вы понимаете, что это значит.
Выборочная проверка базы показала, что это действительно реальная информация.
[Расследование](http://www.csoonline.com/article/3176433/security/spammers-expose-their-entire-operation-through-bad-backups.html) против спамерского гиганта RCM провели специалисты MacKeeper Security Research Center, CSOOnline и Spamhaus. Всё началось с того, что в январе этого года Крис Викери натолкнулся в открытом доступе на странный, но подозрительный набор файлов. Как выяснилось впоследствии, резервная копия базы принадлежала River City Media. Файлы не были защищены паролем. Крис Викери пока не сказал, где именно он «случайно обнаружил» файлы. Будем надеяться, что специалист по информационной безопасности не совершил ничего незаконного.
**Утечка произошла из-за неправильной конфигурации `rsync` — популярной утилиты для резервного копирования, синхронизации и зеркалирования данных между серверами.**
Бэкапы RCM лежали в открытом доступе уже более месяца. Часть файлов датируется январём 2017 года, а другая часть — декабрём 2016 года.
Среди файлов оказалась база размером 222,8 ГиБ с адресами электронной почты. Общее количество записей — 1 374 159 612.
Судя по статистике почтовых сервисов, спамеры явно ориентировались на американских пользователей. Среди самых популярных нет российских почтовых доменов. Но зато в базе, наверное, присутствуют почти все американские пользователи.
Изучение файлов показало, что RCM не просто спамер, а очень искушённый в своём деле агент. Для рассылки писем они использовали автоматические методы и некоторые хакерские техники. Например, проверяли почтовые серверы на предмет уязвимой конфигурации, а потом использовали эту информацию для массовых рассылок. Об этом свидетельствует наличие скриптов и логи чатов, найденные в бэкапах. Вот один фрагмент из этих чатов, где обсуждается техника, как обмануть антиспамерские фильтры Gmail и завалить письмами этот почтовый сервер.
Объясняется, что нужно поднять максимальное количество соединений с Gmail, но ничего не отправлять, просто долго держать соединения открытыми. Это делается путём конфигурации своей машины на максимальную задержку ответных пакетов и фрагментированным образом, одновременно открывая всё больше соединений. Ну а потом, когда Gmail уже почти готов разорвать соединения по таймауту, ввалить отправку писем на полную катушку по всем открытым соединениям, пока Gmail не захлебнётся и не отключит их.
Техника открытия как можно большего количества соединений между вашей машиной и компьютером жертвы, фактически, является атакой типа [Slowloris](https://en.wikipedia.org/wiki/Slowloris_(computer_security)), разновидностью DoS. Хитрость тут в том, что спамер не пытается вывести из строя компьютер жертвы, а пытается захватить и использовать как можно больше её ресурсов. В данном случае — чтобы всучить Gmail максимально возможное количество спам-почты.
*Логи провайдера TierPoint, который использовала RCM, показывают проблемы с забивкой ящиков AOL*
Подробности о разных видах атак со скриптами отправлены в Microsoft, Apple и другим фирмам, которых использовала спамерская банда.
Неизвестно, какими методами пользовалась River City Media, чтобы собрать эту информацию. Наверняка в ближайшее время Элвин Слокомбе и его подельники объявят, что не делали ничего незаконного. Возможно, база собрана через так называемые «ко-регистрации», когда человек регистрируется в каком-то сервисе, но не замечает галочки вроде «Разрешаю делиться своей информацией с третьими лицами». Владельцы интернет-сервисов и программ собирают базы своих пользователей и могут продавать эти базы третьим лицам.
Что ж, теперь RCM будет гораздо сложнее использовать старые методы. По состоянию на вчера Spamhaus внёс в свою базу всю инфраструктуру River City Media.
Крис Викери обещает в ближайшее время опубликовать ряд документов из бэкапа RCM, там достаточно интересных электронных таблиц, есть бэкапы жёстких дисков, логи чатов и др. А в блоге Salt Hash [подробно описываются](http://www.csoonline.com/article/3176433/security/spammers-expose-their-entire-operation-through-bad-backups.html?page=2) некоторые методы, которые использовала RCM для своего грязного заработка на интернет-рекламе: фальшивые страницы поисковых систем, продажа баннерной рекламы на сайтах с переносом её в тело письма и т.д. На всей этой гадости компания собрала с октября 2016 года по январь 2017 года немалую сумму $937 451,21 от различных рекламных сетей, в том числе AdDemand, W4, AD1 Media (Flex) и Union Square Media. | https://habr.com/ru/post/357286/ | null | ru | null |
# «Проблема 2000» в WebMoney WMClasses
В .Net для работы с интерфейсами WebMoney существует замечательная OpenSource библиотека [WMClasses](http://habrahabr.ru/post/14617/). За что большое спасибо [kazkad](http://habrahabr.ru/users/kazkad/).
Внезапно :) в пятницу вечером в этой библиотеке обнаружился неприятный баг, напоминающий «проблему 2000». В ответ на запрос осуществить WM перевод средств, сервис WebMoney начал выдавать код — 102 — не выполнено условие постоянного увеличения значения параметра w3s.request/reqn. Ниже описание, почему так происходит и как это исправить.
Дело в том, что при запросах на интерфейсы Webmoney необходимо использовать номер запроса [reqn](http://wiki.webmoney.ru/projects/webmoney/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_X2), который должен быть постоянно возрастающим. (целое без знака, макс. количество цифр — 15; всегда должен быть больше номера предыдущего запроса на перевод средств!!! Монотонность номера учитывается в привязке к WMID, подписывающему запрос.)
Смотрим в код WmXmlCmd.cs
```
public static long GenerateReqNo(int maxlen)
{
long reqn = DateTime.Now.ToFileTimeUtc();
string data = reqn.ToString();
if (data.Length > maxlen)
{
data = data.Remove(0, data.Length - maxlen); // <- удаляет первые 3 символа из строки
}
reqn = long.Parse(data);
return reqn;
}
```
В результате 14.12.2012 в 23.06 значение reqn достигло 999999999999999 и началось с 0. Требование возрастания нарушилось и работа сервиса остановилась. Решить удалось только обращением в службу поддержки WebMoney с просьбой сбросить значение reqn.
В этой истории радует то, что в следующий раз эта проблема возникнет 15.02.2016 8:53:20. Так что, еще есть 4 года, чтобы изменить способ генерации reqn.
Будьте внимательны. | https://habr.com/ru/post/162947/ | null | ru | null |
# use bigint в perl
В зависимости от версии мантисса целых чисел в **perl** 40 бит (5 байт) или 64 бита (8 байт).
Проверить сколько бит отводится на число в текущем **perl** довольно просто:
```
$ perl -e 'sub logn { log($_[1])/log($_[0]) } print "Мантисса целого числа — ", logn(2, ~0+1), " (бит)\n"'
Мантисса целого числа — 64 (бит)
```
В случае превышения мантиссы в математической операции результат будет вещественным числом с плавающей точкой.
Я столкнулся с таким различным поведением **perl**, когда работал с идентификатором сессии — 64-битным числом, которое сохранялось в куку в 64-ричной системе счисления.
> Такие же идентификаторы использует ютюб для своих видео.
> Для записи числа в 64-ричной СС в качестве цифр используются: цифры, большие и малые буквы латинского алфавита, а так же знаки \_ (подчёрк) и - (тире).
> Например: \_m9ZDg8Ve7w64 = 7234851255909079500210.
>
>
На сервере стоял **perl** c 40-битными целыми. В результате алгоритм считывания числа из 64-ричной системы счисления (**from\_radix**) переполнял мантиссу и число превращалось в число с плавающей точкой и точностью. Результат — совсем другой идентификатор.
> Конечно, знающие люди скажут, что в наш просвещённый век стоит использовать **docker** в том числе и на сервере. Полностью с этим согласен и, как только **docker** станет безопасным (научится запускать контейнеры с пользователем **root** не от рута, чтобы через **/proc** нельзя было из контейнера пробраться на хостовую машину с рутовыми правами), то сразу же на него и перейду. Пока же остаются **lxc/lxd** (умеет подменять идентификатор нерутового пользователя на рутового в контейнере) и тяжёлые решения вроде виртуальных машин. Впрочем, **vagrant** поддерживает и **lcx** и **virtualbox**, так что — есть, где развернуться.
>
>
Положение спас **use bigint**. Эта прагма всем целочисленные константам в блоке, в котором указана, придаёт блеск **Math::BigInt** и следит за тем, чтобы они имели 64-битную мантиссу вне зависимости от версии **perl**-а:
```
$ perl -e 'use bigint; print ref 10'
Math::BigInt
```
Напоследок приведу алгоритмы для перевода чисел в различные системы счисления:
```
use utf8;
# Использованы символы из кодировки cp1251, что нужно для корректной записи в таблицы
our $CIF = join "", "0".."9", "A".."Z", "a".."z", "_-", # 64 символа для 64-ричной системы счисления
(map chr, ord "А" .. ord "Я"), "ЁЂЃЉЊЌЋЏЎЈҐЄЇІЅ",
(map chr, ord "а" .. ord "я"), "ёђѓљњќћџўјґєїіѕ",
"‚„…†‡€‰‹‘’“”•–—™›¤¦§©«¬®°±µ¶·№»", do { no utf8; chr 0xa0 }, # небуквенные символы из cp1251
"!\"#\$%&'()*+,./:;<=>?\@[\\]^`{|}~", # символы пунктуации ASCII
" ", # пробел
(map chr, 0 .. 0x1F, 0x7F), # управляющие символы ASCII
# символ 152 (0x98) в cp1251 отсутствует.
;
# Переводит натуральное число в заданную систему счисления
sub to_radix(@) {
use bigint;
my ($n, $radix) = @_;
$radix //= 64;
die "to_radix: Слишком большая система счисления $radix. Используйте СС до " . (1 + length $CIF) if $radix > length $CIF;
$n += 0; $radix += 0;
my $x = "";
for(;;) {
my $cif_idx = $n % $radix;
my $cif = substr $CIF, $cif_idx, 1;
$x =~ s/^/$cif/;
last unless $n = int($n / $radix);
}
return $x;
}
# Парсит натуральное число в указанной системе счисления
sub from_radix(@) {
use bigint;
my ($s, $radix) = @_;
$radix //= 64;
$radix += 0;
die "from_radix: Слишком большая система счисления $radix. Используйте СС до " . length $CIF if $radix > length $CIF;
my $x = 0;
for my $ch (split "", $s) {
$x = $x*$radix + index $CIF, $ch;
}
return $x;
}
```
Как Вы можете видеть, приходящие в параметрах функций числа никак прагмой **use bigint** не преобразуются. Поэтому они преобразуются к числу **Math::BigInt** прибавлением нуля ($radix += 0).
> Что касается подбора символов для цифр в больших системах счисления (в **$CIF** содержится достаточно чисел для СС до 255 включительно) на основе кодировки **cp1251**, то я планировал использовать приведённые функции для кодирования юникодовских символов в базу с COLLATE cp1251\_general\_ci. Это должно сократить место в базе, ввиду того, что русские буквы используются гораздо чаще юникодовских символов.
> Если интересно — дайте знать в комментариях и я напишу статью и об этом.
>
>
Тезаурус
--------
* CC — система счисления.
Ссылки
------
1. [U. Windl „How to check availability of 64-bit integers (for `use integer`)?”](https://stackoverflow.com/questions/68890205/how-to-check-availability-of-64-bit-integers-for-use-integer)
2. [SquarePerl „Функция log() в Perl”](https://squareperl.com/ru/function/log) | https://habr.com/ru/post/662213/ | null | ru | null |
# Totem Gnome Applet
В предыдущем [посте](http://habrahabr.ru/blogs/PyGTK/73973/) , я описывал создание простейшего апплета панели Gnome. В этом посте хотелось бы продемонстрировать апплет взаимодействующий с видеопроигрывателем Totem. Данный апплет будет представлять из себя небольшое приложение с 4 кнопками и надписью, у кнопок будет следующая функцианальность: воспроизведение, паузу, воспроизведение предыдущего и следующего.
Код апплета:
> `Copy Source | Copy HTML1. #!/usr/bin/env python
> 2.
> 3. import sys
> 4. import gtk
> 5. import pygtk
> 6. import subprocess
> 7. import gnomeapplet
> 8.
> 9. def factory(applet, iid):
> 10. button = gtk.Button("")
> 11. image = gtk.Image()
> 12. image.set\_from\_stock("gtk-media-previous",gtk.ICON\_SIZE\_BUTTON)
> 13. button.set\_image(image)
> 14. button.connect("clicked",previous\_clicked)
> 15. hbox.add(button)
> 16.
> 17. button = gtk.Button("")
> 18. image = gtk.Image()
> 19. image.set\_from\_stock("gtk-media-play",gtk.ICON\_SIZE\_BUTTON)
> 20. button.set\_image(image)
> 21. button.connect("clicked",play\_clicked)
> 22. hbox.add(button)
> 23.
> 24. button = gtk.Button("")
> 25. image = gtk.Image()
> 26. image.set\_from\_stock("gtk-media-pause",gtk.ICON\_SIZE\_BUTTON)
> 27. button.set\_image(image)
> 28. button.connect("clicked",pause\_clicked)
> 29. hbox.add(button)
> 30.
> 31. button = gtk.Button("")
> 32. image = gtk.Image()
> 33. image.set\_from\_stock("gtk-media-next",gtk.ICON\_SIZE\_BUTTON)
> 34. button.set\_image(image)
> 35. button.connect("clicked",next\_clicked)
> 36. hbox.add(button)
> 37.
> 38. hbox = gtk.HBox()
> 39. label = gtk.Label("Gnome player:")
> 40. hbox.add(label)
> 41.
> 42. applet.add(hbox)
> 43. applet.show\_all()
> 44. return True
> 45.
> 46. def previous\_clicked(event):
> 47. **subprocess**.Popen(("totem","--previous"))
> 48.
> 49. def play\_clicked(event):
> 50. **subprocess**.Popen(("totem","--play"))
> 51.
> 52. def pause\_clicked(event):
> 53. **subprocess**.Popen(("totem","--pause"))
> 54.
> 55. def next\_clicked(event):
> 56. **subprocess**.Popen(("totem","--next"))
> 57.
> 58. if **len**(**sys**.argv) == 2:
> 59. if **sys**.argv[1] == "run-in-window":
> 60. main\_window = gtk.Window(gtk.WINDOW\_TOPLEVEL)
> 61. main\_window.set\_title("Totem Applet")
> 62. main\_window.connect("destroy", gtk.main\_quit)
> 63. app = gnomeapplet.Applet()
> 64. factory(app, None)
> 65. app.reparent(main\_window)
> 66. main\_window.show\_all()
> 67. gtk.main()
> 68. **sys**.exit()
> 69.
> 70. gnomeapplet.bonobo\_factory("OAFIID:GNOME\_TotemApplet\_Factory",
> 71. gnomeapplet.Applet.\_\_gtype\_\_,
> 72. "simple remote control", "1.0", factory)`
Здесь у нас контейнером всех элементов выступает элемент — HBox, содержащий в себе надпись label, и 4 кнопки — button — воспроизведение, пауза и т.д. За описанием контейнера идет описание 4-ех событий — нажатия на наши кнопки, описание окна, и непосредственно регистрация нашего апплета.
Файл .server:
> `Copy Source | Copy HTML1. <oaf\_info>
> 2. <oaf\_server iid="OAFIID:GNOME\_TotemApplet\_Factory"
> 3. type="exe" location="/home/totemapplet.py">
> 4.
> 5. <oaf\_attribute name="repo\_ids" type="stringv">
> 6. <item value="IDL:Bonobo/GenericFactory:1.0"/>
> 7. <item value="IDL:Bonobo/Unknown:1.0"/>
> 8. oaf\_attribute>
> 9. <oaf\_attribute name="name" type="string" value="Totem Applet"/>
> 10. <oaf\_attribute name="description" type="string" value="Simple remote control"/>
> 11. oaf\_server>
> 12.
> 13. <oaf\_server iid="OAFIID:GNOME\_TotemApplet"
> 14. type="factory" location="OAFIID:GNOME\_TotemApplet\_Factory">
> 15.
> 16. <oaf\_attribute name="repo\_ids" type="stringv">
> 17. <item value="IDL:GNOME/Vertigo/PanelAppletShell:1.0"/>
> 18. <item value="IDL:Bonobo/Control:1.0"/>
> 19. <item value="IDL:Bonobo/Unknown:1.0"/>
> 20. oaf\_attribute>
> 21. <oaf\_attribute name="name" type="string" value="Totem Applet"/>
> 22. <oaf\_attribute name="description" type="string" value="Simple remote control"/>
> 23. <oaf\_attribute name="panel:category" type="string" value="Utility"/>
> 24. oaf\_server>
> 25. oaf\_info>`
После того как проделано вышеописанное, нужно проделать следующие:
Копируем файл .server в /usr/lib/bonobo/servers/: *cp /home/totemapplet.server /usr/lib/bonobo/servers/*
Делаем наш апплет иполняемым: *chmod +x totemapplet.py*
Добавляем на панель и наслаждаемся. | https://habr.com/ru/post/74937/ | null | ru | null |
# Руководство по Java 8 Optional
### 1. Обзор
В этом учебном пособии мы рассмотрим класс `Optional`, который был представлен в Java 8.
Цель класса — предоставить решение на уровне типа для представления опциональных значений вместо `null` (нулевых) ссылок.
Для более глубокого понимания того, почему мы должны обратить внимание на класс `Optional`, ознакомьтесь с [официальной статьей Oracle](http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html).
### 2. Создание объектов Optional
Существует несколько способов создания объектов `Optional`.
Чтобы создать пустой объект `Optional`, нужно просто использовать его статический метод `empty()`:
```
@Test
public void whenCreatesEmptyOptional_thenCorrect() {
Optional empty = Optional.empty();
assertFalse(empty.isPresent());
}
```
Обратите внимание, что мы использовали метод `isPresent()` для проверки наличия значения внутри объекта `Optional`. Значение присутствует, только если мы создали `Optional` с non-*null* (ненулевым) значением. Мы рассмотрим метод `isPresent()` в следующем разделе.
Можно также создать объект `Optional` с помощью статического метода `of()`:
```
@Test
public void givenNonNull_whenCreatesNonNullable_thenCorrect() {
String name = "baeldung";
Optional opt = Optional.of(name);
assertTrue(opt.isPresent());
}
```
Однако аргумент, переданный в метод`of()`, не может быть `null`. В противном случае мы получим `NullPointerException`:
```
@Test(expected = NullPointerException.class)
public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
String name = null;
Optional.of(name);
}
```
Но в случае, если мы предполагаем некоторые значения `null`, то можно использовать метод `ofNullable()`:
```
@Test
public void givenNonNull_whenCreatesNullable_thenCorrect() {
String name = "baeldung";
Optional opt = Optional.ofNullable(name);
assertTrue(opt.isPresent());
}
```
Таким образом, если мы передаем `null` ссылку, это не вызовет исключения, а вернет пустой объект `Optional`:
```
@Test
public void givenNull_whenCreatesNullable_thenCorrect() {
String name = null;
Optional opt = Optional.ofNullable(name);
assertFalse(opt.isPresent());
}
```
### 3. Проверка наличия значения: isPresent() и isEmpty()
Когда у нас есть объект `Optional`, возвращенный из метода или созданный нами, мы можем проверить, есть ли в нем значение или нет, с помощью метода`isPresent()`:
```
@Test
public void givenOptional_whenIsPresentWorks_thenCorrect() {
Optional opt = Optional.of("Baeldung");
assertTrue(opt.isPresent());
opt = Optional.ofNullable(null);
assertFalse(opt.isPresent());
}
```
Этот метод возвращает `true`, если обернутое значение не является `null`.
Также, начиная с Java 11, мы можем сделать обратное с помощью метода `isEmpty`:
```
@Test
public void givenAnEmptyOptional_thenIsEmptyBehavesAsExpected() {
Optional opt = Optional.of("Baeldung");
assertFalse(opt.isEmpty());
opt = Optional.ofNullable(null);
assertTrue(opt.isEmpty());
}
```
### 4. Условное действие с помощью ifPresent()
Метод `ifPresent()` позволяет нам запустить некоторый код для обернутого значения, если выяснится, что оно не является `null`. До метода `Optional` мы бы сделали следующее:
```
if(name != null) {
System.out.println(name.length());
}
```
Этот код проверяет, является ли переменная name `null`или нет, прежде чем приступить к выполнению какого-либо кода над ней. Такой подход занимает много времени, и это не единственная проблема — он также склонен к ошибкам.
В самом деле, где гарантия, что после печати этой переменной мы не воспользуемся ею снова, а потом забудем выполнить проверку на `null`?
Это может привести к `NullPointerException`во время выполнения программы, если в этот код попадет значение `null`**.** Когда программа терпит неудачу из-за проблем с вводом, это часто является результатом плохой практики программирования.
`Optional`заставляет нас иметь дело с допускающими `null` значениями в явном виде, как способ принуждения к хорошей практике программирования.
Теперь давайте посмотрим, каким образом приведенный выше код может быть рефакторизован в Java 8.
В типичном стиле функционального программирования мы можем выполнить действие над объектом, который действительно присутствует:
```
@Test
public void givenOptional_whenIfPresentWorks_thenCorrect() {
Optional opt = Optional.of("baeldung");
opt.ifPresent(name -> System.out.println(name.length()));
}
```
### 5. Значение по умолчанию с помощью orElse()
Метод `orElse()` используется для получения значения, обернутого внутри экземпляра `Optional`. Он принимает один параметр, который выступает в качестве значения по умолчанию. Метод `orElse()` возвращает обернутое значение, если оно присутствует, либо его аргумент в противном случае:
```
@Test
public void whenOrElseWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElse("john");
assertEquals("john", name);
}
```
### 6. Значение по умолчанию с помощью orElseGet()
Метод `orElseGet()` аналогичен методу `orElse()`. Однако вместо того, чтобы принимать значение для возврата, если `Optional` значение отсутствует, он принимает функциональный интерфейс поставщика, который вызван и возвращает значение вызова:
```
@Test
public void whenOrElseGetWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(() -> "john");
assertEquals("john", name);
}
```
### 7. Разница между orElse и orElseGet()
Многим программистам, которые только начинают работать с `Optional` или Java 8, разница между `orElse()`и `orElseGet()` непонятна. На самом деле, создается впечатление, что эти два метода перекрывают друг друга по функциональности.
Однако между ними есть тонкое, но очень важное различие, которое может сильно повлиять на производительность нашего кода, если его не понять.
Давайте создадим в тестовом классе метод `getMyDefault()`, который не принимает никаких аргументов и возвращает значение по умолчанию:
```
public String getMyDefault() {
System.out.println("Getting Default Value");
return "Default Value";
}
```
Давайте рассмотрим два теста и понаблюдаем за их побочными эффектами, чтобы определить, где `orElse()` и `orElseGet()` пересекаются, а где отличаются:
```
@Test
public void whenOrElseGetAndOrElseOverlap_thenCorrect() {
String text = null;
String defaultText = Optional.ofNullable(text).orElseGet(this::getMyDefault);
assertEquals("Default Value", defaultText);
defaultText = Optional.ofNullable(text).orElse(getMyDefault());
assertEquals("Default Value", defaultText);
}
```
В приведенном выше примере мы обертываем `null` текст внутри объекта `Optional` и пытаемся получить обернутое значение, используя каждый из двух подходов.
Побочный эффект таков:
```
Getting default value...
Getting default value...
```
В каждом случае вызывается метод `getMyDefault()`. Выходит, что если обернутое значение отсутствует, то и `orElse()`, и `orElseGet()` работают одинаково.
Теперь давайте проведем еще один тест, в котором значение присутствует, и в идеале значение по умолчанию даже не должно создаваться:
```
@Test
public void whenOrElseGetAndOrElseDiffer_thenCorrect() {
String text = "Text present";
System.out.println("Using orElseGet:");
String defaultText
= Optional.ofNullable(text).orElseGet(this::getMyDefault);
assertEquals("Text present", defaultText);
System.out.println("Using orElse:");
defaultText = Optional.ofNullable(text).orElse(getMyDefault());
assertEquals("Text present", defaultText);
}
```
В приведенном выше примере мы больше не оборачиваем значение `null`, а остальная часть кода остается прежней.
Теперь давайте посмотрим на побочный эффект от выполнения этого кода:
```
Using orElseGet:
Using orElse:
Getting default value...
```
Обратите внимание, что при использовании `orElseGet()` для извлечения обернутого значения метод`getMyDefault()` даже не вызывается, поскольку содержащееся значение присутствует.
Однако при использовании `orElse()`, независимо от того, есть ли обернутое значение или нет, создается объект по умолчанию. Таким образом, в данном случае мы просто создали один лишний объект, который никогда не используется.
В этом простом примере создание объекта по умолчанию не требует значительных затрат, поскольку JVM знает, как с ним обращаться. Однако когда такой метод, как `getMyDefault()`, должен выполнить вызов веб-сервиса или даже запрос к базе данных, затраты становятся весьма очевидными.
### 8. Исключения с помощью orElseThrow()
Метод `orElseThrow()` следует из `orElse()` и `orElseGet()` и добавляет новый подход к обработке отсутствующего значения.
Вместо того чтобы возвращать значение по умолчанию, когда обернутое значение отсутствует, он выбрасывает исключение:
```
@Test(expected = IllegalArgumentException.class)
public void whenOrElseThrowWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElseThrow(
IllegalArgumentException::new);
}
```
Здесь пригодятся ссылки на методы в Java 8, чтобы передать в конструктор исключения.
Java 10 представила упрощенную версию метода `orElseThrow()` без аргументов. В случае пустого `Optional`он выбрасывает исключение `NoSuchElementException`:
```
@Test(expected = NoSuchElementException.class)
public void whenNoArgOrElseThrowWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElseThrow();
}
```
### 9. Возвращение значения с помощью get()
Последний способ получения обернутого значения — метод `get()`:
```
@Test
public void givenOptional_whenGetsValue_thenCorrect() {
Optional opt = Optional.of("baeldung");
String name = opt.get();
assertEquals("baeldung", name);
}
```
Однако, в отличие от предыдущих трех подходов, `get()` может вернуть значение, только если обернутый объект не является `null`; в противном случае он выбрасывает исключение нет такого элемента:
```
@Test(expected = NoSuchElementException.class)
public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
Optional opt = Optional.ofNullable(null);
String name = opt.get();
}
```
Это основной недостаток метода `get()`. В идеале `Optional` должен помочь нам избежать таких непредвиденных исключений. Поэтому данный подход противоречит целям `Optional` и, вероятно, будет упразднен в одном из будущих выпусков.
Поэтому рекомендуется использовать другие варианты, которые позволяют нам быть готовыми к случаю `null` и явно его обрабатывать.
### 10. Условный возврат с помощью filter()
Мы можем запустить встроенный тест на нашем обернутом значении с помощью метода `filter`. Он принимает предикат в качестве аргумента и возвращает объект `Optional`. Если обернутое значение проходит проверку предикатом, то `Optional` возвращается как есть.
Однако если предикат вернет `false`, то будет возвращен пустой `Optional`:
```
@Test
public void whenOptionalFilterWorks_thenCorrect() {
Integer year = 2016;
Optional yearOptional = Optional.of(year);
boolean is2016 = yearOptional.filter(y -> y == 2016).isPresent();
assertTrue(is2016);
boolean is2017 = yearOptional.filter(y -> y == 2017).isPresent();
assertFalse(is2017);
}
```
Метод `filter` обычно используется таким образом для отклонения обернутых значений на основе предопределенного правила. Мы могли бы использовать его для отбраковки неправильного формата электронной почты или недостаточно надежного пароля.
Давайте рассмотрим другой показательный пример. Допустим, мы хотим купить модем, и нас интересует только его цена.
С определенного сайта нам приходят push-уведомления о ценах на модемы, и они сохраняются в объектах:
```
public class Modem {
private Double price;
public Modem(Double price) {
this.price = price;
}
// standard getters and setters
}
```
Затем мы передаем эти объекты некоторому коду, единственная цель которого — проверить, находится ли цена модема в пределах нашего бюджета.
Теперь давайте посмотрим на код без `Optional`:
```
public boolean priceIsInRange1(Modem modem) {
boolean isInRange = false;
if (modem != null && modem.getPrice() != null
&& (modem.getPrice() >= 10
&& modem.getPrice() <= 15)) {
isInRange = true;
}
return isInRange;
}
```
Обратите внимание на то, как много кода нам приходится писать для достижения этой цели, особенно в условии `if`. Единственная часть условия `if`, которая критична для приложения, — это последняя проверка диапазона цен; остальные проверки носят вспомогательный характер:
```
@Test
public void whenFiltersWithoutOptional_thenCorrect() {
assertTrue(priceIsInRange1(new Modem(10.0)));
assertFalse(priceIsInRange1(new Modem(9.9)));
assertFalse(priceIsInRange1(new Modem(null)));
assertFalse(priceIsInRange1(new Modem(15.5)));
assertFalse(priceIsInRange1(null));
}
```
Кроме того, о проверках на `null` можно забыть надолго, не получив ни одной ошибки во время компиляции.
Теперь давайте рассмотрим вариант с `Optional#filter`:
```
public boolean priceIsInRange2(Modem modem2) {
return Optional.ofNullable(modem2)
.map(Modem::getPrice)
.filter(p -> p >= 10)
.filter(p -> p <= 15)
.isPresent();
}
```
**Вызов** `map` **используется для трансформации одного значения в другое.** Следует помнить, что эта операция не изменяет исходное значение.
В нашем случае мы получаем объект цены из класса `Model`. Метод `map()` будет подробно рассмотрен в следующем разделе.
Во-первых, если в этот метод передается объект `null`, то никаких проблем не предвидится.
Во-вторых, единственная логика, которую мы прописываем внутри его тела, это именно то, что описывает название метода — проверка ценового диапазона. Об остальном позаботится `Optional`:
```
@Test
public void whenFiltersWithOptional_thenCorrect() {
assertTrue(priceIsInRange2(new Modem(10.0)));
assertFalse(priceIsInRange2(new Modem(9.9)));
assertFalse(priceIsInRange2(new Modem(null)));
assertFalse(priceIsInRange2(new Modem(15.5)));
assertFalse(priceIsInRange2(null));
}
```
Предыдущий подход обещает проверить диапазон цен, но при этом должен сделать нечто большее, чтобы защититься от присущей ему хрупкости. Поэтому мы можем использовать метод `filter`, чтобы заменить ненужные операторы `if` и отбросить нежелательные значения.
### 11. Трансформация значения с помощью map()
В предыдущем разделе мы рассмотрели, как отклонить или принять значение на основе фильтра.
Мы можем использовать аналогичный синтаксис для преобразования значения `Optional`с помощью метода `map()`:
```
@Test
public void givenOptional_whenMapWorks_thenCorrect() {
List companyNames = Arrays.asList(
"paypal", "oracle", "", "microsoft", "", "apple");
Optional> listOptional = Optional.of(companyNames);
int size = listOptional
.map(List::size)
.orElse(0);
assertEquals(6, size);
}
```
В этом примере мы оборачиваем список строк внутри объекта `Optional` и используем его метод `map` для выполнения действия над содержащимся в нем списком. Оно заключается в получении размера списка.
Метод `map` возвращает результат вычислений, завернутый внутрь `Optional`. Затем мы должны вызвать соответствующий метод для возвращенного `Optional`, чтобы получить это значение.
Обратите внимание, что метод `filter` просто выполняет проверку значения и возвращает `Optional`, описывающий это значение, только если оно соответствует заданному предикату. В противном случае возвращается пустой `Optional`. Метод `map` берет существующее значение, выполняет вычисления, используя его, и возвращает результат вычислений, обернутый в объект `Optional`:
```
@Test
public void givenOptional_whenMapWorks_thenCorrect2() {
String name = "baeldung";
Optional nameOptional = Optional.of(name);
int len = nameOptional
.map(String::length)
.orElse(0);
assertEquals(8, len);
}
```
Мы можем соединить `map` и `filter` вместе, чтобы сделать что-то более мощное.
Допустим, нам нужно проверить правильность пароля, введенного пользователем. Можно очистить пароль с помощью трансформации `map` и проверить его правильность с помощью `filter`:
```
@Test
public void givenOptional_whenMapWorksWithFilter_thenCorrect() {
String password = " password ";
Optional passOpt = Optional.of(password);
boolean correctPassword = passOpt.filter(
pass -> pass.equals("password")).isPresent();
assertFalse(correctPassword);
correctPassword = passOpt
.map(String::trim)
.filter(pass -> pass.equals("password"))
.isPresent();
assertTrue(correctPassword);
}
```
Как мы видим, без предварительной очистки ввода он будет отфильтрован. Однако пользователи могут считать само собой разумеющимся, что начальные и конечные пробелы — это всё входные данные. Поэтому мы преобразуем измененный пароль в очищенный с помощью `map`, прежде чем отфильтровать неправильные пароли.
### 12. Трансформация значения с помощью flatMap()
Подобно методу `map()`, у нас также есть метод `flatMap()` в качестве альтернативы для трансформации значений. Разница в том, что *map* преобразует значения только тогда, когда они извлечены (развернуты), в то время как `flatMap` берет обернутое значение и разворачивает его перед трансформацией.
Ранее мы создавали простые объекты `String` и `Integer` для обертывания в экземпляр `Optional`. Теперь, зачастую, мы будем получать эти объекты от асессора сложного объекта.
Чтобы лучше понять разницу, давайте рассмотрим объект `Person`, который принимает данные человека, такие как имя, возраст и пароль:
```
public class Person {
private String name;
private int age;
private String password;
public Optional getName() {
return Optional.ofNullable(name);
}
public Optional getAge() {
return Optional.ofNullable(age);
}
public Optional getPassword() {
return Optional.ofNullable(password);
}
// normal constructors and setters
}
```
Обычно мы создаем такой объект и оборачиваем его в `Optional`, как мы это делали со String.
В качестве альтернативы он может быть возвращен нам другим вызовом метода:
```
Person person = new Person("john", 26);
Optional personOptional = Optional.of(person);
```
Обратите внимание, что когда мы обернем объект `Person`, он будет содержать вложенные экземпляры `Optional`:
```
@Test
public void givenOptional_whenFlatMapWorks_thenCorrect2() {
Person person = new Person("john", 26);
Optional personOptional = Optional.of(person);
Optional> nameOptionalWrapper
= personOptional.map(Person::getName);
Optional nameOptional
= nameOptionalWrapper.orElseThrow(IllegalArgumentException::new);
String name1 = nameOptional.orElse("");
assertEquals("john", name1);
String name = personOptional
.flatMap(Person::getName)
.orElse("");
assertEquals("john", name);
}
```
Здесь мы пытаемся извлечь атрибут name объекта `Person`, чтобы выполнить утверждение.
Обратите внимание, как мы достигаем этого с помощью метода `map()` в третьем операторе, а затем заметьте, как мы делаем то же самое с помощью метода `flatMap()` после этого.
Ссылка на метод `Person::getName` похожа на вызов `String::trim`, который мы использовали в предыдущем разделе для очистки пароля.
Единственное отличие заключается в том, что `getName()` возвращает `Optional`, а не String, как операция `trim()`. Это, в сочетании с тем, что трансформация `map` оборачивает результат в объект `Optional`, и приводит к появлению вложенного `Optional`.
Поэтому во время применения метода `map()` необходимо добавить дополнительный вызов для получения значения перед использованием трансформированного значения. Таким образом, обертка `Optional` будет удалена. Эта операция выполняется неявно при использовании `flatMap`.
### 13. Цепочка Optional в Java 8
Иногда нам может понадобиться получить первый непустой объект `Optional` из нескольких `Optional`. В таких случаях было бы очень удобно использовать метод типа `orElseOptional()`. К сожалению, в Java 8 такая операция напрямую не поддерживается.
Давайте сначала представим несколько методов, которые мы будем использовать на протяжении всего этого раздела:
```
private Optional getEmpty() {
return Optional.empty();
}
private Optional getHello() {
return Optional.of("hello");
}
private Optional getBye() {
return Optional.of("bye");
}
private Optional createOptional(String input) {
if (input == null || "".equals(input) || "empty".equals(input)) {
return Optional.empty();
}
return Optional.of(input);
}
```
Для того чтобы выстроить цепочку из нескольких объектов `Optional`и получить первый непустой объект в Java 8, мы можем использовать `Stream` *API*:
```
@Test
public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturned() {
Optional found = Stream.of(getEmpty(), getHello(), getBye())
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();
assertEquals(getHello(), found);
}
```
Недостатком этого подхода является то, что все наши методы `get` выполняются всегда, независимо от того, где в `Stream` появляется непустой `Optional`.
Если мы хотим лениво оценить методы, переданные в `Stream.of()`, нам нужно использовать ссылку на метод и интерфейс `Supplier`:
```
@Test
public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturnedAndRestNotEvaluated() {
Optional found =
Stream.>>of(this::getEmpty, this::getHello, this::getBye)
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();
assertEquals(getHello(), found);
}
```
В случае если нам нужно использовать методы, принимающие аргументы, мы должны прибегнуть к лямбда-выражениям:
```
@Test
public void givenTwoOptionalsReturnedByOneArgMethod_whenChaining_thenFirstNonEmptyIsReturned() {
Optional found = Stream.>>of(
() -> createOptional("empty"),
() -> createOptional("hello")
)
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();
assertEquals(createOptional("hello"), found);
}
```
Часто мы хотим вернуть значение по умолчанию в случае, если все цепочки `Optional` пусты. Мы можем сделать это, просто добавив вызов `orElse()` или `orElseGet()`:
```
@Test
public void givenTwoEmptyOptionals_whenChaining_thenDefaultIsReturned() {
String found = Stream.>>of(
() -> createOptional("empty"),
() -> createOptional("empty")
)
.map(Supplier::get)
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst()
.orElseGet(() -> "default");
assertEquals("default", found);
}
```
### 14. Optional API в JDK 9
Релиз Java 9 добавил еще больше новых методов в *Optional* API:
* метод `or()` для предоставления поставщика, который создает альтернативный `Optional`;
* `ifPresentOrElse()` метод, позволяющий выполнить действие, если `Optional` присутствует, или другое действие, если нет;
* метод `stream()` для преобразования `Optional` в `Stream`.
Вот полный текст статьи для [дальнейшего чтения](https://www.baeldung.com/java-9-optional).
### 15. Неправильное использование Optional
Наконец, давайте рассмотрим привлекательный, но опасный способ использования `Optional`: передача параметра `Optional` методу.
Представьте, что у нас есть список `Person`, и мы хотим, чтобы метод искал в этом списке людей с заданным именем. Кроме того, желательно, чтобы этот метод находил записи, имеющие по крайней мере определенный возраст, если он указан.
Поскольку этот параметр является опциональным, мы пришли к такому методу:
```
public static List search(List people, String name, Optional age) {
// Null checks for people and name
return people.stream()
.filter(p -> p.getName().equals(name))
.filter(p -> p.getAge().get() >= age.orElse(0))
.collect(Collectors.toList());
}
```
Затем мы публикуем наш метод, и другой разработчик пытается его использовать:
```
someObject.search(people, "Peter", null);
```
Теперь разработчик выполняет свой код и получает `NullPointerException`. Мы вынуждены осуществлять проверку на `null` нашего опционального параметра, что противоречит нашей первоначальной цели избежать подобной ситуации.
Вот некоторые возможности, которые можно было бы сделать, чтобы справиться с этим лучше:
```
public static List search(List people, String name, Integer age) {
// Null checks for people and name
final Integer ageFilter = age != null ? age : 0;
return people.stream()
.filter(p -> p.getName().equals(name))
.filter(p -> p.getAge().get() >= ageFilter)
.collect(Collectors.toList());
}
```
Здесь параметр по-прежнему является опциональным, но мы обрабатываем его только в одной проверке.
Другим возможным вариантом является создание двух перегруженных методов:
```
public static List search(List people, String name) {
return doSearch(people, name, 0);
}
public static List search(List people, String name, int age) {
return doSearch(people, name, age);
}
private static List doSearch(List people, String name, int age) {
// Null checks for people and name
return people.stream()
.filter(p -> p.getName().equals(name))
.filter(p -> p.getAge().get().intValue() >= age)
.collect(Collectors.toList());
}
```
Таким образом, мы предлагаем четкий API с двумя методами, делающими разные вещи (хотя они имеют общую имплементацию).
Итак, существуют решения, позволяющие избежать использования `Optional`в качестве параметров метода. Намерением Java было при выпуске `Optional` использовать его в качестве возвращаемого типа, таким образом указывая, что метод может вернуть пустое значение. На самом деле, практика использования `Optional` в качестве параметра метода даже [не рекомендуется некоторыми инспекторами кода](https://rules.sonarsource.com/java/RSPEC-3553).
### 16. Optional и сериализация
Как уже говорилось выше, `Optional` предназначен для использования в качестве возвращаемого типа. Пытаться использовать его в качестве типа поля не рекомендуется.
Кроме того, использование `Optional` в сериализуемом классе приведет к возникновению исключения `NotSerializableException`. В нашей статье [Java *Optional* как возвращаемый тип](https://www.baeldung.com/java-optional-return) вопросы сериализации рассматриваются подробнее .
А в статье [Использование *Optional* в Jackson](https://www.baeldung.com/jackson-optional) мы объясняем, что происходит при сериализации полей `Optional`, и также приводим несколько обходных путей для достижения желаемых результатов.
### 17. Заключение
В этой статье мы охватили большинство важнейших фич класса `Optional` в Java 8.
Вкратце исследовали некоторые причины, побудившие нас использовать `Optional` вместо явной проверки на `null` и валидации ввода.
Также узнали, как получить значение `Optional` или значение по умолчанию, если оно пустое, с помощью методов `get()`, `orElse()` и `orElseGet()` (и заметили [важную разницу между двумя последними](https://www.baeldung.com/java-filter-stream-of-optional)).
Затем рассмотрели, как трансформировать или фильтровать наши `Optional` с помощью `map()`, `flatMap()` и`filter()`. Обсудили, что предлагает текучий API `Optional`, позволяющий легко соединять различные методы в цепочку.
Наконец, увидели, почему использование `Optional` в качестве параметров метода является плохой идеей и как этого избежать.
Исходный код всех примеров, приведенных в статье, доступен [на GitHub](https://github.com/eugenp/tutorials/tree/master/core-java-modules/core-java-11-2).
---
Приглашаем все желающих на открытое занятие «**Объектно-ориентированное и функциональное программирование**», на котором разберем отличия между этими двумя подходами на максимально простом уровне. Примеры рассмотрим на языке Java. Во второй части занятия вас ждет подробное описание особенностей специализации Java-разработчик. Регистрация — [**по ссылке.**](https://otus.ru/event-claim?event=2053&utm_source=habr&utm_medium=affilate&utm_campaign=spec_java&utm_term=31.05.22&source=https://otus.ru/lessons/java-specialization/) | https://habr.com/ru/post/668794/ | null | ru | null |
# MarkHtml
Библиотека для чистки HTML кода от XSS вставок и лишних закрывающих тегов, позволяет фильтровать входные данные, способные нарушить работу сайта.
В отличии от других аналогичных библиотек, например [Jevix](http://jevix.ru/project/), ставка сделана не на разрешающие теги и атрибуты, а на запрещающие. То есть, возможно вводить всё, кроме запрещённого.
С помощью внешних библиотек [Markdown Extra](http://michelf.com/projects/php-markdown/extra/) и [Typograf](https://web.archive.org/web/20110417113308/http://webfilin.ru/instruments/typograf/), можно писать красиво оформленные тексты. Markdown хорош тем, что позволяет использовать прежний HTML код без изменения, и в то же время комфортно писать статьи в обычном текстовом редакторе (или ).
Если нет необходимости использовать Markdown или Typograf, можно просто убрать код их подключения в начале файла `markhtml.php`.
Используется умная замена специальных HTML символов, позволяющая писать HTML код, либо же просто текст, в итоге текст будет выглядеть так, как вы хотели, а не как считает правильным парсер текста.
По-умолчанию настроен на вывод тегов и атрибутов в стиле HTML, но можно включить и XHTML режим.
Тестировал код на различных хакерских вставках, работает отлично, но правда не уверен что вспомнил все небезопасные теги и атрибуты, если кто подскажет что упустил, буду дорабатывать код.
Эту статью [писал в Markdown](http://ibnteo.klava.org/habr/markhtml.md) с последующим переносом на хабр, так как после знакомства с этим замечательным форматом, стало невыносимо сложно писать HTML код не для вёрстки шаблона сайта.
MarkHtml на Google Code: <http://code.google.com/p/markhtml/> (hg)
Прямая ссылка на архив с файлами: [markhtml.zip](https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/markhtml/markhtml.zip) | https://habr.com/ru/post/116607/ | null | ru | null |
# Работа с Tier Interaction Profiler ( TIP )
Это малоизвестная функция входящая в состав Visual Studio 2010 Premium которой я хочу посвятить немного времени и познакомить вас с ней. Она полезна когда вы пытаетесь определить почему ваше приложение ASP.NET не работает с такой производительностью с которой должно было бы, и как построены запросы приложения к базе данных, улучшают ли они производительность или снижают.
Для использования в этой публикации я скачал простенькое и неизвестное приложение «NerdDinner» написанное [Скотом Гутри](http://weblogs.asp.net/scottgu/) и друзьями. Скачивайте его [отсюда](http://nerddinner.codeplex.com/), устанавливайте и убедитесь, что оно работает (если у вас есть работающая версия SQL Express, приложение просто сделает аттач к mdf-файлу ассоцированному с проектом. SQL Express установлен по умолчанию в всех инсталляциях Visual Studio 2010, но если у вас нет инстанса, когда SQL Express работает, вам нужно поиграться с установками строки подключения в файле ConnectionStrings.config. Освежить свои знания по синтаксису строки подключения можно [здесь](http://msdn.microsoft.com/en-us/library/ms254500.aspx).). Когда все заработало, зарегистрируйте пользовательскую учетную запись, чтобы выполнить шаги описанные ниже.
Хорошо, теперь у вас есть работающее веб-приложение, давайте запустим профайлер и посмотрим, что мы увидим.
**Запуск Мастера Производительности (Performance Wizard)**
Выберете в Visual Studio пункт меню Анализировать (Analyze), а затем «Запустить мастер производительности…» («Launch Performance Wizard…»).
Далее вам будет представлен следующий диалог:
Просто выберите установку по умолчанию (которой должна быть «CPU Sampling» («Сэмплирование ЦП»)) и нажмите кнопку «Next» («Далее»). После этого появится следующее:
Заметьте «NerdDinner» является единственным выбором в этом диалоге, что и хорошо, так как единственный проект который мы хотим профилировать в данный момент! Если у вас много проектов которые формируют исполняемые файлы или веб-проекты, они также будут показаны.
Нажимте «Next» («Далее»), этим мы отобразим новую страницу мастера:
Убедитесь, что отмечено «Enable Tier Interaction Profiling», так как это включит функции, о которых я расскажу позже в этой публикации. Можете прочитать всю публикацию, чтобы понять о чем идет речь, или просто нажать «Next» («Далее»).
Оставьте отмеченным «Launch profiling after the wizard finishes» («Запустить профилирование после завершения мастера»).
Теперь Visual Studio запустит веб-сервер Cassini с веб-приложением NerdDinner.
**Запуск приложения**
At this point, Visual studio starts a performance session, loading the .vsp file in the Visual Studio doc well, and indicates to you that profiling is currently underway:
С этого момента, Visual Studio начнет сессию профилирования производительности, загрузит .vsp-файл в область документов и будет отображать вам что идет профилирование:
Теперь сделайте следующее:
1. Произведите вход в учетную запись в приложении
2. Разместите заказ на два ужина
Сделайте это щелкнув вкладку «Host Dinner» и введя информацию об ужине на странице, нажмите «Save» («Сохранить»), а затем повторите эти действия еще один раз
3. Выйдите из приложения закрыв IE
Через момент Visual Studio отобразит, что-то похожее на следующую иллюстрацию:
**Анализ результатов**
Одна из главных функций набора инструментов для профилирования в Visual Studio называется «Hot Path». Она быстро показывает области кода в которых может быть потеря производительности. По крайней мере, становится абсолютно ясно, на что приложение тратит большую часть времени.
На изображении ниже, сразу видно, что метод GetMostPopularDinners, кажется занимает большую часть времени по отношению к только что выполненной сессии.
Давайте щелкнем на этой ссылке (указывающей на метод). Вам должно быть отображено, что-то подобное изображенному ниже:
Много всего происходит здесь. Обратите внимание на факт, что выпадающий список «Current View» («Текущее представление») установлен на «Function Details» («Подробности функции»). Это важно и также высвечивает проблему с опытом пользователей Visual Studio, как много пользователей не знает, что есть этот выпадающий список и упускают завидную долю функциональности! Это одна из главных причин по которой много ребят не знает о Tier Interaction Profiler, так как это просто другое представление сессии производительности.
Можете поиграться с «большими синими прямоугольниками» щелкая на них, перемещаясь дальше и обратно щелкая на левом или правом прямоугольниках.
Вы также заметили, что я выделил строку кода, которая привлекла наше внимание при использовании функции «Hot Path». Также вы заметили временную характеристику 42.2% в углу слева в текстовом редакторе, с фактической строкой отмеченной по умолчанию в «красноватый» цвет.
Создается ощущение, что это строка, где тратится время, так как это место, где фактически строится выражение LINQ до того как выполняется вызов его запроса (Если вы не знакомы с этой концепцией, я очень рекомендую ознакомится с [этой публикацией](http://blogs.msdn.com/b/charlie/archive/2007/12/09/deferred-execution.aspx)).
Взглянем на код, он выглядит так как будто в нем мы обращаемся к базе данных из бекенда в этом методе:
> `public ActionResult GetMostPopularDinners(int? limit)
>
> {
>
> var dinners = dinnerRepository.FindUpcomingDinners();
>
>
>
> // Default the limit to 40, if not supplied.
>
> if (!limit.HasValue)
>
> limit = 40;
>
>
>
> var mostPopularDinners = from dinner in dinners
>
> orderby dinner.RSVPs.Count descending
>
> select dinner;
>
>
>
> var jsonDinners =
>
> mostPopularDinners.Take(limit.Value).AsEnumerable()
>
> .Select(item => JsonDinnerFromDinner(item));
>
>
>
> return Json(jsonDinners.ToList());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как я могу увидеть TSQL который посылается базе данных? Перейдем в Tier Interaction Profiler.
**Tier Interaction Profiler**
Вы отметили на изображении выше, что строка которую мы исследуем в данный момент является частью нашего контроллера SearchController. Посмотрим код более внимательно, метод GetMostPopularDinners на самом деле является акшеном контроллера и вызывается URL'ом относительно приложения. О чем все это на говорит?
Хорошо, все это показывает, что приложение NerdDinner является образцом демонстрирующим набор технологий, в первую очередь ASP.NET MVC 2. ASP.NET MVC 2 имеет очень мощный механизм маршрутизации URL'ов который полезен, когда вам нужно сделать более дружественные к пользователю URL'ы, более легкие в обслуживании и т.д. Это становится очевидным при просмотре данных в Tier Interaction Profiling.
Нажмите на выпадающем списке «Current View» («Текущее представление») и выберите «Tier Interactions»:
Теперь у вас должно отображаться, что-то похожее на изображение в верхней панели:
Столбец «Name» («Имя») содержит список различных артефактов запрошенных клиентом (в данном случае IE выполняющим приложение NerdDinner) у сервера. Вы увидите сколько запросов данного элемента записано в столбце «Count» («Счетчик»), также как и то как долго выполнялся запрос.
Например, вы заметите **/Content/Production.css** в столбце «Name» («Имя»). Этот css-файл был запрошен 7 раз, что в сумме составило 38 миллисекунд задержки. Таким образом очень удобно получать информацию о различных запросах которые выполняет приложение к серверу.
А вверху списка (и возвращаясь к нашему выполняющемуся примеру) вы заметите элемент **/Search/GetMostPopularDinners** который выполняется большую часть времени. Обычно вы видите адреса которые оканчиваются на aspx (страницы) или css (документы), и т.д., но так как это приложение использует преимущества маршрутизации ASP.NET MVC 2 вы видите более дружественные адреса, которые запрашиваются у сервера.
А что делать с запросами к базе данных?
Представление TIP (Tire Interaction Profile) ассоциирует запросы к серверу с вызовами базы данных ассоциированными с этими запросами. Так, если вы развернете элемент **/Search/GetMostPopularDinners**, вы увидите следующее:
Обратный запрос к серверу по адресу **/Search/GetMostPopularDinners** превращается в два запроса к базе данных которые вместе занимают ~75 миллисекунд. Не плохо, но даже лучше то, что вы можете в панели «Database connection details» («Подробности соединения с БД») вы можете видеть сам TSQL посылаемый базе данных. Дважды щелкните на записи, чтобы увидеть SQL полностью, подобный этому:
**Выводы**
Tier Interaction Profiler может сделать понимание запросов идущих от вашего клиента к базе данных очень простыми для понимания. Вы поймете не только какой SQL передается, но и сможете проанализировать производительность всей операции.
Я надеюсь это поможет!
Cameron | https://habr.com/ru/post/105906/ | null | ru | null |
# 1000++ способ запуска команд на удаленном компьютере
*В наше время даже для собак* [*придумали удаленное управление*](http://www.inderscience.com/info/inarticle.php?artid=55911).
Возвращаясь к циклу «Конспект Админа», мне хотелось бы рассказать о вариантах запуска исполняемых программ на удаленных компьютерах. Эта статья будет интересна тем, у кого еще нет систем централизованного управления, но уже есть понимание утомительности ручного обхода рабочих станций и серверов. **Либо тем, кому решения «под ключ» не интересны ввиду неспортивности.**
В качестве того, зачем нужен такой запуск программ, можно привести недавнюю истерию с Петей\Не-Петей, когда все бросились проверять\отключать [SMBv1](https://habrahabr.ru/company/pc-administrator/blog/331906/) и загружать обновления. Да и провести инвентаризацию или установить срочный патч таким методом тоже можно.
> Когда-то давно я устроился работать в организацию в период эпидемии [Kido\Conficker](https://en.wikipedia.org/wiki/Conficker). Наиболее простым способом выяснить, все ли хорошо в ИС компании, была славная утилита от Касперского под названием [Kido Killer](https://support.kaspersky.ru/viruses/disinfection/1956#block3), которая проверяла наличие вируса и устраняла его. Запускать программу на доброй сотне машин руками было невесело, поэтому пришлось знакомиться с автоматизацией.
Если в операционных системах \*nix для удаленного запуска, как правило, используется SSH, то у Windows способов запуска программ и скриптов воистину как песка в пустыне. Я разберу основные варианты, как общеизвестные, так и экзотические. Таких очевидных вещей как telnet-сервер касаться не буду, тем более Microsoft уже убрала его из современных ОС.
Способы старые, временем проверенные
====================================
Psexec
------
Пожалуй, это первое, что приходит на ум, когда идет речь об удаленном запуске программ. [Утилита](https://technet.microsoft.com/ru-ru/sysinternals/bb897553.aspx) от Марка Руссиновича используется еще со времен Windows NT и до сих пор применяется. Помимо основной функции, можно использовать ее и как Runas, и для запуска программ в пользовательской сессии терминального сервера. **Psexec** также позволяет задавать ядра процессора, на которых будет запускаться программа, и ее приоритет в системе.
В качестве примера посмотрим, установлено ли обновление, закрывающее нашумевшую уязвимость SMB на списке компьютеров:
```
psexec @computers.txt /u USER /p PASS cmd.exe /v /c ""systeminfo | find "KB4012212" || echo !computername! >> \\server\share\log.txt"""
```
В файле computers.txt находится список компьютеров. Для запуска по всему домену можно использовать \\\*. В файле \\server\share\log.txt будут появляться имена рабочих станций или серверов без обновления. Если в домене существуют компьютеры с \*nix на борту или нет доступа к административному сетевому ресурсу **Admin$** ― команда на этой машине не выполнится, но обработка продолжится. Чтобы скрипт не зависал при каждой попытке подключения, можно задать тайм-аут с помощью ключа **-n**.
Если компьютер выключен ― мы об этом не узнаем. Поэтому лучше предварительно проверять доступность машин или собирать в файле информацию об успешном или неудачном выполнении.
К минусам **Psexec** можно отнести то, что она из-за своего удобства и популярности часто используется вирусописателями. Поэтому антивирусные системы могут обнаруживать утилиту как опасность вида remote admin.
По умолчанию процесс на удаленной машине выполняется от имени пользователя, запустившего Psexec. При необходимости логин и пароль можно задать явно или же использовать аккаунт SYSTEM.
WMIC
----
Для управления системами Windows с помощью разных графических утилит часто используется [WMI](https://msdn.microsoft.com/ru-ru/library/aa394582.aspx) (Windows Management Instrumentation) ― реализация объектно-ориентированного стандарта управления WBEM. В качестве утилиты с графическим интерфейсом для работы с WMI можно использовать wbemtest.exe.
Для работы с WMI из консоли создана **wmic.exe**. Например, для проверки установленных обновлений вместо жутковатой конструкции из предыдущего примера можно использовать простую команду:
```
wmic /node:"servername" qfe get hotfixid | find "KB4012212"
```
Использовать список компьютеров также можно командой /node:"@computers.txt".
Еще при помощи WMI можно запускать программы – синтаксис предельно прост:
```
wmic /node:"servername" process call create "cmd /c somecommands"
```
К сожалению, в отличие от Psexec, получить вывод в консоли не получится ― придется выводить результаты команды в файл.
По умолчанию процесс на удаленной машине выполняется от имени пользователя, запустившего wmic. При необходимости логин и пароль можно задать явно.
Групповые политики и скрипты
----------------------------
Если предыдущие варианты не требовали доменной среды, то в этом случае потребуется домен. Поддерживаются скрипты при входе и выходе пользователя из системы, а также при ее включении и выключении. Поскольку каждый администратор Windows сталкивался с ними, я не буду подробно расписывать как ими пользоваться ― лишь напомню, где их искать.
*Скрипты, выполняющиеся при старте и завершении системы.*
*Скрипты, выполняющиеся при входе и выходе пользователя из системы.*
Скрипты, настраиваемые в пользовательском разделе, выполняются от имени пользователя, а в разделе компьютера ― под аккаунтом SYSTEM.
Назначенные задания
-------------------
Довольно интересный способ, заслуживающий право на жизнь. Назначенные задания можно создавать из командной строки при помощи утилиты **schtasks.exe**, выполнять их, затем удалять. Подробнее с синтаксисом можно ознакомиться в [документации](https://msdn.microsoft.com/ru-ru/library/windows/desktop/bb736357(v=vs.85).aspx), я же разберу пример использования назначенных заданий в доменной среде. Предположим, нам нужно выполнить команду как можно быстрее вне зависимости от того, выключен компьютер или нет. Для этого используются так называемые предпочтения групповых политик (Group Policy Preference).
Искать установку назначенных заданий следует в конфигурации компьютера или пользователя ― «Настройка ― Параметры панели управления ― Назначенные задания».
*Создание нового назначенного задания.*
Для выполнения команды или скрипта ASAP понадобится создать «Немедленную задачу (Windows 7 и выше)». Если вдруг в инфраструктуре остались машины под управлением Windows XP, то подойдет «Очередное задание (Windows XP)».
Стоит сделать несколько политик с соответствующими WMI-фильтрами или создать два разных назначенных задания в одной политике с нацеливанием ― например, при помощи того же WMI-фильтра. Это поможет избежать конфликтов в разнородной среде со старыми и новыми Windows.
Пример WMI-фильтра для применения политики только на компьютерах с Windows XP:
```
SELECT * FROM Win32_OperatingSystem WHERE Version LIKE "5.1%" AND ProductType = "1"
```
В остальном процедура создания назначенного задания тривиальна. Единственное, не забывайте отметить пункт «Применить один раз и не применять повторно», если задача не требует повторного запуска.
*Запускаем немедленную задачу только один раз.*
При использовании таких назначенных заданий программа запустится, как только компьютер получит обновление групповой политики. Это удобно: не нужно проверять доступность компьютеров в случае Psexec и wmic и заставлять пользователей перезагружать машины, как в случае скриптов групповых политик. При необходимости можно скопировать файл скрипта локально в разделе «Настройка ― Конфигурация Windows ― Файлы».
Назначенные задания позволяют явно задать имя пользователя для запуска программы, в том числе и для SYSTEM.
Через реестр
------------
Модификация реестра на пользовательских машинах ― странный вариант, лишь на случай крайней необходимости. Можно использовать ветки Run или RunOnce. Подробнее о них ― в [документации](https://support.microsoft.com/RU/help/137367). Сама модификация реестра может проводиться через групповые политики или из командной строки ― например, такой командой:
```
reg add \\COMPUTER\HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce /v script /t Reg_SZ /d "script.cmd"
```
В зависимости от ветки реестра, процесс будет выполняться или под пользователем, выполнившим вход в систему, или под аккаунтом SYSTEM.
Есть и другие способы, такие как правка ярлыков в папке «Автозагрузка» или добавление в ярлык к популярной программе **&& script.cmd**, но эти методы уже из серии «можно, но не нужно».
Теперь перейдем к новым инструментам.
Способы новые или куда же без PowerShell
========================================
PowerShell, оправдывая свое название, может подключаться к удаленным компьютерам при помощи WMI, RPC и WS-Management (WSMan). Использование последнего метода требует предварительной настройки.
Командлеты, не требующие предварительной настройки, как правило, имеют параметр ComputerName, но не имеют параметра Session. Посмотреть список таких командлетов можно командой:
```
Get-Command | where { $_.parameters.keys -contains "ComputerName" -and $_.parameters.keys -notcontains "Session"}
```
Для настройки WSMan в общем случае достаточно выполнить команду **Enable-PSRemoting-Force.** Она запустит службу удаленного управления WinRM и пропишет исключения в фаерволе ― в принципе, это можно сделать для всего домена при помощи групповых политик. Подробнее настройка описана в [документации](https://technet.microsoft.com/en-us/library/dd315349.aspx).
После того как все компьютеры будут готовы принимать запросы, мы сможем подключаться при помощи соответствующих командлетов PowerShell. Для проверки возможности подключения используется командлет **Test-WSMan**.
*Проверка возможности подключения.*
Для того чтобы выполнить определенную команду или скрипт, используется командлет **Invoke-Command** со следующим синтаксисом:
```
Invoke-Command -ComputerName COMPUTER -ScriptBlock { COMMAND } -credential USERNAME
```
Где COMPUTER ― имя компьютера, COMMAND ―– имя команды, а USERNAME ― имя пользователя, если оно нужно.
*Смотрим содержимое диска С удаленного компьютера.*
Если же нам нужно получить полноценную консоль ― не автоматизации ради, а ради управления конкретным компьютером, ― то можно использовать командлет **Enter-PSSession.**
*Работаем в консоли удаленного компьютера.*
Напомню, что с помощью [JEA](https://habrahabr.ru/company/pc-administrator/blog/335568/) можно ограничить доступные подобной сессии командлеты или дать доступ нужным без прав администратора.
Конечно, кроме встроенных средств и небольших утилит, существует множество программ для управления структурой. Помимо взрослых решений, для управления конфигурациями вроде Chef, Ansible и MS SCCM можно использовать и средства мониторинга вроде Zabbix, и даже консоль управления антивирусом Касперского.
В период гетерогенных структур хорошо бы иметь возможность унифицированного управления Windows и Linux. Это можно сделать и с помощью PowerShell, что само по себе достойно отдельной статьи ― стоит такую сделать или уже лишнее?
**Кстати, поделитесь вашими способами скрытого и не очень запуска программ на удаленных компьютерах. Ну, за исключением эксплойтов.** | https://habr.com/ru/post/342428/ | null | ru | null |
# Динамическое программирование в алгоритмах распознавания речи
В системах распознавания речи, содержащих слова, распознавание требует сравнения между входным словом и различными словами в словаре. Эффективное решение проблемы лежит в динамических алгоритмах сравнения, целью которого является введение временных масштабов двух слов в оптимальное соответствие. Алгоритмы такого типа являются динамическими алгоритмами трансформации временной шкалы. В данной статье представлено два варианта реализации алгоритма предназначенные для распознавания отдельных слов.
#### Введение
Исследования в области распознавания речи, так же как и в других областях, следуют по двум направлениям: фундаментальные исследования, целью которых является разработка и тестирование новых методов, алгоритмов и концепций на некоммерческой основе; и прикладных исследований, целью которых является улучшение существующих методов, следуя определенным критериям. В этой статье рассматривается распознавание отдельных слов в тенденции прикладных исследований.
Фундаментальные исследования направлены на получение среднесрочной или долгосрочной выгоды, в то время как прикладные исследования направлены на быстрое улучшение существующих методов или расширения их использования в областях, где такие методы еще практически не используются.
Улучшить скорость распознавания речи можно при учете следующих критериев:
* Размер узнаваемой лексики;
* Степень спонтанности речи, которую необходимо распознать;
* Зависимость/независимость от диктора;
* Время, необходимое для приведения системы в движение;
* Время приспособления системы для новых пользователей;
* Время выбора и распознавания;
* Степень распознавания (выраженная словом или предложением).
Сегодня системы распознавания звука строятся на основе принципов признания форм распознавания. Методы и алгоритмы, которые использовались до сих пор, могут быть разделены на четыре больших класса:
Методы дискриминатного анализа, основанные на Байесовской дискриминации;
Скрытые модели Маркова;
Динамическое программирование – временные динамические алгоритмы (DTW);
Нейронные сети;
В данной статье приводится пример и альтернатива алгоритму динамического программирования DTW, реализующего распознавание речи.
Алгоритм динамического трансформирования времени (DTW)
Алгоритм динамического трансформирования времени (DTW) вычисляет оптимальную последовательность трансформации (деформации) времени между двумя временными рядами. Алгоритм вычисляет оба значения деформации между двумя рядами и расстоянием между ними.
Предположим, что у нас есть две числовые последовательности (a1, a2, …, an) и (b1, b2, …, bm). Как видим, длина двух последовательностей может быть различной. Алгоритм начинается с расчета локальных отклонений между элементами двух последовательностей, использующих различные типы отклонений. Самый распространенный способ для вычисления отклонений является метод, рассчитывающий абсолютное отклонение между значениями двух элементов (Евклидово расстояние). В результате получаем матрицу отклонений, имеющую n строк и m столбцов общих членов:
Минимальное расстояние в матрице между последовательностями определяется при помощи алгоритма динамического программирования и следующего критерия оптимизации:
где: aij — минимальное расстояние между последовательностями (a1, a2, …, an) и (b1, b2, …, bm). Путь деформации – это минимальное расстояние в матрице между элементами а11 и anm, состоящими из тех aij элементами, которые выражают расстояние до anm.
Глобальные деформации состоят из двух последовательностей и определяются по следующей формуле:
где: wi – элементы, которые принадлежать пути деформации; p – их количество. Расчеты производились для двух коротких последовательностей и указаны в таблице, в которой выделена последовательность деформации.
Существует три условия, налагаемых на DTW алгоритм для обеспечения быстрой конвергенции:
1. Монотонность – путь никогда не возвращается, то есть: оба индекса, i и j, которые используются в последовательности, никогда не уменьшаются.
2. Непрерывность – последовательность продвигается постепенно: за один шаг индексы, i и j, увеличиваются не более чем на 1.
3. Предельность – последовательность начинается в левом нижнем углу и заканчивается в правом верхнем.
Пример деформации последовательности с использованием языка программирования Java приведен ниже:
````
public static void dtw(double a[],double b[],double dw[][], Stack w){
// a,b - the sequences, dw - the minimal distances matrix
// w - the warping path
int n=a.length,m=b.length;
double d[][]=new double[n][m]; // the euclidian distances matrix
for(int i=0;i0&&j>0)
if(dw[i-1][j-1]<=dw[i-1][j])
if(dw[i-1][j-1]<=dw[i][j-1]){i--;j--;} else j--;
else
if(dw[i-1][j]<=dw[i][j-1])i--; else j--;
else if(i==0)j--; else i--;
w.push(new Double(dw[i][j]));
}
while(i!=0||j!=0);
}
````
Так как для определения основы последовательности в динамическом программировании оптимальным является использование метод обратного программирования, необходимо использовать определенный динамический тип структуры, который называется «стек». Подобно любому динамическому алгоритму программирования, DWT имеет полиноминальную сложность. Когда мы имеем дело с большими последовательностями, возникают два неудобства:
— Запоминание больших числовых матриц;
— Выполнение большого количества расчетов отклонений.
Существует улучшенная версия алгоритма, FastDWT, которая решает две вышеуказанные проблемы. Решение заключается в разбиении матрицы состояний на 2, 4, 8, 16 и т.д. меньших по размеру матриц, посредством повторяющегося процесса разбиения последовательности ввода на две части. Таким образом, расчеты отклонения производятся только на этих небольших матрицах, и путях деформации, рассчитанных для небольших матриц. С алгоритмической точки зрения, предлагаемое решение основано на методе “Divide et Impera” (прим. пер. от лат. «Разделяй и влавствуй»).
#### Использование DWT алгоритма в распознавании речи
##### Анализ голосового сигнала
Звук проходит через среду, как продольная волна со скоростью, зависящей от плотности среды. Самый простой способ представления звуков – синусойдный график. Графическое представление вибраций воздуха под давлением на протяжении некоторого времени.
Форма звуковой волны зависит от трех факторов: аплитуды, частоты и фазы.
Амплитуда — перемещение синусоидальных графов выше и ниже временной оси (у = 0), что соответствует энергии загруженной звуковой волны. Измерение амплитуды может быть произведено в единицах давления (децибелах DB), которые измеряют амплитуду обычного звука при помощи логарифмических функций. Измерение амплитуды используя децибелы очень важно на практике, так как это прямое представление о том, как громкость звука воспринимается людьми. Частота – число циклов синусойды за одну секунду. Цикл колебаний начинается со средней линией, потом достигает максимума и минимума, а после возвращается к средней линии. Частота цикла измеряется за одну секунду или в герцах (Гц). Величина обратная частоте называется периодом – время необходимое звуковой волне для завершения цикла.
Последний фактор – фаза. Она измеряет положение относительно начала синусоидальной кривой. Фаза не может быть услышана человеком, однако ее можно определить относительно положения между двумя сигналами. Тем не менее, слуховой аппарат воспринимает положение звука на разных фазах.
Для того чтобы разобрать звуковые волны на синусоидальной кривой воспользуемся теоремой Фурье. Она гласит, что любая комплексная периодическая волна может быть разобрана при помощи синусоидальной кривой с различными частотами, амплитудами и фазами. Этот процесс называется анализ Фурье, и его результатом является набором амплитуд, фаз и частот для каждого синусоидального компонента волны. Складывая эти синусоидальные кривые вместе, получаем оригинальную звуковую волну. Точка частоты или фазы, взятая вместе с амплитудой, называется спектром. Любой периодический сигнал показывает, рекурсивную модель времени, которая соответствует первой частоте колебаний сигнала и называется основной частотой. Она может быть измерена из речевого сигнала, при помощи проверки периода колебаний около 0 оси. Спектр показывает частоту короткой последовательности звуков, и если мы хотим проанализировать ее развитие в течение времени, необходимо найти способ, позволяющий продемонстрировать это. Это можно показать на спектрограмме. Спектрограмма — это диаграмма в двух измерениях: частота и время, — в которой цвет точки (темный – сильный, светлый – слабый) определяет амплитуду интенсивности. Метод играет важную роль в распознавании речи, и профессионал может раскрыть многие подробности, глядя только на звуковую спектрограмму.
#### Выявление слов
Современные методы выявления могут точно определить начальную и конечную точку произнесенного слова в звуковом потоке, на основе обработки сигналов меняющихся в течение времени. Данные методы оценивают энергию и среднюю величину в коротком отрезке времени, а также вычисляют средний уровень пересечения нуля.
Создание начальной и конечной точки – простая задач, если аудиозапись сделана в идеальных условиях. В этом случае отношение сигнал-шум велик, так как определить действительный сигнал в потоке путем анализа образов не представляет труда. В реальных условиях все не так просто: фоновый шум имеет огромную интенсивность и может нарушить процесс отделения слов в потоке речи.
Лучший алгоритм отделения слов — алгоритм Рабинел-Ламель. Если рассматривать стоб-импульсов {s1, s2, …, sn}, где n – число образов строб-импульсов, а si, i=1, n – численное выражение образцов, общая энергия строб-импульсов вычисляется:
Средний уровень пересечения нулевого уровня:
где:
Метод использует три числовых уровня: два для энергии (верхний, нижний) и один для среднего пересечения нулевого уровня. Точка, начиная с которой энергия перекрывает верхний уровень и уровень положительных и отрицательных значений, не отменяет установленный уровень, который считается отправной точкой голосового звучания (не тишины). Поиск первой такой точки производится путем скрещивания импульсов от начала и до конца, и это определит первую область с речью. Обратный переход, из конца в начало, позволяет определить конечную точку последней области с речью. Определение внутри области может быть сделано путем скрещивания импульсов между двумя этими точками. Начало глухой области начинается в точке, в которой энергия становится меньше значения нижнего уровня. Обратите внимание на рисунок ниже, на котором до и после удаления глухой области:
звуковой сигнал слова «nouă»
Определение слов с использованием алгоритма DWT
Определение слова может осуществляться путем сравнения числовых форм сигналов или путем сравнения спектрограммы сигналов. Процесс сравнения в обоих случаях должен компенсировать различные длины последовательности и нелинейный характер звука. DWT алгоритму удается разобрать эти проблемы путем нахождения деформации, соответствующей оптимальному расстоянию между двумя рядами различной длины.
Существуют 2 особенности применения алгоритма:
1. Прямое сравнение числовых форм сигналов. В этом случае, для каждой числовой последовательности создается новая последовательность, размеры которой значительно меньше. Алгоритм имеет дело с этими последовательностями. Числовая последовательность может иметь несколько тысяч числовых значений, в то время как подпоследовательность может иметь несколько сотен значений. Уменьшение количества числовых значений может быть выполнено путем их удаления между угловыми точками. Этот процесс сокращения длины числовой последовательности не должен изменять своего представления. Несомненно, процесс приводит к уменьшению точности распознавания. Однако, принимая во внимание увеличение скорости, точность, по сути, повышается за счет увеличения слов в словаре.
2. Представление сигналов спектрограмм и применение алгоритма DTW для сравнения двух спектрограмм. Метод заключается в разделении цифрового сигнала на некоторое количество интервалов, которые будут перекрываться. Для каждого импульса, интервалы действительных чисел (звуковых частот), будет рассчитывать Быстрым преобразование Фурье, и будет храниться в матрице звуковой спектрограммы. Параметры будут одинаковыми для всех вычислительных операций: длин импульса, длины преобразования Фурье, длины перекрытия для двух последовательных импульсов. Преобразование Фурье является симметрично связанным с центром, а комплексные число с одной стороны связаны с числами с другой стороны. В связи с этим, только значения из первой части симметрии можно сохранить, таким образом, спектрограмма будет представлять матрицу комплексных чисел, количество линий в такой матрице является равной половине длины преобразования Фурье, а количество столбцов будет определяться в зависимости от длины звука. DTW будет применяться на матрице вещественных чисел в результате сопряжения спектрограммы значений, такая матрица называется матрицей энергии.
#### Заключение
DTW алгоритмы являются очень полезными для распознавания отдельных слов в ограниченном словаре. Для распознавания беглой речи используются скрытые модели Маркова. Использование динамического программирования обеспечивает полиминальную сложность алгоритма: О (n2v), где n – длина последовательности, а v количество слов в словаре.
DWT имеют несколько слабых сторон. Во-первых, O (n2v) сложность не удовлетворяет большим словарям, которые увеличивают успешность процесса распознавания. Во-вторых, трудно вычислить два элемента в двух разных последовательностях, если принять во внимание, что существует множество каналов с различными характеристиками. Тем не менее, DTW остается простым в реализации алгоритмом, открытым для улучшений и подходящим для приложений, которым требуется простое распознавание слов: телефоны, автомобильные компьютеры, системы безопасности и т.д.
#### Литература
[1] Benoit Legrand, C.S. Chang, S.H. Ong, Soek-Ying Neo, Nallasivam Palanisamy, Chromosome classification using dynamic time warping, ScienceDirect Pattern Recognition Letters 29 (2008) 215–222
[2] Cory Myers, Lawrence R. Rabiner, Aaron E. Rosenberg, Performance Tradeoffs in Dynamic Time Warping Algorithms for Isolated Word Recognition, Ieee Transactions On Acoustics, Speech, And Signal Processing, Vol. Assp-28, No. 6, December 1980
[3] F. Jelinek. «Continuous Speech Recognition by Statisical Methods.» IEEE Proceedings 64:4(1976): 532-556
[4] Rabiner, L. R., A Tutorial on Hidden Markov Models and Selected Applications in Speech Recognition, Proc. of IEEE, Feb. 1989
[5] Rabiner, L. R., Schafer, R.W., Digital Processing of Speech Signals, Prentice Hall, 1978.
[6] Stan Salvador, Chan, FastDTW: Toward Accurate Dynamic Time Warping in Linear Time
and Space, IEEE Transactions on Biomedical. Engineering, vol. 43, no. 4
[7] Young, S., A Review of Large-Vocabulary Continuous Speech Recognition, IEEE Signal
Processing Magazine, pp. 45-57, Sep. 1996
[8] Sakoe, H. & S. Chiba. (1978) Dynamic programming algorithm optimization for spoken word recognition. IEEE, Trans. Acoustics, Speech, and Signal Proc., Vol. ASSP-26.
[9] Furtună, F., Dârdală, M., Using Discriminant Analisys in Speech Recognition, The Proceedings Of The Fourth National Conference Humman Computer Interaction Rochi 2007, Universitatea Ovidius Constanţa, 2007, MatrixRom, Bucharest, 2007
[10] \* \* \*, Speech Separation by Humans and Machines, Kluwer Academic Publishers, 2005
перевод статьи: [Dynamic Programming Algorithms in Speech Recognition by Titus Felix FURTUNĂ](http://revistaie.ase.ro/content/46/s%20-%20furtuna.pdf) | https://habr.com/ru/post/135087/ | null | ru | null |
# Релиз 11-й версии Asterisk
На финальном дне конференции Astricon 2012, 25 октября, объявлено о релизе 11-й версии Asterisk, которая имеет статус LTS, поддержка обещана до октября 2017-го года. Версия доступна для загрузки с [www.asterisk.org/downloads](http://www.asterisk.org/downloads), пока только в исходном коде.
Из наиболее заметных нововведений:
* поддержка WebRTC (звонки из браузера, нативно)
* логгирование идентификатора звонка в каждой строке всех log-файлов
* новый драйвер Jingle / Google Talk (chan\_motif)
* поддержка кастомных кодеков, генерирование/парсинг SDP параметров
Полный список — [wiki.asterisk.org/wiki/display/AST/New+in+11](https://wiki.asterisk.org/wiki/display/AST/New+in+11)
Видео с демонстрацией звонка на Asterisk IVR из браузера смотреть с [4:23](http://www.youtube.com/watch?v=wy7e2GmVUGc&t=4m23s):
Что касается кодеков, то имеется в виду поддержка подобных конструкций в SDP:
```
a=rtpmap:108 AMR/8000
a=fmtp:108 mode-set=0,2,5,7;mode-change-neighbor=1;mode-change-period=2
a=rtpmap:102 AMR/8000
a=fmtp:102 mode-set=0,2,5,7
```
Кстати, AMR NB кодек в состав Астериска не входит, но существуют патчи, которые удалось адаптировать под 11-ю версию с использованием новых возможностей по парсингу SDP.
А вы уже пробовали новый Астериск? | https://habr.com/ru/post/156653/ | null | ru | null |
# Интерактивная инфографика с анимациями CSS и SVG
Одной из наименее обсуждаемых функций, все чаще появляющейся в последних браузерах, является поддержка файлов формата SVG. Этот формат характеризуется абсолютной свободой в отображении: легко изменяется в размере, может быть отображен в любом разрешении без потери качества. Во многих случаях SVG весят гораздо меньше, чем, например, PNG или JPG.
Но самое клевое свойство SVG, о котором многие разработчики не знают, это то, что этот формат построен на спецификации XML. C помощью этого мы можем манипулировать элементами SVG файла используя технологии вроде CSS или JavaScript, с которыми разработчики уже знакомы.
С правильным применением технологий и современным браузером, разработчики могут создавать впечатляющие анимации и эффекты с помощью SVG. Сегодня мы рассмотрим возможности SVG и создадим интерактивную векторную инфографику, демоверсию которой можно посмотреть [здесь](http://pavel.shimansky.ru/InteractiveSVG/).
#### **Подготовка SVG файла**
Существует множество способов создания графики SVG, начиная от знакомого вам Adobe Illustrator и заканчивая бесплатным Inkscape. Не зависимо от выбора софта, очень важно сгруппировать объекты вместе и дать этим группам имена. Это позволит нам превратить наш SVG в определенную иерархию, которую в дальнейшем мы будем использовать в CSS и/или JavaScript.
В нашем примере, когда мы сохраняем наш SVG и открываем его в текстовом редакторе, мы получим следующую структуру:
```
```
*Код, указанный выше, был нарочно уменьшен для того, чтобы просто показать вам структуру, к которой мы идем. Вы наверняка заметите много знакомого от HTML, но и новые моменты тоже присутствуют.*
Как мы можем видеть, каждый тег содержит группу объектов, которая может быть помещена в другие группы. Конечно, во время создания SVG, не обязательно приписывать id каждому объекту или группе, это делается лишь для того, чтобы в дальнейшем при работе с CSS и JavaScript было легче использовать SVG.
#### **Загрузка SVG в HTML с помощью JavaScript**
##### HTML
Существуют множество способов вставить SVG внутрь HTML. Это возможно осуществить с помощью тега ![](), tag, или даже используя свойство CSS «background-image».
Во-первых, мы создадим div внутри нашего HTML документа:
```
```
##### JavaScript
Затем, используя jQuery.load, мы загрузим SVG файл в див #stage и назначим ему класс svgLoaded, который позднее мы будем использовать для анимирования:
```
$(function(){
$("#stage").load('interactive.svg',function(response){
$(this).addClass("svgLoaded");
if(!response){
// Ошибка при загрузке SVG!
}
});
});
```
***Важно:** Мы загружаем SVG файл с помощью JavaScript, чтобы получить доступ к HTML содержимому файла. Chrome (и возможно другие браузеры) не позволят осуществить это локально; это сработает лишь при использовании протокола HTTP в целях безопасности. Таким образом, если у вас возникнут проблемы с загрузкой SVG файла, убедитесь, что вы тестирует с веб сервера или localhost*
#### **CSS**
*Обратите внимание, что в данном туториале CSS не будет содержать никаких стилей для определенных браузеров, однако вы сможете найти их в исходниках.*
Первое, что мы сделаем, это назначим стили для контейнера div. Стандартное поведение SVG файла при загрузке – изменить свой масштаб по размеру контейнера, поэтому важно настроить параметры контейнера согласно размерам SVG файла.
```
#stage {
width: 1024px;
height: 1386px;
}
```
##### ***Стилизуем элементы SVG: назначаем параметр transform-origin***
Ключ к анимированию элемента в рамках SVG лежит в параметре transform-origin. По умолчанию все трансформации начинаются в точке (0px, 0px). Для каждого элемента, который мы будет трансформировать (например, вращать или масштабировать) нам необходимо назначить параметр transform-origin относительно верхнего левого угла SVG.
```
#coffee {
transform-origin: 517px 484px;
}
#coffee-badge {
transform-origin: 445px 488px;
}
#coffee-title {
transform-origin: 310px 396px;
}
#coffee-details {
transform-origin: 311px 489px;
}
#design {
transform-origin: 514px 603px;
}
#design-badge {
transform-origin: 580px 606px;
}
#design-title {
transform-origin: 712px 513px;
}
#design-details {
transform-origin: 710px 620px;
}
#build {
transform-origin: 511px 769px;
}
#build-badge {
transform-origin: 445px 775px;
}
#build-title {
transform-origin: 312px 680px;
}
#build-details {
transform-origin: 310px 790px;
}
#complain {
transform-origin: 512px 1002px;
}
#complain-badge {
transform-origin: 586px 1000px;
}
#complain-title {
transform-origin: 718px 921px;
}
#complain-details {
transform-origin: 717px 1021px;
}
#beer {
transform-origin: 513px 1199px;
}
#beer-badge {
transform-origin: 444px 1193px;
}
#beer-title {
transform-origin: 313px 1097px;
}
#beer-details {
transform-origin: 316px 1202px;
}
```
##### ***Применяем начальные трансформации***
```
[id$=badge] { /* Каждый элемент с id, заканчивающимся на "badge" */
transform: scale(0.5, 0.5);
}
[id$=title] {
transform: scale(1.8) translate(0px, 48px);
}
[id$=details] {
transform: scale(0, 0);
}
```
##### ***Добавляем :hover и применяем переходы (transitions)***
```
#timeline > g:hover [id$=badge], #timeline > g:hover [id$=details] {
transform: scale(1, 1);
}
#timeline > g:hover [id$=title] {
transform: scale(1) translate(0px, 0px);
}
[id$=badge], [id$=title], [id$=details] {
transition: transform 0.25s ease-in-out;
}
```
##### ***Интро анимация***
```
@keyframes left-brace-intro {
0% {
transform: translateX(220px);
opacity: 0;
}
50% {
opacity: 1;
transform: translateX(220px);
}
100% {
transform: translateX(0px);
}
}
@keyframes right-brace-intro {
0% {
transform: translateX(-220px);
opacity: 0;
}
50% {
opacity: 1;
transform: translateX(-220px);
}
100% {
transform: translateX(0px);
}
}
@keyframes fade-in {
0% {
opacity: 0;
}
100% {
opacity: 1;
}
}
@keyframes grow-y {
0% {
transform: scaleY(0);
}
100% {
transform: scaleY(1);
}
}
@keyframes grow-x {
0% {
transform: scaleX(0);
}
100% {
transform: scaleX(1);
}
}
@keyframes grow {
0% {
transform: scale(0, 0);
}
100% {
transform: scale(1, 1);
}
}
```
##### ***Создаем последовательность анимированного интро***
```
.svgLoaded #logo {
animation: fade-in 0.5s ease-in-out;
}
.svgLoaded #quote-text {
animation: fade-in 0.5s ease-in-out 0.75s;
animation-fill-mode: backwards;
}
.svgLoaded #quote-left-brace {
animation: left-brace-intro 1s ease-in-out 0.25s;
animation-fill-mode: backwards;
}
.svgLoaded #quote-right-brace {
animation: right-brace-intro 1s ease-in-out 0.25s;
animation-fill-mode: backwards;
}
.svgLoaded #background {
animation: grow-y 0.5s ease-in-out 1.25s;
transform-origin: 512px 300px;
animation-fill-mode: backwards;
}
.svgLoaded #background > g {
animation: grow-x 0.25s ease-in-out 1.75s;
animation-fill-mode: backwards;
}
.svgLoaded #background > g:last-of-type {
transform-origin: 458px 877px;
}
.svgLoaded #background > g:first-of-type {
transform-origin: 563px 877px;
}
.svgLoaded #coffee, .svgLoaded #design, .svgLoaded #build, .svgLoaded #complain, .svgLoaded #beer {
animation: grow 0.25s ease-in-out;
animation-fill-mode: backwards;
}
.svgLoaded #coffee {
animation-delay: 2s;
}
.svgLoaded #design {
animation-delay: 2.25s;
}
.svgLoaded #build {
animation-delay: 2.5s;
}
.svgLoaded #complain {
animation-delay: 2.75s;
}
.svgLoaded #beer {
animation-delay: 3s;
}
```
#### **Веб шрифт**
Так как мы использовали нестандартные шрифты, нам надо включить их в нашу веб-странцу для корректного отображения. Для этого требуется правильно указать название шрифта внутри файла SVG:
```
12PM
```
Как мы видим, файл SVG был создан при использованияя шрифта ‘LeagueGothic’, название которого мы просто скопируем в CSS.
```
@font-face {
font-family: 'LeagueGothic';
url("../fonts/league-gothic/league-gothic.eot.woff") format("woff");
}
```
Ну вот и все! Я надеюсь вам понравился наш туториал, и он оказался для вас полезным и информативным. Пишите в комментариях о своих примерах использования SVG и делитесь с нами своим опытом!
[СКАЧАТЬ ИСХОДНИКИ](https://dl.dropbox.com/u/18318518/InteractiveSVG.zip) | [ПОСМОТРЕТЬ ДЕМО](http://pavel.shimansky.ru/InteractiveSVG/)
**От переводчика.** Со всеми пожеланиями и замечаниями по поводу перевода прошу обращаться ко мне в личку. Спасибо! | https://habr.com/ru/post/168681/ | null | ru | null |
# Беспроводной адаптер для программирования Arduino или AVR с загрузчиком на базе ESP8266
Небольшая заметка о самодельном адаптере на базе ESP8266, позволяющем загрузить прошивку в микроконтроллер с установленным UART загрузчиком или Arduino.
Последнее время при проектировании устройств на микроконтроллерах AVR, для программирования вывожу только один 6-пиновый разъем (не ISP) для FTDI адаптера. Он позволяет и загрузить прошивку, и отладиться по UART после прошивки. Именно так сделано в Arduino, идея позаимствована оттуда. Это удобно.
Тем временем, не раз приходилось сталкиваться с ситуацией, когда нужно загрузить прошивку в микроконтроллер, но он уже в корпусе который не помещается на рабочем месте/лежит на антресоли/в другом городе/замурован в стену. В таких случаях адаптер FTDI не применим из-за короткого USB шнурка и приходилось изворачиваться с ноутбуком. Задумался о беспроводном программаторе. Тут как нельзя лучше подойдет ESP8266, ведь он обладает UART и в любом исполнении имеет хотя бы один GPIO, пригодный для перезагрузки контроллера и входа в режим программирования.
В сети был найден следующий материал по теме:
1. [Programming an Arduino via WiFi with the ESP8266](https://garyservin.wordpress.com/2014/12/16/programming-an-arduino-via-wifi-with-the-esp8266/) — модуль типа ESP-01 подключается на проводках к Arduino pro mini, затем для загрузки прошивки используется python скрипт
2. [Programando un Arduino remotamente con el módulo ESP8266](https://www.sistemasorp.es/2014/11/11/programando-un-arduino-remotamente-con-el-modulo-esp8266/) — тут, как я понял, не вдаваясь в подробности, один из GPIO Arduino соединен с RESET. Сначала микроконтроллеру передается команда перезагрузить себя самого, а потом уже начинается загрузка прошивки
3. [ESP8266-transparent-bridge](https://github.com/beckdac/ESP8266-transparent-bridge) — прошивка для ESP8266 делающая из модуля прозрачный Wi-Fi — UART мост с поддержкой AT команд для управления GPIO2. Автор предлагает нажимать кнопку reset на Arduino, а затем запускать avrdude c параметрами -c avrisp и -P net:x.x.x.x:23, но это позволяют автоматизировать AT. Именно эту прошивку я и взял за основу
Характеристики адаптера следующие:
* Шести-пиновый разъем c распиновкой как у адаптера FTDI
**Скрытый текст**
* Работа в схемах с напряжением питания микроконтроллера 3.3В или 5В, выбирается джамперами
* Стабильная работа на скорости до 57600 включительно
* Перезагрузка микроконтроллера при помощи AT команд для входа в режим программирования
Работоспособность проверялась на китайской Arduino pro mini со стоковым загрузчиком и на ATmega8 c установленным [optiboot](https://github.com/Optiboot/optiboot) и скоростях 9600, 19200 и 57600. На скорости по умолчанию (115200) прошиваться контроллер отказался.
##### Для тех, кто не хочет паять и делать плату
В случае применения в схемах с питанием 3.3В достаточно просто присоединить модуль в исполнение esp-01 к Arduino проводками (VCC-->VCC, GND--->GND, RX--->TX, TX--->RX, GPIO2--->DTR). Плата сделана для удобства подключения и возможности работы в схемах с напряжением питания микроконтроллера 5В.
##### Принципиальная схема и печатная плата
Применяется модули типа esp-02, но подойдет и распространенный esp-01, только плату перетрассировать нужно будет слегка. Джамперами выбирается режим работы 3.3/5В. U1 — стабилизатор преобразующий 5В в 3.3В в случае необходимости. R2 и R3 — делитель, тоже для 5В режима. После сборки нужно установить джампер RPOG и при помощи того же FTDI или любого другого UART адаптера загрузить [ESP8266-transparent-bridge](https://github.com/beckdac/ESP8266-transparent-bridge).
Шаблон односторонней печатной платы (SVG вектор):
Если нужен негатив достаточно открыть текстовым редактором и заменить #000000 на #FFFFFF и наоборот.
[В формате KiCad на github](https://github.com/dima-ch/esp-ftdi)
##### Прошивка микроконтроллера
Обычно, чтобы загрузить прошивку следует перезагрузить микроконтроллер. FTDI адаптер делает это импульсом на ноге DTR (первая в разъеме), она через емкость соединена с ногой RESET микроконтроллера. В нашем случае на место DTR выведена GPIO2 (см. UPD). Для перезагрузки микроконтроллера используются AT команды "+++AT GPIO2 1" и затем "+++AT GPIO2 0", которые меняют уровень на GPIO2 ESP8266. Одного перепада достаточно, чтобы перезагрузить контроллер. Сразу после перезагрузки некоторое время работает загрузчик и ждет образ прошивки по UART, его можно передать с помощью утилиты avrdude. Ниже приведен скрипт выполнение которого прошивает контроллер:
```
#!/bin/bash
HEXILE="firmware.hex"
ADDRESS=x.x.x.x
BAUD=57600
echo "+++AT BAUD $BAUD" | nc $(ADDRESS) 23
echo "+++AT GPIO2 1" | nc $(ADDRESS) 23
echo "+++AT GPIO2 0" | nc $(ADDRESS) 23
avrdude -P net:$(ADDRESS):23 -F -U flash:w:$(HEXILE):i
```
Данные команды можно включить в Makefile.
Беспроводную прошивку можно провернуть и в Windows, установив утилиты nc и avrdude.
##### Видео, демонстрирующее работу на примере китайской Arduino pro mini
**UPD**:
[sav13](https://geektimes.ru/users/sav13/) предложил в качестве прошивки для ESP8266 использовать [esp-link](https://github.com/jeelabs/esp-link), она совместима с текущей схемой адаптера. Данная прошивка имеет ряд преимуществ по сравнению с ESP8266-transparent-bridge, в т.ч. WEB интерфейс для конфигурации, нет необходимости использовать AT команды, дополнительный функционал, более подробно [тут](http://samopal.pro/arduino-esp8266/). | https://habr.com/ru/post/392833/ | null | ru | null |
# Регуляризация в ограниченной машине Больцмана, эксперимент
 Привет. В этом посте мы проведем эксперимент, в котором протестируем два типа [регуляризации](http://ru.wikipedia.org/wiki/Регуляризация_(математика)) в [ограниченной машине Больцмана](http://habrahabr.ru/post/159909/). Как оказалось, RBM очень чувствительна к параметрам модели, таким как момент и [локальное поле нейрона](http://habrahabr.ru/post/157179/) (более подробно обо всех параметрах можно прочитать в [практическом руководстве в RBM Джеффри Хинтона](http://www.cs.toronto.edu/~hinton/absps/guideTR.pdf)). Но мне для полной картины и для получения шаблонов наподобие [таких вот](http://deeplearning.net/tutorial/_images/filters_at_epoch_14.png), не хватало еще одного параметра — регуляризации. К ограниченным машинам Больцмана можно относиться и как к разновидности сети Маркова, и как к очередной нейроной сети, но если копнуть глубже, то будет видна аналогия и со зрением. Подобно [первичной зрительной коре](http://ru.wikipedia.org/wiki/%D0%97%D1%80%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BE%D1%80%D0%B0#.D0.9F.D0.B5.D1.80.D0.B2.D0.B8.D1.87.D0.BD.D0.B0.D1.8F_.D0.B7.D1.80.D0.B8.D1.82.D0.B5.D0.BB.D1.8C.D0.BD.D0.B0.D1.8F_.D0.BA.D0.BE.D1.80.D0.B0_.28V1.29), получающей информацию от сетчатки через зрительный нерв (да простят меня биологи за такое упрощение), RBM ищет простые шаблоны во входном изображении. На этом аналогия не заканчивается, если очень малые и нулевые веса интерпретировать как отсутствие веса, то мы получим, что каждый скрытый нейрон RBM формирует некоторое [рецептивное поле](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%86%D0%B5%D0%BF%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%BB%D0%B5), а [сформированная из обученных RBM глубокая сеть](http://habrahabr.ru/post/163819/) формирует из простых образов более комплексные признаки; чем-то подобным, в принципе, и занимается [зрительная кора головного мозга](http://ru.wikipedia.org/wiki/%D0%97%D1%80%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BE%D1%80%D0%B0), правда, вероятно, как то посложнее =)
#### L1 и L2 регуляризация
Начнем мы, пожалуй, с краткого описания того, что такое регуляризация модели — это способ наложить штраф к целевой функции за сложность модели. С байесовской точки зрения — это способ учесть некоторую априорную информацию о распределении параметров модели. Важным свойством является то, что регуляризация помогает избежать переобучения модели. Обозначим параметры модели как θ = {θ\_i}, i=1..n. Итоговая целевая функция **C = η(E + λR)**, где **E** — это основная целевая функция модели, **R = R(θ)** — функция от параметров модели, *эта* и *лямбда* — это скорость обучения и параметр регуляризации соответственно. Таким образом, для вычисления градиента итоговой целевой функции будет необходимо вычислить градиент функции регуляризации:
Мы рассмотрим два вида регуляризации, корни которых находятся в [Lp метрике](http://en.wikipedia.org/wiki/Lp_space). Функция регуляризации L1 и ее производные имеют следующий вид:
L2 регулярицазия выглядит следующим образом:
Оба метода регуляризации штрафуют модель за большое значение весов, в первом случае абсолютными значениями весов, во втором квадратами весов, таким образом, распределение весов будет приближаться к нормальному с центром в нуле и большим пиком. Более подробное сравнение L1 и L2 [можно почитать тут](http://cs.nyu.edu/~rostami/presentations/L1_vs_L2.pdf). Как мы позже увидим, около 70% весов будут меньше 10^(-8).
#### Регуляризация в RBM
В позапрошлом посте я описывал [пример реализации RBM на C#](http://habrahabr.ru/post/159909/). Я буду опираться на ту же реализацию для того, чтобы показать, куда встраивается регуляризация, но сначала формулы. Целью обучения RBM является максимизация вероятности того, что восстановленный образ будет идентичен входному:
Вообще говоря, в алгоритме максимизируется логарифм вероятности, и чтобы внести штраф, необходимо вычесть значение функции регуляризации из полученной вероятности, в итоге новая целевая функция приобретает следующий вид:
Производная такой функции по параметру будет выглядить так:
Алгоритм contrastive divergence состоит из положительной фазы и отрицательной, таким образом, для того, чтобы добавить регуляризацию, достаточно вычесть значение производной функции регуляризации и из значения положительной фазы, после вычитания отрицательной фазы:
**positive and negative phases**
```
#region Gibbs sampling
for (int k = 0; k <= _config.GibbsSamplingChainLength; k++)
{
//calculate hidden states probabilities
hiddenLayer.Compute();
#region accumulate negative phase
if (k == _config.GibbsSamplingChainLength)
{
for (int i = 0; i < visibleLayer.Neurons.Length; i++)
{
for (int j = 0; j < hiddenLayer.Neurons.Length; j++)
{
nablaWeights[i, j] -= visibleLayer.Neurons[i].LastState *
hiddenLayer.Neurons[j].LastState;
if (_config.RegularizationFactor > Double.Epsilon)
{
//regularization of weights
double regTerm = 0;
switch (_config.RegularizationType)
{
case RegularizationType.L1:
regTerm = _config.RegularizationFactor*
Math.Sign(visibleLayer.Neurons[i].Weights[j]);
break;
case RegularizationType.L2:
regTerm = _config.RegularizationFactor*
visibleLayer.Neurons[i].Weights[j];
break;
}
nablaWeights[i, j] -= regTerm;
}
}
}
if (_config.UseBiases)
{
for (int i = 0; i < hiddenLayer.Neurons.Length; i++)
{
nablaHiddenBiases[i] -= hiddenLayer.Neurons[i].LastState;
}
for (int i = 0; i < visibleLayer.Neurons.Length; i++)
{
nablaVisibleBiases[i] -= visibleLayer.Neurons[i].LastState;
}
}
break;
}
#endregion
//sample hidden states
for (int i = 0; i < hiddenLayer.Neurons.Length; i++)
{
hiddenLayer.Neurons[i].LastState = _r.NextDouble() <= hiddenLayer.Neurons[i].LastState ? 1d : 0d;
}
#region accumulate positive phase
if (k == 0)
{
for (int i = 0; i < visibleLayer.Neurons.Length; i++)
{
for (int j = 0; j < hiddenLayer.Neurons.Length; j++)
{
nablaWeights[i, j] += visibleLayer.Neurons[i].LastState*
hiddenLayer.Neurons[j].LastState;
}
}
if (_config.UseBiases)
{
for (int i = 0; i < hiddenLayer.Neurons.Length; i++)
{
nablaHiddenBiases[i] += hiddenLayer.Neurons[i].LastState;
}
for (int i = 0; i < visibleLayer.Neurons.Length; i++)
{
nablaVisibleBiases[i] += visibleLayer.Neurons[i].LastState;
}
}
}
#endregion
//calculate visible probs
visibleLayer.Compute();
}
#endregion
}
#endregion
```
Переходим к экспериментам. В качестве тестовых данных использовался тот же набор, что и в [позапрошлом посте](http://habrahabr.ru/post/159909/). Во всех случаях обучение проводилось ровно 1000 эпох. Я буду приводить два способа визуализации найденных шаблонов, в первом случае (рисунок в серых тонах) темное значение соответствует минимальному значению веса, а белый максимальному; во втором рисунке черный соответствует нулю, увеличение красной составляющей соответствует увеличению в положительную сторону, а увеличение синей составляющей — в отрицательную. Так же я буду приводить гистограмму распределения весов и небольшие комментарии.
#### Без регуляризации
* значение ошибки на обучающем наборе: 0.188181367765024
* значение ошибки на кроссвалидационном наборе: 21.0910315518859
Шаблоны получились очень размытые, и трудно анализируемые. Среднее значение весов сдвинуто влево, а абсолютное значение весов достигает 2 и более.
#### L2 регуляризация
* значение ошибки на обучающем наборе: 10.1198906337165
* значение ошибки на кроссвалидационном наборе: 23.3600809429977
* параметр регуляризации: 0.1
Здесь мы наблюдаем более четкие образы. Мы уже можем разглядеть, что на некоторых образах действительно учитываются какие-то особенности букв. Несмотря на то, что ошибка на обучающем наборе в 100 раз хуже, чем при обучении без регуляризации, ошибка на кроссвалидационном множестве не намного превышает первый эксперимент, что говорит о том, что обобщающая способность сети на незнакомых образах не сильно ухудшилась (стоит заметить, что в подсчет ошибки не включалось значение функции регуляризации, что позволяет нам сравнивать значения с предыдущем опытом). Веса сконцентрированы вокруг нуля, и не сильно превышают 0.2 по абсолютному значению, что в 10 раз меньше, чем в предыдущем опыте.
#### L1 регуляризация
* значение ошибки на обучающем наборе: 4.42672814826447
* значение ошибке на кроссвалидационном наборе: 17.3700437102876
* параметр регуляризации: 0.005
В данном опыте мы наблюдаем четкие шаблоны, а в особенности рецептивные поля (вокруг сине-красных пятен все веса почти равны нулю). Шаблоны даже поддаются анализу, мы можем заметить, например, ребра от W (первый ряд четвертая картинка), или же шаблон, который отражает средний размер входных образов (в пятом ряду 8 и 10 картинка). Ошибка восстановления на обучающем множестве в 40 раз хуже чем в первом эксперименте, но лучше чем при L2 регуляризации, в то же время ошибка на неизвестном множестве лучше, чем в обоих предыдущих опытах, что говорит о еще лучшей обобщающей способности. Веса так же сконцентрированы вокруг нуля, и в большинстве случаев не сильно его превышают. Существенное отличие в параметре регуляризации объясняется тем, что при вычислении градиента для L2 параметр умножается на значение веса, как правило эти оба числа меньше 1; но при L1 параметр умножается на |1|, и и итоговое значение будет того же порядка что и параметр регуляризации.
#### Заключение
В качестве заключения хочется сказать что РБМ действительно очень чувствительная к параметрам вещь. И главное — не сломаться в процессе поиска решения -) В конце приведу увеличенное излбражение одной из RBM тренировавшихся с L1 регуляризацией, но уже в течении 5000 эпох.
**UPDATE**:
недавно обучил рбм на полном наборе больших букв 4 шрифтов 3 стилей, в течении 5000 итераций с L1 регуляризацией, это заняло около 14 часов, но результат еще интереснее, фичи получились еще более локальные и чистые
 | https://habr.com/ru/post/175819/ | null | ru | null |
# Безбраузерные приложения на Javascript (HTA)
Одна из мощнейших средств Ослика (начиная с пятой (!) версии) — HTA или HTML Application (безбраузерные приложения), позволяет создавать Windows-приложения используя HTML, CSS и Javascript/VBscript. Сразу хочу заметить, что в этой статье используется исключительно Javascript.
С точки зрения пользователя, созданная «программа» ничем, кроме расширения (\*.hta), не отличается от любой другой программы: заголовок окна, иконка, отображение на панели задач, а самое главное никаких предупреждений при доступе к файлам компьютера. При всем этом вам не придется устанавливать никаких отдельных приложений или плагинов, достаточно Internet Explorer-а!
Далее представлен код простой HTA-программы. Скопируйте его в любой текстовый редактор, *перед сохранением **обязательно** проверьте все кавычки сгенерированные хабра-редактором, и «HTA:Application» напишите слитно без пробелов (т.к. хабра-редактор ставит пробел после двоеточия)*! Далее сохраните с расширением \*.hta и запустите.
**ВНИМАНИЕ! Пробел или перевод строки перед обратным слешем «/>» тоже обязателен!**
`моя программа
applicationName=myApp />
style="border: none;
font: 8pt sans-serif"
scroll=no text=buttontext>
Hello world!`
Разница всего лишь в одном теге заголовка , и в расширении \*.hta. А каков результат?
Параметры тега HTA:Application позволяют управлять видом созданным приложения. Если тег и/или параметры не заданы, то значения параметров назначаются по-умолчанию.
| Параметр в `HTML` | в `JScript` | Значение(я)
(*по умолчанию*) | Обозначение |
| --- | --- | --- | --- |
| `APPLICATIONNAME` | applicationName | строка
(*нет*) | Уникальное имя приложения. |
| `INNERBORDER` | innerBorder | yes, no
(*yes*) | Наличие внутреннего бордюра. |
| `BORDERSTYLE` | borderStyle | normal, complex, raised, static, sunken
(*normal*) | Внутренний тип бордюра. |
| `BORDER` | border | thick, dialog, thin, none
(*thick*) | Наружный тип бордюра. |
| `CAPTION` | caption | yes, no
(*yes*) | Наличие заголовка. |
| *Нет* | commandLine | Только для чтения.
(*полный путь к данному "\*.hta"*) | Содержимое командной строки. |
| `CONTEXTMENU` | contextMenu | yes, no
(*yes*) | Контекстное меню при клике правой кнопкой мыши. |
| `SELECTION` | selection | yes, no
(*yes*) | Возможность выделения текста внутри `HTA`. |
| `ICON` | icon | URL
(*нет*) | Путь к иконке (*\*.ico*). |
| `MAXIMIZEBUTTON` | maximizeButton | yes, no
(*yes*) | Наличие кнопки «развернуть». |
| `MINIMIZEBUTTON` | minimizeButton | yes, no
(*yes*) | Наличие кнопки «свернуть». |
| `SCROLL` | scroll | yes, no, auto
(*yes*) | Наличие скроллинга. |
| `SCROLLFLAT` (*IE 5.5+*) | scrollFlat | yes, no
(*no*) | Cтиль скроллинга. |
| `SHOWINTASKBAR` | showInTaskBar | yes, no
(*yes*) | Отображение в панели задач. |
| `SINGLEINSTANCE` | singleInstance | yes, no
(*no*) | Запретить запуск второго экземпляра. |
| `SYSMENU` | sysMenu | yes, no
(*нет*) | Наличие системного меню. |
| `VERSION` | version | строка
(*нет*) | Версия `HTA`. |
| `WINDOWSTATE` | windowState | normal, minimize, maximize
(*normal*) | Начальное состояние окна. |
| `NAVIGABLE` (*IE 5.5+*) | navigable | yes, no
(*no*) | Переход по ссылке произойдет в окне `HTA`. |
> *Примечание*:
>
> Если не указать параметр `BORDER` или указать `BORDER="thick"`, то размеры окна программы можно будет изменять при помощи мыши, в остальных же случаях (`BORDER = thin || dialog || none`), размеры окна изменить нельзя.
Как вы видете, MS-овцы забыли добавить самые, по-моему, нужные параметры типа: `winWidth`, `winHeight`, `winPositionX` и `winPositionY`. Но это можно *вылечить* самим.
В примере, я постараюсь показать тот минимум, чтобы хотябы завлечь вас…
`applicationName=hta\_name
showInTaskBar=no
caption=no
innerBorder=no
selection=no
scroll=no
contextmenu=no />
<br/>
var winWidth=450; // ширина окна<br/>
var winHeight=120; // высота окна<br/>
// изменяем размер<br/>
window.resizeTo(winWidth, winHeight);<br/>
<br/>
// окно в центр экрана<br/>
var winPosX=screen.width/2-winWidth/2;<br/>
var winPosY=screen.height/2-winHeight/2;<br/>
window.moveTo(winPosX, winPosY);<br/>
style="padding: 2px;font: 8pt 'MS Sans serif'">
Вглядитесь повнимательней на панель задач...
Ой, а меня, там нету...
Для выхода нажмите ALT+F4.`
Сегодня на этом все.
*Дополнительную информацию найдете в [библиотеке MSDN](http://msdn.microsoft.com/en-us/library/ms536496(VS.85).aspx).* | https://habr.com/ru/post/40707/ | null | ru | null |
# Re: Хороши ли Яндекс.Фотки?
Мне очень понравился [пост](http://habrahabr.ru/blog/yandex/43765.html) [linker](https://geektimes.ru/users/linker/)’а с просьбой дать фидбэк по поводу Яндекс.Фоток, и его серьёзное отношение к комментариям пользователей. Я, например, ответил где-то там трёхсотым с чем-то комментарием, и был практически уверен, что его никто так и не прочитает. Но linker ответил, и даже довольно подробно, и даже попросил меня пояснить некоторые вещи.
Как и в случае с многоточием, мой комментарий вырос в нечто большее, и я решил сделать макет улучшенных Яндес.Фоток в фотошопе, и написать по этому поводу отдельный пост, т.к. хотелось бы услышать общественное мнение о том, что я склепал (да и linker’у будет полезно в лишний раз почитать ваши мнения).
[](http://img-fotki.yandex.ru/get/3/pureby.0/0_cfa3_4c16e5c5_orig)
Всё главное сказано скриншотом (и *на* скриншоте :) ), но я, пожалуй, приложу ещё немного текста…
Итак, как вы видите, я очень серьёзно отношусь к минимализму и порядку в интерфейсах, что заметно уже в моём браузере. Но я поставил себе задачу не выкидывать и кардинально не менять никаких элементов в моём макете Яндекс.Фоток, а лишь переорганизовать их таким образом, чтобы было больше свободного места, и чтобы элементы не были налеплены друг на друга (это я более подробно описал в моём оригинальном [комментарии к посту linker’а](http://habrahabr.ru/blog/yandex/43765.html#comment895390)).
Выкинул я лишь «Свежие фотки», потому что они совсем не нужны на странице, в которой ты *уже* просматриваешь какую-то конкретную фотографию. А вот на главной странице автора этот элемент полезен.
Что же касается не дизайна, а функциональности, то у нас с linker’ом появились разногласия по поводу постоянно перезагружающейся с нуля статической страницы. Тут я буду драться всеми руками и ногами за то, что *перезагружаться должна **не** страница целиком, а лишь то, что **должно** перезагружаться,* а именно: сама фотография со всеми её прибамбасами (метками, комментариями, и т.д. и т.п.)
При этом, если ты смотришь на фотографию №1, и кликнул на фотографию №2, то фотография №1 должна оставаться в поле зрения до тех пор, пока фотография №2 (со всеми её прибамбасами) не загрузится полностью, *и лишь в тот момент* изображение должно поменяться — за миллисекунду.
Почему именно так? *Потому, что мы живём уже не в 90-х.* А более подробно (и более скучно) я это описал, опять-таки, в моём оригинальном комментарии к посту linker’а.
И последняя (но немаловажная!) деталь: очень хотелось бы, чтобы при сохранении фоток имя файла не менялось на нечто вроде "`46dsad456_5d5ads55s_d354ds_orig.jpg`", а оставалось оригинальным.
Высказывайте свои мнения! | https://habr.com/ru/post/26908/ | null | ru | null |
# Превращаем Ubuntu Server в контроллер домена с помощью samba-tool
Как быть, если и контроллер домена нужен, и сэкономить хочется? Сегодня мы представим вашему вниманию один из ответов на этот вопрос. Речь пойдёт о пакете Samba, об Ubuntu Server, и о том, как всё это быстро и правильно настроить.
[](https://habrahabr.ru/company/ruvds/blog/323860/)
С помощью Samba можно превратить сервер, работающий под управлением ОС семейства Linux, в контроллер домена (Domain Controller, DC) Active Directory. Тот DC, который мы собираемся поднять, сможет работать как контроллер домена Windows NT4. Он подойдёт для централизованного хранения данных учётных записей пользователей и компьютеров.
Надо отметить, что мы не будем говорить о задаче создания основного контроллера домена (Primary Domain Controller, PDC) Active Directory, хотя связка Ubuntu Server/Samba, рассмотренная здесь (с добавлением OpenLDAP) вполне может играть и такую роль.
Итак, наша цель — быстро и экономично обзавестись AD DC. В этом нам поможет интерактивный инструмент `samba-tool`, который предназначен для автоматизированной подготовки сервера к работе, а именно, он позволяет сформировать файл настроек `/etc/smb.conf`.
Начнём с установки необходимого ПО.
Установка
---------
Первый шаг — установка на сервер пакетов Samba и Winbind. Сделать это можно с помощью следующей команды:
```
sudo apt install samba libpam-winbind
```
Время установки невелико, даже с учётом того, что системе может понадобиться загрузить некоторые зависимости.
После установки можно приступать к настройкам.
Подготовка к настройке
----------------------
Перед запуском `samba-tool` нужно проверить файл `/etc/hosts`, а именно — верны ли записанные в нём полное доменное имя и IP-адрес контроллера домена. Там можно найти что-то вроде этого:
```
127.0.0.1 localhost.localdomain
IP_ADDRESS_OF_SERVER localhost
IP_ADDRESS_OF_SERVER SAMBADOM.EXAMPLE.NET
SAMBADOM
```
Здесь `IP_ADDRESS_OF_SERVER` — это реальный адрес сервера Samba. Проверьте, чтобы файл содержал актуальные данные.
Далее нужно задать имя узла для сервера. Как можно судить по приведённому выше фрагменту файла `/etc/hosts`, в нашем случае имя узла — `SAMBADOM`. Для того, чтобы его настроить, откройте файл `/etc/hostname` и соответствующим образом его измените. Далее — перезагрузите сервер.
После того, как сервер перезагрузится, нужно удалить существующий файл `smb.conf`, а так же — любые файлы баз данных Samba (это `.tdb` и `.ldb`-файлы). Для того, чтобы найти директории, содержащие эти файлы, выполните следующие команды:
```
mbd -b | grep "CONFIGFILE"
smbd -b | egrep "LOCKDIR|STATEDIR|CACHEDIR|PRIVATE_DIR"
```
На рисунке ниже показаны результаты исполнения этих команд, которыми можно будет воспользоваться для того, чтобы удалить ненужные файлы. Если же подобные файлы в системе не существуют — можно сразу двигаться дальше.
*Поиск файлов, которые надо удалить*
Использование samba-tool
------------------------
Теперь пришло время воспользоваться `samba-tool`. Мы запустим это средство в интерактивном режиме, выполнив следующую команду:
```
sudo samba-tool domain provision --use-rfc2307 --interactive
```
Выполнив команду с ключом `--use-rfc2307`, мы включаем расширения NIS. `Samba-tool` предложит настроить следующие параметры:
* `Realm`. Это полное DNS-имя домена, которое настроено в файле `hosts`. Например: `SAMBADOM.EXAMPLE.NET`.
* `Domain`. Доменное имя NetBIOS сервера Samba. Обратите внимание на то, что здесь рекомендуется использовать первую часть доменного имени DNS. Например, `SAMBADOM`.
* `Server Role`. Этот параметр предназначен для указания типа серверной роли. По умолчанию здесь установлено значение `dc`, оно нас устроит.
* `DNS backend`. Этот параметр позволяет настроить DNS-сервер. Здесь так же оставляем параметр по умолчанию — `SAMBA_INTERNAL`.
* `DNS forwarder IP address`. Данный параметр позволяет указать IP-адрес DNS-сервера, на который будут перенаправлены запросы, которые не может разрешить сервер Samba. Если перенаправление DNS-запросов вам не нужно — ничего не вводите в ответ на данный вопрос. Подробнее об этом можно почитать [здесь](https://wiki.samba.org/index.php/Samba_Internal_DNS_Back_End#Setting_up_a_DNS_Forwarder).
* `Administrator password`. Тут надо указать пароль администратора домена.
После того, как система получит ответы на интересующие её вопросы, `samba-tool` настроит Samba как контроллер домена. Можете просмотреть файл `/etc/samba/smb.conf` и, если нужно, внести в него изменения.
Прежде чем продолжать, позаботьтесь о регистрации пользователей в Samba. Этот шаг очень важен — иначе пользователям не удастся пройти аутентификацию. Делается это следующими командами:
```
smbpasswd -a USERNAME
smbpasswd -e USERNAME
```
Здесь `USERNAME` — имя существующего пользователя, которого надо добавить к Samba. Указать пароль нужно будет лишь после ввода первой команды. Первая команда добавляет нового пользователя и запрашивает пароль для него; вторая — активирует созданный аккаунт.
Настройка DNS-сервера
---------------------
Нам надо, чтобы в качестве DNS-сервера на контроллере домена использовался он сам. Для того, чтобы это сделать, отредактируем файл `/etc/network/interfaces`, приведя его к такому виду:
```
auto INTERFACE_NAME
iface INTERFACE_NAME inet static
address IP_ADDRESS_FOR_SERVER
netmask NETMASK
gateway GATEWAY
dns-nameservers IP_ADDRESS_FOR_SERVER
```
Тут же имеются настройки использования сетевым интерфейсом статического IP-адреса. Обратите внимание на то, что всё, набранное ЗАГЛАВНЫМИ буквами, надо настроить в соответствии с параметрами вашей системы.
После выполнения настроек перезапустите сетевые сервисы такой командой:
```
sudo service networking restart
```
Кроме того, следует отредактировать файл `/etc/resolv.conf`, внеся изменения, согласующиеся с теми, о которых было сказано выше. А именно, тут нас интересует следующая строка:
```
nameserver IP_ADDRESS_FOR_SERVER
```
Здесь, вместо `IP_ADDRESS_FOR_SERVER`, нужно ввести тот же адрес, который был записан в параметр `dns-nameservers` выше.
Настройка Kerberos
------------------
У Kerberos имеется собственный стандартный конфигурационный файл, который нужно заменить файлом `krb5.conf`, сгенерированным в ходе подготовки Samba к работе. Для того, чтобы это сделать, выполните следующие команды:
```
sudo mv /etc/krb5.conf /etc/krb5.conf.orig
sudo ln -sf /var/lib/samba/private/krb5.conf /etc/krb5.conf
```
Обратите внимание на то, что вы можете столкнуться с отсутствием в системе файла `/etc/krb5.conf`. Если это действительно так, достаточно будет выполнить только вторую из вышеприведённых команд.
Тестируем и подключаемся
------------------------
Самое сложное позади. Теперь всё готово к тому, чтобы протестировать только что созданный контроллер домена на Samba и подключиться к нему. Быстро проверить, всё ли работает, можно с помощью такой команды:
```
smbclient -L localhost -U%
```
После ввода пароля пользователя Samba, вы должны увидеть сообщение об успешном подключении.
*Успешное подключение*
Как видите, при проверке `smbclient` выведены сведения о `netlogon` и `sysvol` как об общих ресурсах. Они созданы по умолчанию и должны существовать на контроллере домена. Кроме того, в `/var/lib/samba/sysvol/REALM/scripts` следует поместить любые скрипты входа в систему, которые понадобятся клиентам. Здесь `REALM` соответствует тому параметру `REALM`, который был задан в ходе работы с командой `samba-tool`.
Итоги
-----
Теперь контроллер домена готов принимать подключения. Однако, может оказаться так, что вам придётся отредактировать файл `/etc/samba/smb.conf`, внести в него данные, отражающие ваши требования к серверу. Этот файл, сгенерированный `samba-tool`, весьма лаконичен, хотя и является хорошей отправной точкой для тонкой настройки вашего AD DC, построенного на базе Samba и Ubuntu Server.
Уважаемые читатели! А какие варианты взаимодействия экосистем Linux и Windows кажутся вам наиболее интересными и полезными? | https://habr.com/ru/post/323860/ | null | ru | null |
# PHP Xdebug proxy: когда стандартных возможностей Xdebug не хватает
Для отладки PHP-программ часто используют [Xdebug](https://xdebug.org/). Однако стандартных возможностей IDE и Xdebug не всегда достаточно. Часть проблем можно решить с помощью Xdebug proxy — pydbgpproxy, но всё же не все. Поэтому я реализовал [PHP Xdebug proxy](https://github.com/mougrim/php-xdebug-proxy) на базе асинхронного фреймворка amphp.
Под катом я расскажу, что не так с pydbgpproxy, чего в нём не хватает и почему я не стал его дорабатывать. Также объясню, как работает PHP Xdebug proxy, и покажу на примере, как его расширять.
Pydbgpproxy vs PHP Xdebug proxy
-------------------------------
Xdebug proxy является промежуточным сервисом между IDE и Xdebug (проксирует запросы от Xdebug к IDE и обратно). Чаще всего он используется для [multiuser debugging](https://www.jetbrains.com/help/phpstorm/multiuser-debugging-via-xdebug-proxies.html). Это когда у вас один веб-сервер, а разработчиков — несколько.
В качестве proxy обычно используют pydbgpproxy. Но у него есть несколько проблем:
* нет официальной страницы;
* тяжело найти, где его скачивать; оказывается, это можно сделать [здесь](http://code.activestate.com/komodo/remotedebugging/) — внезапно, Python Remote Debugging Client;
* официального репозитория я не нашёл;
* как следствие предыдущего пункта, непонятно, куда приносить pull request;
* proxy, как видно из названия, написан на Python, который знают далеко не все PHP-шники, а значит, расширять его — это проблема;
* продолжение предыдущего пункта: если есть какой-то код на PHP, и его нужно будет использовать в proxy, то его придется портировать на Python, а дублирование кода — это всегда не очень хорошо.
Поиск Xdebug proxy, написанного на PHP, на GitHub и в интернете результатов не дал. Поэтому я написал [PHP Xdebug proxy](https://github.com/mougrim/php-xdebug-proxy). Под капотом я использовал асинхронный фреймворк [amphp](https://amphp.org/).
Основные преимущества PHP Xdebug proxy перед pydbgpproxy:
* PHP Xdebug proxy написан на хорошо знакомом PHP-шникам языке, а значит:
+ в нём легче решать проблемы;
+ его легче расширять;
* у PHP Xdebug proxy есть публичный репозиторий, а значит:
+ можно форкнуть и допилить его под свои нужды;
+ можно прислать pull request с недостающей фичей или решением какой-либо проблемы.
Как работать с PHP Xdebug proxy
-------------------------------
### Установка
PHP Xdebug proxy можно установить как dev-зависимость через [composer](https://getcomposer.org/):
```
composer.phar require mougrim/php-xdebug-proxy --dev
```
Но если вы не хотите тащить в свой проект лишние зависимости, то PHP Xdebug proxy можно установить как проект через тот же composer:
```
composer.phar create-project mougrim/php-xdebug-proxy
cd php-xdebug-proxy
```
PHP Xdebug proxy расширяемый, но по умолчанию для работы требуется [ext-dom](https://secure.php.net/manual/ru/book.dom.php) (расширение включено по умолчанию в PHP) для разбора XML и [amphp/log](https://github.com/amphp/log) для асинхронной записи в логи:
```
composer.phar require amphp/log '^1.0.0'
```
### Запуск
Запускается proxy следующим образом:
```
bin/xdebug-proxy
```
Proxy запустится с настройками по умолчанию:
```
Using config path /path/to/php-xdebug-proxy/config
[2019-02-14 10:46:24] xdebug-proxy.NOTICE: Use default ide: 127.0.0.1:9000 array ( ) array ( )
[2019-02-14 10:46:24] xdebug-proxy.NOTICE: Use predefined ides array ( 'predefinedIdeList' => array ( 'idekey' => '127.0.0.1:9000', ), ) array ( )
[2019-02-14 10:46:24] xdebug-proxy.NOTICE: [Proxy][IdeRegistration] Listening for new connections on '127.0.0.1:9001'... array ( ) array ( )
[2019-02-14 10:46:24] xdebug-proxy.NOTICE: [Proxy][Xdebug] Listening for new connections on '127.0.0.1:9002'... array ( ) array ( )
```
Из лога видно, что по умолчанию proxy:
* прослушивает `127.0.0.1:9001` для подключений регистраций IDE;
* прослушивает `127.0.0.1:9002` для подключений Xdebug;
* использует `127.0.0.1:9000` как IDE по умолчанию и предустановленную IDE с ключом idekey.
### Конфигурация
Если есть желание настроить прослушиваемые порты и т. д., то можно указать путь до папки с настройками. Достаточно скопировать папку [config](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/config):
```
cp -r /path/to/php-xdebug-proxy/config /your/custom/path
```
В папке с настройками три файла:
* [`config.php`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/config/config.php):
```
php
return [
'xdebugServer' = [
// host:port для прослушивания подключений Xdebug
'listen' => '127.0.0.1:9002',
],
'ideServer' => [
// Если proxy не может найти IDE, то он будет использовать IDE по умолчанию,
// если нужно отключить IDE по умолчанию, то нужно передать пустую строку.
// IDE по умолчанию полезна, когда proxy пользуется только один человек.
'defaultIde' => '127.0.0.1:9000',
// Предопределённые IDE указываются в формате 'idekey' => 'host:port',
// если предопределённые IDE не нужны, то можно указать пустой массив.
// Предопределённые IDE полезны, когда пользователи proxy меняются нечасто,
// так им не нужно будет заново регистрироваться при каждом перезапуске proxy.
'predefinedIdeList' => [
'idekey' => '127.0.0.1:9000',
],
],
'ideRegistrationServer' => [
// host:port для прослушивания подключений регистраций IDE,
// если требуется отключить регистрации IDE, то нужно передать пустую строку.
'listen' => '127.0.0.1:9001',
],
];
```
* [`logger.php`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/config/logger.php): можно настроить логгер; файл должен возвращать объект, который является экземпляром `\Psr\Log\LoggerInterface`, по умолчанию используется `\Monolog\Logger` с `\Amp\Log\StreamHandler` (для неблокирующей записи), выводит логи в stdout;
* [`factory.php`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/config/factory.php): можно настроить классы, которые используются в proxy; файл должен возвращать объект, который является экземпляром [`Factory\Factory`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/Factory/Factory.php), по умолчанию используется [`Factory\DefaultFactory`](https://github.com/mougrim/php-xdebug-proxy/blob/0.4.0/src/Factory/DefaultFactory.php).
После копирования файлы можно отредактировать и запустить proxy:
```
bin/xdebug-proxy --configs=/your/custom/path/config
```
### Отладка
О том, как отлаживать код с помощью Xdebug, написано много статей. Отмечу основные моменты.
В php.ini должны быть следующие настройки в секции `[xdebug]` (исправьте их, если они отличаются от стандартных):
* idekey=idekey
* remote\_host=127.0.0.1
* remote\_port=9002
* remote\_enable=On
* remote\_autostart=On
* remote\_connect\_back=Off
Дальше можно запускать отлаживаемый PHP-код:
```
php /path/to/your/script.php
```
Если вы всё правильно сделали, то отладка начнётся с первого breakpoint в IDE. Отладка в режиме php-fpm несколькими разработчиками выходит за рамки данной статьи, но описана, например, [здесь](https://www.jetbrains.com/help/phpstorm/multiuser-debugging-via-xdebug-proxies.html).
Расширение функций proxy
------------------------
Всё, что мы рассмотрели выше, в той или иной степени умеет и pydbgpproxy.
Теперь поговорим о самом интересном в PHP Xdebug proxy. Прокси можно расширять, используя свою фабрику (создаётся в конфиге `factory.php`, см. выше). Фабрика должна реализовывать интерфейс [`Factory\Factory`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/Factory/Factory.php).
Наиболее мощными являются так называемые подготовители запросов (request preparers). Они могут изменять запросы от Xdebug к IDE и обратные. Чтобы добавить подготовитель запроса, нужно переопределить метод `Factory\DefaultFactory::createRequestPreparers()`. Метод возвращает массив объектов, которые реализовывают интерфейс [`RequestPreparer\RequestPreparer`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/RequestPreparer/RequestPreparer.php). При проксировании запроса от Xdebug к IDE они выполняются в прямом порядке, при проксировании запроса от IDE к Xdebug — в обратном.
Подготовители запросов могут использоваться, например, для изменения путей до файлов (в breakpoints и выполняемых файлах).
### Дебаг переписанных файлов
Для того, чтобы привести пример подготовителя, сделаю небольшое отступление. В unit-тестах мы используем [soft-mocks](https://habr.com/ru/company/badoo/blog/279617/) ([GitHub](https://github.com/badoo/soft-mocks)). Soft-mocks позволяет подменять функции, статические методы, константы и т. д. в тестах, является альтернативой для [runkit](http://php.net/manual/ru/book.runkit.php) и [uopz](http://php.net/manual/ru/book.uopz.php). Работает это за счет переписывания PHP-файлов на лету. Подобным образом ещё работает [AspectMock](https://github.com/Codeception/AspectMock).
Но стандартные возможности Xdebug и IDE позволяют отлаживать переписанные (имеющие другой путь), а не оригинальные файлы.
Рассмотрим подробнее проблему отладки с использованием soft-mocks в тестах. Для начала возьмём случай, когда PHP-код выполняется локально.
Первые сложности появляются на этапе установки точек останова (breakpoints). В IDE они устанавливаются в оригинальные файлы, а не в переписанные. Чтобы поставить breakpoint через IDE, нужно найти актуальный переписанный файл. Проблема усугубляется тем, что при каждом изменении оригинального файла создаётся новый переписанный файл, то есть для каждого уникального содержимого файла будет уникальный переписанный файл.
Эту проблему можно решить вызовом функции `xdebug_break()`, которая аналогична выставлению точки останова. Необходимость поиска переписанного файла в этом случае отпадает.
Теперь рассмотрим ситуацию посложнее: приложение выполняется на удалённой машине.
В этом случае можно примонтировать папку с переписанными файлами, например, через SSHFS. Если локальный и удалённый пути до папки различаются, то ещё нужно прописать mappings в IDE.
Так или иначе, этот способ немного отличается от привычного и позволяет отлаживать только переписанные файлы, но не оригинальные. Но всё же хочется редактировать и отлаживать одни и те же оригинальные файлы.
В AspectMock обошли проблему [включением режима дебага](https://github.com/Codeception/AspectMock/blob/3.0.2/src/AspectMock/Kernel.php#L23) без возможности его отключить:
```
public function init(array $options = [])
{
if (!isset($options['excludePaths'])) {
$options['excludePaths'] = [];
}
$options['debug'] = true;
$options['excludePaths'][] = __DIR__;
parent::init($options);
}
```
В простом примере теста режим дебага навскидку медленнее процентов на 20. Но у меня нет достаточного количества тестов на AspectMock, чтобы дать более точную оценку того, насколько он медленнее. Если у вас есть много тестов на AspectMock, я буду рад, если вы поделитесь сравнением в комментариях.
### Использование Xdebug с soft-mocks
Теперь, когда понятна проблема, рассмотрим, как можно её решить с использованием PHP Xdebug proxy. Основная часть находится в классе [`RequestPreparer\SoftMocksRequestPreparer`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/RequestPreparer/SoftMocksRequestPreparer.php).
В конструкторе класса определяем путь до скрипта инициализации soft-mocks и запускаем его (предполагается, что soft-mocks подключён как зависимость, но в конструктор можно передать любой путь):
```
public function __construct(LoggerInterface $logger, string $initScript = '')
{
$this->logger = $logger;
if (!$initScript) {
$possibleInitScriptPaths = [
// proxy установлен как проект, soft-mocks — как зависимость проекта
__DIR__.'/../../vendor/badoo/soft-mocks/src/init_with_composer.php',
// proxy и soft-mocks установлены как зависимости
__DIR__.'/../../../../badoo/soft-mocks/src/init_with_composer.php',
];
foreach ($possibleInitScriptPaths as $possiblInitScriptPath) {
if (file_exists($possiblInitScriptPath)) {
$initScript = $possiblInitScriptPath;
break;
}
}
}
if (!$initScript) {
throw new Error("Can't find soft-mocks init script");
}
// инициализируем soft-mocks (путь до папки с переписанными файлами и т.д.)
require $initScript;
}
```
Для подготовки запроса от Xdebug к IDE нужно заменить путь до переписанного файла путём оригинального файла:
```
public function prepareRequestToIde(XmlDocument $xmlRequest, string $rawRequest): void
{
$context = [
'request' => $rawRequest,
];
$root = $xmlRequest->getRoot();
if (!$root) {
return;
}
foreach ($root->getChildren() as $child) {
// путь до переписанного файла лежит в одном из тегов:
// - 'stack': https://xdebug.org/docs-dbgp.php#stack-get
// - 'xdebug:message': https://xdebug.org/docs-dbgp.php#error-notification
if (!in_array($child->getName(), ['stack', 'xdebug:message'], true)) {
continue;
}
$attributes = $child->getAttributes();
if (isset($attributes['filename'])) {
// если в атрибутах тега есть путь до переписанного файла, то заменяем его оригинальным путём
$filename = $this->getOriginalFilePath($attributes['filename'], $context);
if ($attributes['filename'] !== $filename) {
$this->logger->info("Change '{$attributes['filename']}' to '{$filename}'", $context);
$child->addAttribute('filename', $filename);
}
}
}
}
```
Для подготовки запроса от IDE к Xdebug нужно заменить путь до оригинального файла путём до переписанного:
```
public function prepareRequestToXdebug(string $request, CommandToXdebugParser $commandToXdebugParser): string
{
// разбираем запрос на команду и аргументы
[$command, $arguments] = $commandToXdebugParser->parseCommand($request);
$context = [
'request' => $request,
'arguments' => $arguments,
];
if ($command === 'breakpoint_set') {
// если есть аргумент -f, то заменяем путь до оригинального файла путём до переписанного
// см. https://xdebug.org/docs-dbgp.php#id3
if (isset($arguments['-f'])) {
$file = $this->getRewrittenFilePath($arguments['-f'], $context);
if ($file) {
$this->logger->info("Change '{$arguments['-f']}' to '{$file}'", $context);
$arguments['-f'] = $file;
// собираем обратно запрос
$request = $commandToXdebugParser->buildCommand($command, $arguments);
}
} else {
$this->logger->error("Command {$command} is without argument '-f'", $context);
}
}
return $request;
}
```
Чтобы подготовитель запроса заработал, нужно создать свой класс фабрики и либо наследовать его от [`Factory\DefaultFactory`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/Factory/DefaultFactory.php), либо имплементировать интерфейс [`Factory\Factory`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/Factory/Factory.php). Для soft-mocks фабрика [`Factory\SoftMocksFactory`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/src/Factory/SoftMocksFactory.php) выглядит так:
```
class SoftMocksFactory extends DefaultFactory
{
public function createConfig(array $config): Config
{
// здесь создаём объект своего класса конфига
return new SoftMocksConfig($config);
}
public function createRequestPreparers(LoggerInterface $logger, Config $config): array
{
$requestPreparers = parent::createRequestPreparers($logger, $config);
return array_merge($requestPreparers, [$this->createSoftMocksRequestPreparer($logger, $config)]);
}
public function createSoftMocksRequestPreparer(LoggerInterface $logger, SoftMocksConfig $config): SoftMocksRequestPreparer
{
// здесь передаём путь до init-скрипта из конфига
return new SoftMocksRequestPreparer($logger, $config->getSoftMocks()->getInitScript());
}
}
```
Свой класс конфига здесь нужен, чтобы можно было указать путь init-скрипта soft-mocks. Что он из себя представляет, посмотреть можно в [Config\SoftMocksConfig](https://github.com/mougrim/php-xdebug-proxy/blob/0.4.0/src/Config/SoftMocksConfig.php).
Осталась самая малость: создать новую фабрику и указать путь до init-скрипта soft-mocks. Как это делается, можно посмотреть в [`softMocksConfig`](https://github.com/mougrim/php-xdebug-proxy/tree/0.4.0/softMocksConfig).
### Неблокирующий API
Как я уже писал выше, PHP Xdebug proxy под капотом использует amphp, а значит, для работы с [I/O](https://ru.wikipedia.org/wiki/%D0%92%D0%B2%D0%BE%D0%B4-%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4) должен использоваться неблокирующий API. В apmphp уже есть немало компонентов, которые реализуют этот неблокирующий API. Если вы собираетесь расширять PHP Xdebug proxy и использовать его в многопользовательском режиме, то обязательно используйте неблокирующие API.
Выводы
------
PHP Xdebug proxy — ещё довольно молодой проект, но в Badoo он уже активно используется для отладки тестов с использованием soft-mocks.
PHP Xdebug proxy:
* заменяет pydbgpproxy при многопользовательской отладке;
* может работать с soft-mocks;
* можно расширить:
+ можно заменять пути до файлов, приходящих от IDE и от Xdebug;
+ можно собирать статистику: в режиме отладки как минимум доступен выполняемый контекст при отладке (значения переменных и выполняемая строчка кода).
Если вы используете Xdebug proxy для чего-то, кроме multiuser debugging, то поделитесь своим кейсом и Xdebug proxy, которым пользуетесь, в комментариях.
Если вы используете pydbgpproxy или какой-то другой Xdebug proxy, то попробуйте PHP Xdebug proxy, расскажите о своих проблемах, поделитесь pull requests. Давайте развивать проект вместе! :)
P. S. Спасибо моему коллеге Евгению Махрову aka [eZH](https://habr.com/ru/users/ezh/) за идею proxy [smdbgpproxy](https://github.com/eelf/smdbgpproxy)!
Ещё раз ссылки
--------------
* [PHP Xdebug proxy](https://github.com/mougrim/php-xdebug-proxy) — Xdebug proxy, о котором идёт речь в статье;
* pydbgpproxy можно скачать [здесь](http://code.activestate.com/komodo/remotedebugging/) — внезапно, Python Remote Debugging Client;
* [amphp](https://amphp.org/) — асинхронный неблокирующий фреймворк на PHP;
* инструменты для mock-ов:
+ [soft-mocks](https://github.com/badoo/soft-mocks);
+ [AspectMock](https://github.com/Codeception/AspectMock);
+ [uopz](http://php.net/manual/ru/book.uopz.php);
+ [runkit](http://php.net/manual/ru/book.runkit.php).
Спасибо за внимание!
Буду рад комментариям и предложениям.
Ринат Ахмадеев, Sr. PHP developer
**UPD**: Опубликован [перевод](https://badootech.badoo.com/php-xdebug-proxy-when-xdebugs-standard-capabilities-are-insufficient-49fe86943f12) статьи на английский. | https://habr.com/ru/post/442504/ | null | ru | null |
# Выводим в Интернет публичную виртуальную машину QEMU без сетевой карты и пробуем майнить
Бывают случаи когда счастливый пользователь публичной виртуальной машины может столкнуться с тем что виртуальная машина не имеет выхода в сеть Интернет. Пользователю предоставляется процессор, память, диск с операционной системой, базовые интерфейсы, порт удаленного доступа и всё.
Хостера в таком случае тоже можно понять, ему проще отключить доступ в Интернет сегодня чтобы не ломать голову завтра по поводу активности пользователя в сети Интернет так как различные обиженые и оскорбленые пользователем первым делом начнут выяснять отношения именно с хостером. Например, в некоторых странах распространена практика досудебной блокировки IP-адресов хостера от чего страдают не пользователь-злоумышленик, а невиновные пользователи.
Новый метод выхода в Интернет
-----------------------------
Раньше, чтобы вывести виртуальную машину без сети в Интернет, клиент мог только пробросить физическое USB-устройство, раздающее Интернет c его адреса: модем, сетевой адаптер.
Сегодня пользователь может пробросить порты к VPN или Proxy-серверу по аналогии c SSH. Для этого необходимо чтобы все три стороны клиент, хост и виртуальная машина были собраны на основе кода FlexVDI т.е необходимо пересобрать и установить пакеты программ которые используются для осуществления удаленного доступа по протоколу Spice.
FlexVDI — это улучшенная версия открытого протокола удаленного доступа SPICE и дополнительный слой абстракции от одноименной компании. Весь необходимый код доступен в репозиториях на [гитхабе](https://github.com/flexvdi).
Подключение
-----------
Для того чтобы получить spice-клиента от FlexVDI, Linux-пользователь может скомпилировать клиента вручную либо выполнить несколько действий над appImage-образом клиента:
Для начала нужно загрузить appImage-образ клиента с официального сайта, сделать его исполняемым файлом и распаковать с помощью команды:
```
./flexvdi-linux-client-2.2.15-x86_64.AppImage --appimage-extract
```
После выполнения команды в каталоге squashfs-root в директории с файлом будут находится файлы образа. Нас интересует клиент spicy, однако прямое исполнение файла завершается с ошибкой так как приложение пробует использовать библиотеки расположенные в системе, а не в образе. Чтобы запустить spicy создаем копию файла AppRun. В файле копии в конце комментируем или удадаляем строку:
```
./python2.7 ./flexvdi_launcher.pyc "$@"
```
и вместо неё добавляем строку вида:
```
./spicy --uri=spice://vpla.umvirt.com?port=6060 -R 3128:127.0.0.1:3128 --spice-debug
```
*Здесь настраивается подключение к порту удаленного доступа по spice-протоколу к публичной виртуальной машине RetroGamer на сервере vpla.umvirt.com и пробрасываем в виртуальную машину порт 3128 от squid с выводом отладочной информации.*
Сохраняем файл, устанавливаем Proxy-сервер Squid и проверяем его работоспособность с помощью браузера.
Ниже приведен скриншот окна настроек Proxy-сервера для Firefox:
Если браузер работает с прокси успешно, резервируем доступ к виртуальной машине и запускаем созданный файл запуска с перенаправлением вывода в файл, например так:
```
./myApp > spicy.log
```
В файле лога должны появится сообщения:
```
(spicy:10702): GSpice-DEBUG: port-forward.c:183 Created new port forwarder
```
и
```
(spicy:10702): GSpice-DEBUG: port-forward.c:231 Associate guest (null), port 3128 -> 127.0.0.1 port 3128
```
Если сообщение не появилось значит либо на хосте либо в виртуальной машине код оригинальных spice пакетов не заменен на код Flexvdi.
В виртуальной машине:
1. проверяем проброс порта командой:
```
ss -atnl
```
2. проверяем отсутствие сети командой:
```
ip addr
```
В настройках браузера прописываем аналогичные параметры Proxy-сервера.
Проверяем выход в сеть
----------------------
Проверяем IP-адрес, например на странице <http://umvirt.com/agentinfo>
Проверяем возможность открытия сайтов, например откроем сайт онлайн майнинга "[Coinhive](https://coinhive.com)".
Как видим виртуальная машина не просто вышла в сеть Интернет с адреса клиента, но также позволила запустить процесс майнинга.
Видео процесса подключения доступно на [Youtube](https://www.youtube.com/watch?v=P2--KG-zDxA). | https://habr.com/ru/post/431598/ | null | ru | null |
# Текстуры для 64k intro: как это делается сегодня
*Эта статья является второй частью нашей серии о создании* [*H – Immersion*](http://www.ctrl-alt-test.fr/productions/h-immersion/)*. Первую часть можно прочитать здесь:* [*Погружение в Immersion*](https://habr.com/post/352970/)*.*
При создании анимации всего лишь в 64 КБ сложно использовать готовые изображения. Мы не можем хранить их традиционным способом, потому что это недостаточно эффективно, даже если применять сжатие, например JPEG. Альтернативное решение заключается в процедурной генерации, то есть в написании кода, описывающего создание изображений во время выполнения программы. Нашей реализацией такого решения стал генератор текстур — фундаментальная часть нашего тулчейна. В этом посте мы расскажем, как разрабатывали и использовали его в [*H – Immersion*](http://www.ctrl-alt-test.fr/?page_id=444).
*Прожекторы субмарины освещают детали морского дна.*
Ранняя версия
-------------
Генерация текстур стала одним из самых первых элементов нашей кодовой базы: в нашем первом интро [*B – Incubation*](http://www.ctrl-alt-test.fr/?page_id=94) уже использовались процедурные текстуры. [Код](https://github.com/laurentlb/Ctrl-Alt-Test/blob/master/F/src/texgen/texture.hh#L40) состоял из набора функций, выполняющих заливку, фильтрацию, преобразования и комбинирование текстур, а также из одного большого цикла, обходящего все текстуры. Эти функции были написаны на чистом C++, но позже был добавлено взаимодействие C API, чтобы их можно было вычислять интерпретаторе C [PicoC](https://github.com/zsaleeba/picoc). В то время мы использовали PicoC для того, чтобы снизить время, занимаемое каждой итерацией: так нам удавалось изменять и перезагружать текстуры в процессе выполнения программы. Переход на подмножество C был небольшой жертвой по сравнению с тем, что теперь мы могли менять код и видеть результат сразу, не заморачиваясь закрытием, перекомпиляцией и повторной загрузкой всего демо.
*С помощью простого паттерна, небольшого шума и деформаций мы можем получить стилизованную текстуру древесины.*
*В этой сцене из* F – Felix’s workshop *были использованы различные текстуры древесины.*
Какое-то время мы исследовали возможности этого генератора, и в результате выложили его на веб-сервер с небольшим скриптом на PHP и простым веб-интерфейсом. Мы могли писать код текстур в текстовом поле, а скрипт передавал его в генератор, который затем сбрасывал результат как файл PNG для отображения на странице. Очень скоро мы начали делать наброски прямо на работе во время обеденного перерыва и делиться своими небольшими шедеврами с другими членами группы. Такое взаимодействие сильно мотивировало нас к творческому процессу.
*Веб-галерея нашего старого генератора текстур. Все текстуры можно редактировать в браузере.*
Полный редизайн
---------------
Долгое время генератор текстур почти не менялся; мы считали, что он хорош, и наша эффективность перестала повышаться. Но однажды мы обнаружили, что на Интернет-форумах есть множество [художников](http://polycount.com/discussion/145615/josh-lynch-substance-designer-sketchbook), демонстрирующих свои полностью процедурно сгенерированные текстуры, а также устраивающих [челленджи](http://polycount.com/discussion/196297/the-bi-weekly-substance-challenge-challenge-16-17-18) на разные темы. Процедурный контент когда-то был «фишкой» демо-сцены, но [Allegorithmic](https://www.allegorithmic.com/products/substance-designer), [ShaderToy](https://www.shadertoy.com/) и подобные им инструменты сделали его доступным для широкой публики. Мы не обращали на это внимания, и они начали с лёгкостью класть нас на лопатки. Неприемлемо!
*[Fabric Couch](https://www.artstation.com/artwork/gv9rL). Полностью процедурная текстура ткани, созданная в Substance Designer. Автор: Imanol Delgado. [www.artstation.com/imanoldelgado](https://www.artstation.com/imanoldelgado)*
*[Forest Floor](https://www.artstation.com/artwork/evGD6). Полностью процедурная текстура лесной почвы, созданная в Substance Designer. Автор: Daniel Thiger. [www.artstation.com/dete](https://www.artstation.com/dete)*
Нам давно уже нужно было пересмотреть свои инструменты. К счастью, многолетняя работа с одним и тем же генератором текстур позволила нам осознать его недостатки. Кроме того, наш зарождающийся генератор мешей тоже подсказал нам, как должен выглядеть конвейер процедурного контента.
Самой важной архитектурной ошибкой была реализация генерирования как множества операций с объектами текстур. С точки зрения высокоуровневой перспективы это может быть и правильный подход, но с точки зрения реализации такие функции как **texture.DoSomething()** или **Combine(textureA, textureB)** имеют серьёзные недостатки.
Во-первых, ООП-стиль требует объявлять эти функции как часть API, какими бы простыми они ни были. Это серьёзная проблема, потому что она плохо масштабируется и, что более важно, создаёт ненужные трения в процессе творчества. Мы не хотели менять API каждый раз, когда нужно будет попробовать что-то новое. Это усложняет экспериментирование и ограничивает творческую свободу.
Во-вторых, с точки зрения производительности такой подход требует обрабатывать в циклах данные текстур столько раз, сколько есть операций. Это бы не было особо важно, если бы эти операции были затратными относительно затрат доступа к большим фрагментам памяти, однако обычно это не так. За исключением совсем малой доли операций, например, генерация [шума Перлина](https://mzucker.github.io/html/perlin-noise-math-faq.html) или выполнение [заливки](https://en.wikipedia.org/wiki/Flood_fill), в основном они на самом деле очень просты и требуют всего несколько инструкций на точку текстуры. То есть мы обходили данные текстур для выполнения тривиальных операций, что чрезвычайно неэффективно с точки зрения кэширования.
Новая структура решает эти проблемы благодаря реорганизации логики. Большинство функций на практике независимо выполняет одну и ту же операцию для каждого элемента текстуры. Поэтому вместо написания функции **texture.DoSomething()**, обходящей все элементы, мы можем написать **texture.ApplyFunction(f)**, где **f(element)** работает только для отдельного элемента текстуры. Затем **f(element)** можно написать в соответствии с конкретной текстурой.
Это кажется незначительным изменением. Однако такая структура упрощает API, делает код генерирования более гибким и выразительным, более дружественным к кэшу и с лёгкостью позволяет реализовать параллельную обработку. Многие из читателей уже поняли, что по сути это шейдер. Однако реализация по факту остаётся кодом C++, выполняемым в процессоре. Мы по-прежнему сохраняем возможность выполнять операции за пределами цикла, но используем этот вариант только при необходимости, например, выполняя свёртку.
### Было:
```
// Логика находится на уровне текстур.
// API раздут.
// Всё что есть - это API.
// Генерирование текстуры проходит за множество проходов.
class ProceduralTexture {
void DoSomething(parameters) {
for (int i = 0; i < size; ++i) {
// Здесь подробности реализации.
(*this)[i] = …
}
}
void PerlinNoise(parameters) { … }
void Voronoi(parameters) { … }
void Filter(parameters) { … }
void GenerateNormalMap() { … }
};
void GenerateSomeTexture(texture t) {
t.PerlinNoise(someParameter);
t.Filter(someOtherParameter);
… // и т.д.
t.GenerateNormalMap();
}
```
### Стало:
```
// Логика обычно находится на уровне элементов текстур.
// API минимален.
// Операции пишутся по мере необходимости.
// Количество проходов при генерировании текстур снижено.
class ProceduralTexture {
void ApplyFunction(functionPointer f) {
for (int i = 0; i < size; ++i) {
// Реализация передаётся как параметр.
(*this)[i] = f((*this)[i]);
}
}
};
void GenerateNormalMap(ProceduralTexture t) { … }
void SomeTextureGenerationPass(void* out, PixelInfo in) {
result = PerlinNoise(in);
result = Filter(result);
… // и т.д.
*out = result;
}
void GenerateSomeTexture(texture t) {
t.ApplyFunction(SomeTextureGenerationPass);
GenerateNormalMap(t);
}
```
Параллелизация
--------------
Для генерации текстур требуется время, и очевидный кандидат для снижения этого времени — параллельное выполнение кода. По крайней мере, можно научиться генерировать несколько текстур одновременно. Именно так мы сделали для [*F *–* Felix’s workshop*](http://www.ctrl-alt-test.fr/?page_id=373), и это очень снизило время загрузки.
Однако это не экономит время там, где оно необходимо больше всего. По-прежнему много времени занимает генерирование одной текстуры. Это относится и к изменению, когда мы продолжаем перезагружать текстуру снова и снова перед каждой модификацией. Вместо этого лучше распараллелить внутренний код генерирования текстур. Поскольку теперь код по сути состоит из одной большой функции, применяемой в цикле к каждом текселу, параллелизация становится простой и эффективной. Снижаются затраты на эксперименты, настройку и наброски, что непосредственно влияет на творческий процесс.
*Иллюстрация идеи, исследованной и отброшенной нами для [*H – Immersion*](http://www.ctrl-alt-test.fr/?page_id=444): мозаичное украшение с облицовкой из орихалка. Здесь она показана в нашем интерактивном инструменте для редактирования.*
Генерирование на стороне GPU
----------------------------
Если это всё ещё не очевидно, то скажу, что генерирование текстур полностью выполняется в ЦП. Возможно, кто-то из вас сейчас читает эти строки и недоумевает «но почему?!». Кажется, что очевидным шагом является генерация текстур в видеопроцессоре. Для начала он на порядок увеличит скорость генерации. Так почему же мы его не используем?
Основная причина в том, что цель нашего небольшого редизайна заключалась в том, чтобы остаться на CPU. Переход на GPU означал бы гораздо больше работы. Нам бы пришлось решать дополнительные проблемы, для которых у нас пока недостаточно опыта. Работая с CPU, мы имеем чёткое понимание того, что хотим, и знаем, как исправить предыдущие ошибки.
Однако хорошие новости заключаются в том, что благодаря новой структуре эксперименты с GPU теперь кажутся довольно тривиальными. Тестирование сочетаний обоих типов процессоров будет интересным экспериментом на будущее.
Генерирование текстур и физически точный шейдинг
------------------------------------------------
Ещё одно ограничение старого дизайна заключалось в том, что текстура рассматривалась только как RGB-изображение. Если нам нужно было сгенерировать больше информации, допустим diffuse-текстуру и текстуру нормалей для той же поверхности, то ничего нам не мешало это сделать, но API особо и не помогал. Особенно важно это стало в контексте [физически точного шейдинга](http://lousodrome.net/blog/light/2011/12/27/readings-on-physically-based-rendering/) (Physically Based Shading, PBR).
В традиционном конвейере без PBR обычно используют цветовые текстуры, в которые запечено множество информации. Такие текстуры часто представляют собой окончательный внешний вид поверхности: у них уже имеется некий объём, затемнены трещины, и на них могут быть даже отражения. Если одновременно используется несколько текстур, то для добавления карт нормалей или отражаемости поверхности обычно сочетаются детали крупного и мелкого масштабов.
В PBR-конвейере поверхности обычно используют наборы из нескольких текстур, представляющих физические значения, а не требуемый художественный результат. Диффузная цветовая текстура, которая ближе всего к тому, что часто называют «цветом» поверхности, обычно плоская и неинтересная. Цвет specular определяется коэффициентом преломления поверхности. БОльшая часть деталей и вариативности берётся из текстур нормалей и roughness (шероховатости) (которые кто-то может считать одним и тем же, но с двумя разными масштабами). Воспринимаемая отражающая способность поверхности становится следствием из уровня её roughness. На этом этапе логичнее будет думать с точки зрения не текстур, а материалов.
Новая структура позволяет нам объявлять для текстур произвольные форматы пикселей. Сделав её частью API, мы позволяем ему заниматься всем boilerplate-кодом. После объявления формата пикселей мы можем сосредоточиться на творческом коде, не тратя лишних усилий на обработку этих данных. Во время выполнения он сгенерирует несколько текстур и прозрачным образом передаст их в GPU.
В некоторых PBR-конвейерах цвета diffuse и specular не передаются непосредственно. Вместо них используются параметры «base color» и «metalness», что имеет свои достоинства и недостатки. В [*H – Immersion*](http://www.ctrl-alt-test.fr/?page_id=444) мы используем модель diffuse+specular, а материал обычно состоит из пяти слоёв:
1. Цвет Diffuse (RGB; 0: [Vantablack](https://en.wikipedia.org/wiki/Vantablack); 1: [fresh snow](https://en.wikipedia.org/wiki/Albedo#Snow)).
2. Цвет Specular (RGB: доля отражённого под 90° света, также известная как [*F0* или *R0*](https://seblagarde.wordpress.com/2013/04/29/memo-on-fresnel-equations/)).
3. Roughness (A; 0: идеально гладкий; 1: похожий на резину).
4. Нормали (XYZ; единичный вектор).
5. Подъём рельефа (A; используется для parallax occlusion mapping).
При использовании информация об испускании света добавлялась непосредственно в шейдер. Нам не показалось необходимым наличие ambient occlusion, потому что в большинстве сцен вообще нет окружающего освещения. Однако не удивлюсь, что у нас появятся дополнительне слои или другие типы информации, например, анизотропия или непрозрачность.
На изображениях выше показан недавний эксперимент с генерацией локального ambient occlusion на основании высоты. Для каждого направления мы проходим заданное расстояние и сохраняем наибольший наклон (разность высот, поделенная на расстояние). Затем мы вычисляем occlusion из среднего наклона.
Ограничения и работа на будущее
-------------------------------
Как видите, новая структура стала серьёзным улучшением по сравнению со старой. Кроме того, она поощряет творческую выразительность. Однако у неё всё равно есть ограничения, которые мы хотим устранить в будущем.
Например, хотя в этом интро проблем не возникало, мы заметили, что препятствием может стать выделение памяти. При генерации текстур используется один массив из значений float. При больших текстурах со множеством слоёв можно быстро прийти к проблеме с выделением памяти. Есть различные способы её решения, но все они имеют свои недостатки. Например, мы можем генерировать текстуры потайлово, при этом масштабируемость будет лучше, однако реализация некоторых операций, например свёртки, становится менее очевидной.
Кроме того, в этой статье, несмотря на использованное слово «материалы», мы говорили только о текстурах, но не о шейдерах. Однако применение материалов должно приводить и к шейдерам. Такое противоречие отражает ограничения существующей структуры: генерирование текстур и шейдинг — это две отдельные части, разделённые мостом. Мы пытались сделать так, чтобы этот мост пересечь было как можно проще, но на самом деле хотим, чтобы эти части стали единым. Например, если у материала есть и статические, и динамические параметры, то мы хотим описывать их в одном месте. Это сложная тема и мы пока не знаем, найдётся ли хорошее решение, но давайте не будем забегать вперёд.
*Эксперимент по созданию текстуры ткани, похожей на показанную выше работу Imadol Delgado.* | https://habr.com/ru/post/419007/ | null | ru | null |
# Telegram-бот на вебхуках — Java+Spring, Redis, клавиатуры и деплой на Heroku — снова для самых маленьких
### В предыдущих сериях
Это вторая статья в моей серии «для самых маленьких» — [предыдущая](https://habr.com/ru/post/528694/) была посвящена «классическому» Telegram-боту, наследуемому от `TelegramLongPollingBot`.
### Для кого написано
Если вы ни разу не писали Telegram-ботов на Java с использованием вебхуков и только начинаете разбираться — эта статья для вас. В ней подробно и с пояснениями описано создание реального бота, автоматизирующего одну конкретную функцию. Можно использовать статью как мануал для создания скелета своего бота, а потом подключить его к своей бизнес-логике.
Я пытаюсь писать как для себя, а не сразу для умных — надеюсь, кому-нибудь это поможет быстрее въехать в тему.
### Предыстория
Учить словарные слова — занятие довольно скучное, а если делать это в лоб, ещё и малоэффективное, поэтому я решил разработать для дочери задания такого вида:
Ребёнок сначала выбирает правильный вариант, а затем закрепляет его написанием. По ощущениям, запоминание идёт неплохо. Дело оставалось за малым — написать бота и составить словари неправильных написаний.
### Что в статье есть, чего нет
В статье есть про:
* создание бекенда Telegram-бота на вебхуках на Java 11 с использованием Spring;
* использование базы данных Redis;
* отправку пользователю текстовых сообщений и файлов;
* подключение постоянных и временных клавиатур;
* локальный запуск бота для дебага;
* деплой и запуск бота на Heroku, включая подключение к проекту Heroku Redis.
В статье нет про:
* использование функций ботов, не перечисленных выше;
* работу с Apache POI — создание Word и Excel файлов;
* общение с BotFather (создание бота, получение его токена и формирование списка команд подробно и понятно описано во многих источниках, вот первый попавшийся [мануал](https://botcreators.ru/blog/kak-sozdat-svoego-bota-v-botfather/);
* создание и загрузку в БД словарей по умолчанию.
Из примеров кода в статье эти функции исключены, чтобы упростить восприятие. Исходный код лежит на [GitHub](https://github.com/taksebe-official/writeReadRightBot). Если у вас вдруг есть вопросы, пишите в личку, с удовольствием проконсультирую.
### Бизнес-функции бота
Бот позволяет:
* создавать Word-файлы с заданиями из имеющихся словарей (стандартных или пользовательского);
* скачивать имеющиеся словари в Excel-файлы (для корректировки и последующей загрузки в качестве пользовательского словаря);
* загружать пользовательский словарь;
* выводить справку.
Можно потыкать — [WriteReadRightBot](https://t.me/WriteReadRightBot). Выглядит так:
### Порядок разработки
* разобраться с зависимостями;
* сконфигурировать БД;
* создать бота;
* реализовать обработку сообщений, включая работу с клавиатурами;
* раскурить приём и отправку файлов;
* завести локально;
* задеплоить на Heroku.
Ниже подробно расписан каждый пункт.
### Зависимости
Для управления зависимостями используем [Apache Maven](https://maven.apache.org/). Нужные зависимости — собственно Telegram Spring Boot, [Redis](https://redis.io/) и [Lombok](https://projectlombok.org/), использовавшийся для упрощения кода (заменяет стандартные java-методы аннотациями).
Вот что вышло в
**pom.xml**
```
org.springframework.boot
spring-boot-starter-parent
2.2.0.RELEASE
4.0.0
ru.taksebe.telegram
write-read
1.0-SNAPSHOT
write-read
Пиши-читай
jar
11
${java.version}
${java.version}
UTF-8
UTF-8
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-data-redis
org.springframework.data
spring-data-redis
2.2.0.RELEASE
redis.clients
jedis
3.7.0
org.telegram
telegrambots-spring-boot-starter
5.3.0
org.projectlombok
lombok
1.18.20
compile
org.springframework.boot
spring-boot-maven-plugin
build-info
${project.build.sourceEncoding}
${project.reporting.outputEncoding}
${maven.compiler.source}
${maven.compiler.target}
```
### Конфигурируем базу данных Redis
Создадим модель — классы-сущности, объекты которых должны храниться в БД. В каждом из них должны быть ключ и значение — очень похоже на привычную `Map`. В нашем случае сущности всего две — словарное слово
**Word.java**
```
import lombok.*;
import lombok.experimental.FieldDefaults;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import java.util.Set;
@FieldDefaults(level = AccessLevel.PRIVATE)
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@RedisHash("word")
public class Word {
@Id
String word;
/**
* Ошибочные варианты написания
*/
Set mistakes;
//тут переопределены equals() и hashCode()
}
```
… и словарь
**Dictionary.java**
```
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import java.util.List;
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
@Getter
@RedisHash("dictionary")
@Builder
public class Dictionary {
@Id
String id;
List wordList;
}
```
Для сохранения объектов в БД и обращения к ним нам нужны два конвертера, переводящие объект «Слово» в массив байт (да-да, Redis нужно скормить именно его) для сохранения
**WordToBytesConverter.java**
```
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import ru.taksebe.telegram.writeRead.model.Word;
import javax.annotation.Nullable;
public class WordToBytesConverter implements Converter {
private final Jackson2JsonRedisSerializer serializer;
public WordToBytesConverter() {
serializer = new Jackson2JsonRedisSerializer<>(Word.class);
serializer.setObjectMapper(new ObjectMapper());
}
@Override
public byte[] convert(@Nullable Word value) {
return serializer.serialize(value);
}
}
```
… и обратно для получения объектов из БД.
**BytesToWordConverter.java**
```
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import ru.taksebe.telegram.writeRead.model.Word;
import javax.annotation.Nullable;
public class BytesToWordConverter implements Converter {
private final Jackson2JsonRedisSerializer serializer;
public BytesToWordConverter() {
serializer = new Jackson2JsonRedisSerializer<>(Word.class);
serializer.setObjectMapper(new ObjectMapper());
}
@Override
public Word convert(@Nullable byte[] value) {
return serializer.deserialize(value);
}
}
```
С использованием конвертеров создадим файл конфигурации.
**RedisConfiguration.java**
```
import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.convert.RedisCustomConversions;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import ru.taksebe.telegram.writeRead.converters.BytesToWordConverter;
import ru.taksebe.telegram.writeRead.converters.WordToBytesConverter;
import java.util.Arrays;
@Configuration
@EnableRedisRepositories
public class RedisConfiguration {
@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceClientConfigurationBuilderCustomizer() {
return clientConfigurationBuilder -> {
if (clientConfigurationBuilder.build().isUseSsl()) {
clientConfigurationBuilder.useSsl().disablePeerVerification();
}
};
}
@Bean
public RedisTemplate, ? redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
@Bean
public RedisCustomConversions redisCustomConversions() {
return new RedisCustomConversions(Arrays.asList(new WordToBytesConverter(),new BytesToWordConverter()));
}
}
```
Наконец, нужно создать репозиторий. Привыкшим к Postgre (как я) будет особенно приятно узнать, что работу с Redis поддерживает набивший оскомину `CrudRepositoty`. Поскольку мы используем только его стандартные методы, оставляем репозиторий без своих методов:
**DictionaryRepository.java**
```
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import ru.taksebe.telegram.writeRead.model.Dictionary;
@Repository
public interface DictionaryRepository extends CrudRepository {
}
```
К классу `Word` напрямую я не обращаюсь, поэтому для него репозиторий не нужен.
### Создаём бота
Начнём с добавления в `application.yaml` (или `application.properties`, если так привычнее) настроек:
* `telegram.api-url` — тут всё просто, `https://api.telegram.org/`;
* `telegram.webhook-path` — адрес вебхука, который должен быть зарегистрирован в Telegram (об этом ниже, в разделе «Запускаем локально»);
* `telegram.bot-name` и `telegram.bot-token` — имя и токен бота, полученные от [BotFather](https://t.me/BotFather).
Полный `application.yaml` можно посмотреть ниже, в разделе «Запускаем локально».
Далее, чтобы эти настройки можно было использовать в коде, создадим небольшой
**TelegramConfig.java**
```
import lombok.AccessLevel;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
@Getter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class TelegramConfig {
@Value("${telegram.webhook-path}")
String webhookPath;
@Value("${telegram.bot-name}")
String botName;
@Value("${telegram.bot-token}")
String botToken;
}
```
Теперь создадим класс бота и унаследуем его от `SpringWebhookBot` —
**WriteReadBot.java**
```
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.FieldDefaults;
import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.methods.updates.SetWebhook;
import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.starter.SpringWebhookBot;
import ru.taksebe.telegram.writeRead.constants.bot.BotMessageEnum;
import ru.taksebe.telegram.writeRead.telegram.handlers.CallbackQueryHandler;
import ru.taksebe.telegram.writeRead.telegram.handlers.MessageHandler;
import java.io.IOException;
@Getter
@Setter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class WriteReadBot extends SpringWebhookBot {
String botPath;
String botUsername;
String botToken;
MessageHandler messageHandler;
CallbackQueryHandler callbackQueryHandler;
public WriteReadBot(SetWebhook setWebhook, MessageHandler messageHandler,CallbackQueryHandler callbackQueryHandler) {
super(setWebhook);
this.messageHandler = messageHandler;
this.callbackQueryHandler = callbackQueryHandler;
}
@Override
public BotApiMethod onWebhookUpdateReceived(Update update) {
try {
return handleUpdate(update);
} catch (IllegalArgumentException e) {
return new SendMessage(update.getMessage().getChatId().toString(),
BotMessageEnum.EXCEPTION_ILLEGAL_MESSAGE.getMessage());
} catch (Exception e) {
return new SendMessage(update.getMessage().getChatId().toString(),
BotMessageEnum.EXCEPTION_WHAT_THE_FUCK.getMessage());
}
}
private BotApiMethod handleUpdate(Update update) throws IOException {
if (update.hasCallbackQuery()) {
CallbackQuery callbackQuery = update.getCallbackQuery();
return callbackQueryHandler.processCallbackQuery(callbackQuery);
} else {
Message message = update.getMessage();
if (message != null) {
return messageHandler.answerMessage(update.getMessage());
}
}
return null;
}
}
```
`MessageHandler` и `CallbackQueryHandler` — обработчики (соответственно) сообщений и нажатий на кнопки инлайн-клавиатур (подробнее ниже, в разделе «Обрабатываем сигналы»).
Методы класса направляют получаемый от пользователей сигнал в необходимый класс-обработчик в зависимости от его типа (сообщение или нажатие на кнопку инлайн-клавиатуры).
Для создания бина бота нам нужна ещё одна конфигурация:
**SpringConfig.java**
```
import lombok.AllArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.telegram.telegrambots.meta.api.methods.updates.SetWebhook;
import ru.taksebe.telegram.writeRead.telegram.WriteReadBot;
import ru.taksebe.telegram.writeRead.telegram.handlers.CallbackQueryHandler;
import ru.taksebe.telegram.writeRead.telegram.handlers.MessageHandler;
@Configuration
@AllArgsConstructor
public class SpringConfig {
private final TelegramConfig telegramConfig;
@Bean
public SetWebhook setWebhookInstance() {
return SetWebhook.builder().url(telegramConfig.getWebhookPath()).build();
}
@Bean
public WriteReadBot springWebhookBot(SetWebhook setWebhook,
MessageHandler messageHandler,
CallbackQueryHandler callbackQueryHandler) {
WriteReadBot bot = new WriteReadBot(setWebhook, messageHandler, callbackQueryHandler);
bot.setBotPath(telegramConfig.getWebhookPath());
bot.setBotUsername(telegramConfig.getBotName());
bot.setBotToken(telegramConfig.getBotToken());
return bot;
}
}
```
Поскольку наш бот — это веб-приложение, для доступа к нему нам нужен контроллер:
**WebhookController.java**
```
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
import org.telegram.telegrambots.meta.api.objects.Update;
@RestController
@AllArgsConstructor
public class WebhookController {
private final WriteReadBot writeReadBot;
@PostMapping("/")
public BotApiMethod onUpdateReceived(@RequestBody Update update) {
return writeReadBot.onWebhookUpdateReceived(update);
}
}
```
Ну и где-то должен быть метод main(), чтобы всё это запустилось. Создадим стандартный для Spring класс:
**WriteReadApplication.java**
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class WriteReadApplication {
public static void main(String[] args) {
SpringApplication.run(WriteReadApplication.class, args);
}
}
```
Бот готов, осталось научить его общаться с пользователем.
### Обрабатываем сигналы
Как уже говорилось, наш бот получает от пользователя сигналы двух типов — сообщения и нажатия на кнопки инлайн-клавиатур. Эти сигналы обрабатываются в классах `MessageHandler` и `CallbackQueryHandler`, а маршрутизация между ними осуществляется в классе бота `WriteReadBot` (его код чуть выше, в разделе «Создаём бота»).
Классы-обработчики служат связующим звеном между ботом и бизнес-логикой решаемой задачи — в зависимости от конкретного полученного значения происходит обращение к нужного методу внешнего сервиса. Код этих классов можно посмотреть [в этом пакете на Github](https://github.com/taksebe-official/writeReadRightBot/tree/master/src/main/java/ru/taksebe/telegram/writeRead/telegram/handlers), а в статье рассмотрим только две ключевых детали — создание клавиатур и работу с файлами.
### Постоянная клавиатура
Чтобы сразу было понятно, вот это она:
Постоянная клавиатура — это основное меню бота. Она создаётся в отдельном классе путём создания отдельных кнопок, затем их рядов и, в завершении, присвоения клавиатуре нужных признаков:
**ReplyKeyboardMaker.java**
```
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
import ru.taksebe.telegram.writeRead.constants.bot.ButtonNameEnum;
import java.util.ArrayList;
import java.util.List;
@Component
public class ReplyKeyboardMaker {
public ReplyKeyboardMarkup getMainMenuKeyboard() {
KeyboardRow row1 = new KeyboardRow();
row1.add(new KeyboardButton(ButtonNameEnum.GET_TASKS_BUTTON.getButtonName()));
row1.add(new KeyboardButton(ButtonNameEnum.GET_DICTIONARY_BUTTON.getButtonName()));
KeyboardRow row2 = new KeyboardRow();
row2.add(new KeyboardButton(ButtonNameEnum.UPLOAD_DICTIONARY_BUTTON.getButtonName()));
row2.add(new KeyboardButton(ButtonNameEnum.HELP_BUTTON.getButtonName()));
List keyboard = new ArrayList<>();
keyboard.add(row1);
keyboard.add(row2);
final ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
replyKeyboardMarkup.setKeyboard(keyboard);
replyKeyboardMarkup.setSelective(true);
replyKeyboardMarkup.setResizeKeyboard(true);
replyKeyboardMarkup.setOneTimeKeyboard(false);
return replyKeyboardMarkup;
}
}
```
Для удобства названия кнопок можно вынести в отдельный `ButtonNameEnum` ([на GitHub](https://github.com/taksebe-official/writeReadRightBot/blob/master/src/main/java/ru/taksebe/telegram/writeRead/constants/bot/ButtonNameEnum.java)), но это необязательно — можно прописать их текстом прямо в классе.
Инициализируется клавиатура в рамках обработки команды `/start` (то есть при первом обращении пользователя к боту) в классе-обработчике сообщений `MessageHandler`. Необходимо:
**Добавить постоянную клавиатуру в ответное сообщение**
```
SendMessage sendMessage = new SendMessage(, <текст ответа>);
sendMessage.setReplyMarkup(replyKeyboardMaker.getMainMenuKeyboard());
return sendMessage;
```
Кроме того, в классе `MessageHandler` надо не забыть обработать текстовые сообщения, отличные от названий кнопок — наш бот в этом случае призывает пользователя воспользоваться клавиатурой.
### Инлайн-клавиатуры
Это вот такое:
В нашем боте инлайн-клавиатуры используются для выбора пользователем словаря и отображаются в ответ на команды основного меню «Создать файл с заданиями» и «Скачать словарь». Состав кнопок отличается всего на одну позицию — при обработке команды «Скачать словарь» добавляется кнопка «Шаблон». Кроме того, если пользователь загрузил в базу данных свой словарь, при обработке обеих команд в клавиатуру добавляется кнопка «Ваш словарь».
Также, как и постоянная клавиатура, инлайн-версия формируется в отдельном классе:
**InlineKeyboardMaker.java**
```
import org.springframework.stereotype.Component;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import ru.taksebe.telegram.writeRead.constants.bot.CallbackDataPartsEnum;
import ru.taksebe.telegram.writeRead.constants.resources.DictionaryResourcePathEnum;
import java.util.ArrayList;
import java.util.List;
@Component
public class InlineKeyboardMaker {
public InlineKeyboardMarkup getInlineMessageButtonsWithTemplate(String prefix, boolean isUserDictionaryNeed) {
InlineKeyboardMarkup inlineKeyboardMarkup = getInlineMessageButtons(prefix, isUserDictionaryNeed);
inlineKeyboardMarkup.getKeyboard().add(getButton(
"Шаблон",
prefix + CallbackDataPartsEnum.TEMPLATE.name()
));
return inlineKeyboardMarkup;
}
public InlineKeyboardMarkup getInlineMessageButtons(String prefix, boolean isUserDictionaryNeed) {
List> rowList = new ArrayList<>();
for (DictionaryResourcePathEnum dictionary : DictionaryResourcePathEnum.values()) {
rowList.add(getButton(
dictionary.getButtonName(),
prefix + dictionary.name()
));
}
if (!rowList.isEmpty()) {
rowList.add(getButton(
"Все классы",
prefix + CallbackDataPartsEnum.ALL\_GRADES.name()
));
}
if (isUserDictionaryNeed) {
rowList.add(getButton(
"Ваш словарь",
prefix + CallbackDataPartsEnum.USER\_DICTIONARY.name()
));
}
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
inlineKeyboardMarkup.setKeyboard(rowList);
return inlineKeyboardMarkup;
}
private List getButton(String buttonName, String buttonCallBackData) {
InlineKeyboardButton button = new InlineKeyboardButton();
button.setText(buttonName);
button.setCallbackData(buttonCallBackData);
List keyboardButtonsRow = new ArrayList<>();
keyboardButtonsRow.add(button);
return keyboardButtonsRow;
}
}
```
В отличие от кнопок постоянных клавиатур, инлайн-кнопкам можно добавлять не только название (которое видит пользователь), но и ответное значение, которое будет отправлено при нажатие на неё.
Инициализация инлайн-клавиатуры происходит:
**в целом аналогично постоянной**
```
SendMessage sendMessage = new SendMessage(, <текст ответа>);
sendMessage.setReplyMarkup(inlineKeyboardMaker.getInlineMessageButtons(<аргументы, связанные с бизнес-логикой>));
return sendMessage;
```
### Отправка и получение файлов
Наш бот умеет как отправлять пользователю готовые файлы заданий и словарей, так и получать от него пользовательский словарь для загрузки в базу данных.
Отправка и загрузка файлов происходит в отдельном классе, в котором реализовано REST-взаимодействие с сервисами Telegram:
**TelegramApiClient.java**
```
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.StreamUtils;
import org.springframework.web.client.RestTemplate;
import org.telegram.telegrambots.meta.api.objects.ApiResponse;
import ru.taksebe.telegram.writeRead.exceptions.TelegramFileNotFoundException;
import ru.taksebe.telegram.writeRead.exceptions.TelegramFileUploadException;
import java.io.File;
import java.io.FileOutputStream;
import java.text.MessageFormat;
import java.util.Objects;
@Service
public class TelegramApiClient {
private final String URL;
private final String botToken;
private final RestTemplate restTemplate;
public TelegramApiClient(@Value("${telegram.api-url}") String URL,
@Value("${telegram.bot-token}") String botToken) {
this.URL = URL;
this.botToken = botToken;
this.restTemplate = new RestTemplate();
}
public void uploadFile(String chatId, ByteArrayResource value) {
LinkedMultiValueMap map = new LinkedMultiValueMap<>();
map.add("document", value);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.MULTIPART\_FORM\_DATA);
HttpEntity> requestEntity = new HttpEntity<>(map, headers);
try {
restTemplate.exchange(
MessageFormat.format("{0}bot{1}/sendDocument?chat\_id={2}", URL, botToken, chatId),
HttpMethod.POST,
requestEntity,
String.class);
} catch (Exception e) {
throw new TelegramFileUploadException();
}
}
public File getDocumentFile(String fileId) {
try {
return restTemplate.execute(
Objects.requireNonNull(getDocumentTelegramFileUrl(fileId)),
HttpMethod.GET,
null,
clientHttpResponse -> {
File ret = File.createTempFile("download", "tmp");
StreamUtils.copy(clientHttpResponse.getBody(), new FileOutputStream(ret));
return ret;
});
} catch (Exception e) {
throw new TelegramFileNotFoundException();
}
}
private String getDocumentTelegramFileUrl(String fileId) {
try {
ResponseEntity> response = restTemplate.exchange(
MessageFormat.format("{0}bot{1}/getFile?file\_id={2}", URL, botToken, fileId),
HttpMethod.GET,
null,
new ParameterizedTypeReference>() {
}
);
return Objects.requireNonNull(response.getBody()).getResult().getFileUrl(this.botToken);
} catch (Exception e) {
throw new TelegramFileNotFoundException();
}
}
}
```
Методы этого класса используются в классах-обработчиках `MessageHandler` и `CallbackQueryHandler`.
Для отправки файла пользователю необходимо перевести его в объект класса `ByteArrayResource` и отправить POST-запрос на адрес вида:
`https://api.telegram.org/bot<токен бота>/sendDocument?chat_id=`
При загрузке пользовательского файла в составе объекта `Document` приходит идентификатор файла. Чтобы скачать файл, необходимо отправить GET-запрос на адрес вида:
`https://api.telegram.org/bot<токен бота>/getFile?file_id=`
Следует обратить внимание, что скачивается объект `File` из пакета `org.telegram.telegrambots.meta.api.objects`, и для последующего использования мы переводим его в привычный `java.io.File`.
### Подключаем Heroku Redis для локального запуска
Идём на [Heroku](https://heroku.com) и выполняем алгоритм:
* Зарегистрироваться (если нет аккаунта)
* Создать проект — нажать «New»/«Create new app» в правой части экрана
* Перейти на вкладку «Resources»
* В разделе «Add-ons» ввести в поисковую строку «Heroku Redis», выбрать её в результатах поиска
* Подтвердить подключение БД к проекту
* В правом верхнем углу нажать на иконку в виде квадрата из синих точек, выбрать пункт Data, в открывшемся списке баз нажать на только что созданную. Первые несколько минут после подключения может тормозить и показывать ошибку
* Перейти на вкладку «Settings»
* Нажать на кнопку «View credentials» в правой части экрана
* Вуаля, перед Вами настройки подключения к БД
Надо помнить, что эти настройки Heroku периодически меняет, поэтому иногда нужно будет заново копировать их в Ваш проект
Заполняем `application.yaml`:
`spring.redis.database: 0`
`spring.redis.host: <хост БД Redis, копируем с Heroku>`
`spring.redis.port: <порт БД Redis, копируем с Heroku>`
`spring.redis.password: <пароль БД Redis, копируем с Heroku>`
`spring.redis.ssl: true`
Полный `application.yaml` можно посмотреть ниже, в разделе «Запускаем локально».
### Запускаем локально
Нам осталось сделать вебхук и зарегистрировать его в Telegram.
Для получения внешнего адреса при локальном запуске используем утилиту [ngrok](https://ngrok.com/) по вот этой [инструкции](https://pavelpage.ru/koderstvo/nastroyka-ngrok-dlya-otladki-telegram-bota.html). Не забываем добавить в `application.yaml` настройки `telegram.webhook-path` (выдаст ngrok) и `server.port` (передаётся ngrok в качестве параметра)
Вот так выглядит итоговый (для локального запуска с использованием БД Redis на Heroku)
**application.yaml**
```
telegram:
api-url: "https://api.telegram.org/"
webhook-path: "https://<...>.ngrok.io"
bot-name: "<что-то вроде @NameOfYourBot>"
bot-token: "<токен бота - цифры, двоеточие и белиберда:)>"
spring:
redis:
database: 0
host: "<...>.compute-1.amazonaws.com"
port: "<как правило, 5 цифр, если деплоим на Heroku>"
password: "<очень длинный пароль:)>"
ssl: true
server:
port: "<порт, который передавался в ngrok в качестве параметра, я использовал 5000>"
```
Регистрируем вебхук в Telegram, формируя в строке браузера запрос вида:
`https://api.telegram.org/bot<токен бота>/setWebhook?url=`
… видим ответ:
`{"ok":true,"result":true,"description":"Webhook was set"}`
… и запускаем приложение в своей IDE!
### Деплоим на Heroku
Если используется версия Java, отличная от 8, необходимо в корне проекта создать файл `system.properties`, содержащий одну строку:
`java.runtime.version=<версия Java, в нашем случае 11>`
Ещё один специфический для Heroku файл `Procfile` в данном случае можно не добавлять, он будет сгенерирован автоматически на основе `pom.xml`.
Сначала нужно обязательно удалить/закомментировать в `application.yaml` настройки подключения к БД — она подцепится автоматически, поскольку подключена к проекту на Heroku. Если оставить эти настройки, ничего не заведётся, они нужны только для внешнего подключения к этой БД.
Также нужно изменить настройку `webhook-path` — это адрес веб-приложения на Heroku. Чтобы его получить, надо нажать на кнопку «Open app» в интерфейсе Heroku, убедиться, что приложение запустилось (должна отображаться надпись «Whitelabel Error Page» — значит, успех) и скопировать содержимое адресной строки.
Вот так должен выглядеть готовый к деплою на Heroku
**application.yaml**
```
telegram:
api-url: "https://api.telegram.org/"
webhook-path: "адрес приложения на Heroku- что-то вроде https://<имя приложения>.herokuapp.com/"
bot-name: "<что-то вроде @NameOfYourBot>"
bot-token: "<токен бота - цифры, двоеточие и белиберда:)>"
```
Далее:
* в консоли `heroku create <имя приложения>` (либо `heroku git:remote -a <название проекта>`, если приложение на Heroku уже было создано ранее)
* в интерфейсе Heroku создать в проекте БД Heroku Redis (если ранее это не было сделано — алгоритм выше, в разделе «Запускаем локально»)
* в консоли `mvn clean install`
* в консоли `git push heroku master`
* в консоли `heroku ps:scale web=1` — установить количество используемых контейнеров (dynos) для типа процесса web
* открыть приложение — нажать на кнопку «Open app» в интерфейсе Heroku, убедиться, что оно запустилось (должна отображаться надпись «Whitelabel Error Page» — значит, успех)
* зарегистрировать вебхук в Telegram (алгоритм выше, в разделе «Запускаем локально»), используя URL из адресной строки предыдущего пункта
Теперь можно проверять бота непосредственно в Telegram!
При необходимости в интерфейсе Heroku на вкладке «Deploy» можно переключить деплой на GitHub-репозиторий (по запросу или автоматически).
### Что можно доделать
Как известно, Heroku гасит веб-приложения, которые не используются какое-то время, поэтому на первое сообщение бот может отвечать порядка 8-10 секунд — он ждёт, когда приложение развернётся с нуля. Это позволяет на бесплатном тарифе хостить много редко используемых веб-приложений — в тарифе учитывается только время аптайма.
Чтобы заставить приложение работать постоянно, можно добавить в проект пинг по расписанию условного Google, но нужно понимать, что в этом случае бот будет съедать львиную долю бесплатного тарифа. Я жадный, я так делать не буду.
### Вместо заключения
Оказывается, и мультик про [ПишиЧитая](https://youtu.be/wZGI4w9K5XY) тоже мало кто смотрел. | https://habr.com/ru/post/646017/ | null | ru | null |
# Теория звука. Что нужно знать о звуке, чтобы с ним работать. Опыт Яндекс.Музыки
Звук, как и [цвет](http://habrahabr.ru/company/yandex/blog/262735/), люди воспринимают по-разному. Например, то, что кажется слишком громким или некачественным одним, может быть нормальным для других.
Для работы над Яндекс.Музыкой нам всегда важно помнить о разных тонкостях, которые таит в себе звук. Что такое громкость, как она меняется и от чего зависит? Как работают звуковые фильтры? Какие бывают шумы? Как меняется звук? Как люди его воспринимают.
[](http://habrahabr.ru/company/yandex/blog/270765/)
Мы довольно много узнали обо всём этом, работая над нашим проектом, и сегодня я попробую описать на пальцах некоторые основные понятия, которые требуется знать, если вы имеете дело с цифровой обработкой звука. В этой статье нет серьёзной математики вроде быстрых преобразований Фурье и прочего — эти формулы несложно найти в сети. Я опишу суть и смысл вещей, с которыми придётся столкнуться.
Поводом для этого поста можете считать то, что мы добавили в [приложения](https://music.yandex.ru/apps) Яндекс.Музыки возможность слушать треки в высоком качестве (320kbps). А можете не считать. Итак.
Оцифровка, или Туда и обратно
=============================
Прежде всего разберёмся с тем, что такое цифровой сигнал, как он получается из аналогового и откуда собственно берётся аналоговый сигнал. Последний максимально просто можно определить как колебания напряжения, возникающие из-за колебаний мембраны в микрофоне.
*Рис. 1. Осциллограмма звука*
Это осциллограмма звука — так выглядит аудио сигнал. Думаю, каждый хоть раз в жизни видел подобные картинки. Для того чтобы понять, как устроен процесс преобразования аналогового сигнала в цифровой, нужно нарисовать осциллограмму звука на миллиметровой бумаге. Для каждой вертикальной линии найдем точку пересечения с осциллограммой и ближайшее целое значение по вертикальной шкале — набор таких значений и будет простейшей записью цифрового сигнала.
[](https://www.desmos.com/calculator/aojmanpjrl)
*Рис. 2. Интерактивный пример сложения волн и оцифровки сигнала.
Источник: [www.desmos.com/calculator/aojmanpjrl](https://www.desmos.com/calculator/aojmanpjrl)*
Воспользуемся этим интерактивным примером, чтобы разобраться в том, как накладываются друг на друга волны разной частоты и как происходит оцифровка. В левом меню можно включать/выключать отображение графиков, настраивать параметры входных данных и параметры дискретизации, а можно просто двигать контрольные точки.
На [аппаратном уровне это](https://en.wikipedia.org/wiki/Analog-to-digital_converter), разумеется, выглядит значительно сложнее, и в зависимости от аппаратуры сигнал может кодироваться совершенно разными способами. Самым распространённым из них является [импульсно-кодовая модуляция](https://en.wikipedia.org/wiki/Pulse-code_modulation), при которой записывается не конкретное значение уровня сигнала в каждый момент времени, а разница между текущим и предыдущим значением. Это позволяет снизить количество бит на каждый отсчёт примерно на 25%. Этот способ кодирования применяется в наиболее распространённых аудио-форматах (WAV, MP3, WMA, OGG, FLAC, APE), которые используют контейнер [PCM WAV](http://wav-pcm.narod.ru/).
В реальности для создания стерео-эффекта при записи аудио чаще всего записывается не один, а сразу несколько каналов. В зависимости от используемого формата хранения они могут храниться независимо. Также уровни сигнала могут записываться как разница между уровнем основного канала и уровнем текущего.
Обратное преобразование из цифрового сигнала в аналоговый производится с помощью [цифро-аналоговых преобразователей](https://en.wikipedia.org/wiki/Digital-to-analog_converter), которые могут иметь различное устройство и принципы работы. Я опущу описание этих принципов в данной статье.
Дискретизация
=============
Как известно, цифровой сигнал — это набор значений уровня сигнала, записанный через заданные промежутки времени. Процесс преобразования непрерывного аналогового сигнала в цифровой сигнал называется дискретизацией (по времени и по уровню). Есть две основные характеристики цифрового сигнала — частота дискретизации и глубина дискретизации по уровню.
*Рис. 3. Дискретизация сигнала.
Источник: <https://en.wikipedia.org/wiki/Sampling_(signal_processing)>*
[Частота дискретизации](https://en.wikipedia.org/wiki/Sampling_(signal_processing)#Sampling_rate) указывает на то, с какими интервалами по времени идут данные об уровне сигнала. Существует [теорема Котельникова](https://ru.wikipedia.org/wiki/Теорема_Котельникова) (в западной литературе её упоминают как [теорему Найквиста — Шеннона](https://en.wikipedia.org/wiki/Nyquist–Shannon_sampling_theorem), хотя встречается и название Котельникова — Шеннона), которая утверждает: для возможности точного восстановления аналогового сигнала из дискретного требуется, чтобы частота дискретизации была минимум в два раза выше, чем максимальная частота в аналоговом сигнале. Если брать примерный диапазон воспринимаемых человеком частот звука 20 Гц — 20 кГц, то оптимальная частота дискретизации ([частота Найквиста](https://en.wikipedia.org/wiki/Nyquist_frequency)) должна быть в районе 40 кГц. У стандартных аудио-CD она составляет 44.1 кГц
*Рис. 4. Квантование сигнала.
Источник: <https://ru.wikipedia.org/wiki/Квантование_(обработка сигналов)>*
[Глубина дискретизации](https://ru.wikipedia.org/wiki/Квантование_(обработка_сигналов)) по уровню описывает разрядность числа, которым описывается уровень сигнала. Эта характеристика накладывает ограничение на точность записи уровня сигнала и на его минимальное значение. Стоит специально отметить, что данная характеристика не имеет отношения к громкости — она отражает точность записи сигнала. Стандартная глубина дискретизации на audio-CD — 16 бит. При этом, если не использовать специальную студийную аппаратуру, разницу в звучании большинство перестаёт замечать уже в районе 10-12 бит. Однако большая глубина дискретизации позволяет избежать появления шумов при дальнейшей обработке звука.
Шумы
====
В цифровом звуке можно выделить три основных источника шумов.
Джиттер
-------
Это случайные отклонения сигнала, как правило, возникающие из-за нестабильности частоты задающего генератора или различной скорости распространения разных частотных составляющих одного сигнала. Данная проблема возникает на стадии оцифровки. Если описывать ~~«на пальцах»~~ «на миллиметровке», это происходит из-за немного разного расстояния между вертикальными линиями.
Шум дробления
-------------
Он напрямую связан с глубиной дискретизации. Так как при оцифровке сигнала его реальные значения округляются с определённой точностью, возникают слабые шумы, связанные с её потерей. Эти шумы могут появляться не только на стадии оцифровки, но и в процессе цифровой обработки (например, если сначала уровень сигнала сильно понижается, а затем — снова повышается).
Алиасинг
--------
При оцифровке возможна ситуация, при которой в цифровом сигнале могут появиться частотные составляющие, которых не было в оригинальном сигнале. Данная ошибка получила название [Aliasing](https://en.wikipedia.org/wiki/Aliasing). Этот эффект напрямую связан с частотой дискретизации, а точнее — с частотой Найквиста. Проще всего понять, как это происходит, рассмотрев вот эту картинку:
*Рис. 5. Алиас. Источник: [ru.wikipedia.org/wiki/Алиасинг](https://ru.wikipedia.org/wiki/Алиасинг)*
Зелёным показана частотная составляющая, частота которой выше частоты Найквиста. При оцифровке такой частотной составляющей не удаётся записать достаточно данных для её корректного описания. В результате при воспроизведении получается совершенно другой сигнал — жёлтая кривая.
Уровень сигнала
===============
Для начала стоит сразу понять, что когда речь идёт о цифровом сигнале, то можно говорить только об относительном уровне сигнала. Абсолютный зависит в первую очередь от воспроизводящей аппаратуры и прямо пропорционален относительному. При расчётах относительных уровней сигнала принято использовать [децибелы](https://en.wikipedia.org/wiki/Decibel). При этом за точку отсчёта берётся сигнал с максимально возможной амплитудой при заданной глубине дискретизации. Этот уровень указывается как 0 dBFS (dB — децибел, FS = Full Scale — полная шкала). Более низкие уровни сигнала указываются как -1 dBFS, -2 dBFS и т.д. Вполне очевидно, что более высоких уровней просто не бывает (мы изначально берём максимально возможный уровень).
Поначалу бывает тяжело разобраться с тем, как соотносятся децибелы и реальный уровень сигнала. На самом деле всё просто. Каждые ~6 dB (точнее 20 log(2) ~ 6.02 dB) указывают на изменение уровня сигнала в два раза. То есть, когда мы говорим о сигнале с уровнем -12 dBFS, понимаем, что это сигнал, уровень которого в четыре раза меньше максимального, а -18 dBFS — в восемь, и так далее. Если посмотреть на определение децибела, в нём указывается значение ) — тогда откуда берётся 20? Всё дело в том, что децибел — это логарифм отношения двух одноимённых энергетических величин, умноженный на 10. Амплитуда же не является **энергетической** величиной, следовательно её нужно перевести в подходящую величину. Мощность, которую переносят волны с разными амплитудами, пропорциональна квадрату амплитуды. Следовательно для амплитуды (если все прочие условия, кроме амплитуды принять неизменными) формулу можно записать как %20%3D>%2020%20log(a%2Fa_0))
**N.B.** Стоит упомянуть, что логарифм в данном случае берётся десятичный, в то время как большинство библиотек под функцией с названием log подразумевает натуральный логарифм.
При различной глубине дискретизации уровень сигнала по этой шкале изменяться не будет. Сигнал с уровнем -6 dBFS останется сигналом с уровнем -6 dBFS. Но всё же одна характеристика изменится — динамический диапазон. Динамический диапазон сигнала — это разница между его минимальным и максимальным значением. Он рассчитывается по формуле ), где n — глубина дискретизации (для грубых оценок можно пользоваться более простой формулой: n \* 6). Для 16 бит это ~96.33 dB, для 24 бит ~144.49 dB. Это означает, что самый большой перепад уровня, который можно описать с 24-битной глубиной дискретизации (144.49 dB), на 48.16 dB больше, чем самый большой перепад уровня с 16-битной глубиной (96.33 dB). Плюс к тому — шум дробления при 24 битах на 48 dB тише.
Восприятие
==========
Когда мы говорим о восприятии звука человеком, следует сначала разобраться, каким образом люди воспринимают звук. Очевидно, что мы слышим с помощью [ушей](https://en.wikipedia.org/wiki/Ear). Звуковые волны взаимодействуют с барабанной перепонкой, смещая её. Вибрации передаются во внутреннее ухо, где их улавливают рецепторы. То, насколько смещается барабанная перепонка, зависит от такой характеристики, как [звуковое давление](https://en.wikipedia.org/wiki/Sound_pressure). При этом [воспринимаемая громкость](https://en.wikipedia.org/wiki/Loudness) зависит от звукового давления не напрямую, а логарифмически. Поэтому при изменении громкости принято использовать относительную шкалу SPL (уровень звукового давления), значения которой указываются всё в тех же децибелах. Стоит также заметить, что воспринимаемая громкость звука зависит не только от уровня звукового давления, но ещё и от частоты звука:
*Рис. 6. Зависимость воспринимаемой громкости от частоты и амплитуды звука.
Источник: [ru.wikipedia.org/wiki/Громкость\_звука](https://ru.wikipedia.org/wiki/Громкость_звука)*
Громкость
=========
Простейшим примером обработки звука является изменение его громкости. При этом происходит просто умножение уровня сигнала на некоторое фиксированное значение. Однако даже в таком простом деле, как регулировка громкости, есть один подводный камень. Как я уже отметил ранее, воспринимаемая громкость зависит от логарифма звукового давления, а это значит, что использование линейной шкалы громкости оказывается не очень эффективным. При линейной шкале громкости возникает сразу две проблемы — для ощутимого изменения громкости, когда ползунок находится выше середины шкалы приходится достаточно далеко его сдвигать, при этом ближе к самому низу шкалы сдвиг меньше, чем на толщину волоса, может изменить громкость в два раза (думаю, с этим каждый сталкивался). Для решения данной проблемы используется логарифмическая шкала громкости. При этом на всей её длине передвижение ползунка на фиксированное расстояние меняет громкость в одинаковое количество раз. В профессиональной записывающей и обрабатывающей аппаратуре, как правило, используется именно логарифмическая шкала громкости.
Математика
==========
Тут я, пожалуй, немного вернусь к математике, потому что реализация логарифмической шкалы оказывается не такой простой и очевидной вещью для многих, а найти в интернете данную формулу не так просто, как хотелось бы. Заодно покажу, как просто переводить значения громкости в dBFS и обратно. Для дальнейших объяснений это будет полезным.
```
// Минимальное значение громкости - на этом уровне идёт отключение звука
var EPSILON = 0.001;
// Коэффициент для преобразований в dBFS и обратно
var DBFS_COEF = 20 / Math.log(10);
// По положению на шкале вычисляет громкость
var volumeToExponent = function(value) {
var volume = Math.pow(EPSILON, 1 - value);
return volume > EPSILON ? volume : 0;
};
// По значению громкости вычисляет положение на шкале
var volumeFromExponent = function(volume) {
return 1 - Math.log(Math.max(volume, EPSILON)) / Math.log(EPSILON);
};
// Перевод значения громкости в dBFS
var volumeToDBFS = function(volume) {
return Math.log(volume) * DBFS_COEF;
};
// Перевод значения dBFS в громкость
var volumeFromDBFS = function(dbfs) {
return Math.exp(dbfs / DBFS_COEF);
}
```
Цифровая обработка
==================
Теперь вернёмся к тому, что мы имеем цифровой, а не аналоговый сигнал. У цифрового сигнала есть две особенности, которые стоит учитывать при работе с громкостью:
* точность, с которой указывается уровень сигнала, ограничена (причём достаточно сильно. 16 бит — это в 2 раза меньше, чем используется для стандартного числа с плавающей точкой);
* у сигнала есть верхняя граница уровня, за которую он не может выйти.
Из того, что уровень сигнала имеет ограничение точности, следует две вещи:
* уровень шумов дробления возрастает при увеличении громкости. Для малых изменений обычно это не очень критично, так как изначальный уровень шума значительно тише ощутимого, и его можно безопасно поднимать в 4-8 раз (например, применять эквалайзер с ограничением шкалы в ±12dB);
* не стоит сначала сильно понижать уровень сигнала, а затем сильно его повышать — при этом могут появиться новые шумы дробления, которых изначально не было.
Из того, что сигнал имеет верхнее ограничение уровня, следует, что нельзя безопасно увеличивать громкость выше единицы. При этом пики, которые окажутся выше границы, будут «срезаны» и произойдёт потеря данных.
*Рис. 7. Клиппинг.
Источник: <https://en.wikipedia.org/wiki/Clipping_(audio)>*
На практике всё это означает, что стандартные для Audio-CD параметры дискретизации (16 бит, 44,1 кГц) не позволяют производить качественную обработку звука, потому что имеют очень малую избыточность. Для этих целей лучше использовать более избыточные форматы. Однако стоит учитывать, что общий размер файла пропорционален параметрам дискретизации, поэтому выдача таких файлов для он-лайн воспроизведения — не лучшая идея.
Измерение громкости
===================
Для того чтобы сравнивать громкость двух разных сигналов, её для начала нужно как-то измерить. Существует по меньшей мере три метрики для измерения громкости сигналов — максимальное пиковое значение, усреднённое значение уровня сигнала и метрика ReplayGain.
Максимальное пиковое значение достаточно слабая метрика для оценки громкости. Она никак не учитывает общий уровень громкости — например, если записать грозу, то большую часть времени на записи будет тихо шелестеть дождь и лишь пару раз прогремит гром. Максимальное пиковое значение уровня сигнала у такой записи будет довольно высоким, но большая часть записи будет иметь весьма низкий уровень сигнала. Однако эта метрика всё равно является полезной — она позволяет вычислить максимальное усиление, которое можно применить к записи, при котором не будет потерь данных из-за «обрезания» пиков.
Усреднённое значение уровня сигнала — более полезная метрика и легко вычислимая, но всё же имеет существенные недостатки, связанные с тем, как мы воспринимаем звук. Визг циркулярной пилы и рокот водопада, записанные с одинаковым средним уровнем сигнала, будут восприниматься совершенно по-разному.
[ReplayGain](https://en.wikipedia.org/wiki/ReplayGain) наиболее точно передает воспринимаемый уровень громкости записи и учитывает физиологические и психические особенности восприятия звука. Для промышленного выпуска записей многие звукозаписывающие студии используют именно её, также она поддерживается большинством популярных медиа-плееров. ([Русская статья](https://ru.wikipedia.org/wiki/ReplayGain) на WIKI содержит много неточностей и фактически не корректно описывает саму суть технологии)
Нормализация громкости
======================
Если мы можем измерять громкость различных записей, мы можем её нормализовать. Идея нормализации состоит в том, чтобы привести разные звуки к одинаковому уровню воспринимаемой громкости. Для этого используется несколько различных подходов. Как правило, громкость стараются максимизировать, но это не всегда возможно из-за ограничений максимального уровня сигнала. Поэтому обычно берётся некоторое значение немного меньше максимума (например -14 dBFS), к которому пытаются привести все сигналы.
Иногда нормализацию громкости производят в рамках одной записи — при этом различные части записи усиливают на разные величины, чтобы их воспринимаемая громкость была одинаковой. Такой подход очень часто применяется в компьютерных видео-плеерах — звуковая дорожка многих фильмов может содержать участки с очень сильно отличающейся громкостью. В такой ситуации возникают проблемы при просмотре фильмов без наушников в позднее время — при громкости, на которой нормально слышен шёпот главных героев, выстрелы способны перебудить соседей. А на громкости, при которой выстрелы не бьют по ушам, шёпот становится вообще неразличим. При внутри-трековой нормализации громкости плеер автоматически увеличивает громкость на тихих участках и понижает на громких. Однако этот подход создаёт ощутимые артефакты воспроизведения при резких переходах между тихим и громким звуком, а также порой завышает громкость некоторых звуков, которые по задумке должны быть фоновыми и еле различимыми.
Также внутреннюю нормализацию порой производят, чтобы повысить общую громкость треков. Это называется нормализацией с компрессией. При этом подходе среднее значение уровня сигнала максимизируется за счёт усиления всего сигнала на заданную величину. Те участки, которые должны были быть подвергнуты «обрезанию», из-за превышения максимального уровня усиливаются на меньшую величину, позволяя избежать этого. Этот способ увеличения громкости значительно снижает качество звучания трека, но, тем не менее, многие звукозаписывающие студии не брезгуют его применять.
Фильтрация
==========
Я не стану описывать совсем все аудио-фильтры, ограничусь только стандартными, которые присутствуют в Web Audio API. Самым простым и распространённым из них является биквадратный фильтр ([BiquadFilterNode](https://developer.mozilla.org/ru/docs/Web/API/BiquadFilterNode)) — это активный фильтр второго порядка с [бесконечной импульсной характеристикой](https://ru.wikipedia.org/wiki/Фильтр_с_бесконечной_импульсной_характеристикой), который может воспроизводить достаточно большое количество эффектов. Принцип работы этого фильтра основан на использовании двух буферов, каждый с двумя отсчётами. Один буфер содержит два последних отсчёта во входном сигнале, другой — два последних отсчёта в выходном сигнале. Результирующее значение получается с помощью суммирования пяти значений: текущего отсчёта и отсчётов из обоих буферов перемноженных на заранее вычисленные коэффициенты. Коэффициенты данного фильтра задаются не напрямую, а вычисляются из параметров частоты, добротности (Q) и усиления.
*Все графики ниже отображают диапазон частот от 20 Гц до 20000 Гц. Горизонтальная ось отображает частоту, по ней применяется логарифмический масштаб, вертикальная — магнитуду (жёлтый график) от 0 до 2, или фазовый сдвиг (зелёный график) от -Pi до Pi. Частота всех фильтров (632 Гц) отмечена красной чертой на графике.*
Lowpass
-------
*Рис. 8. Фильтр lowpass.*
Пропускает только частоты ниже заданной частоты. Фильтр задаётся частотой и добротностью.
Highpass
--------
*Рис. 9. Фильтр highpass.*
Действует аналогично lowpass, за исключением того, что он пропускает частоты выше заданной, а не ниже.
Bandpass
--------
*Рис. 10. Фильтр bandpass.*
Этот фильтр более избирателен — он пропускает только определённую полосу частот.
Notch
-----
*Рис. 11. Фильтр notch.*
Является противоположностью bandpass — пропускает все частоты вне заданной полосы. Стоит, однако, отметить разность в графиках затухания воздействия и в фазовых характеристиках данных фильтров.
Lowshelf
--------
*Рис. 12. Фильтр lowshelf.*
Является более «умной» версией highpass — усиливает или ослабляет частоты ниже заданной, частоты выше пропускает без изменений. Фильтр задаётся частотой и усилением.
Highshelf
---------
*Рис. 13. Фильтр highshelf.*
Более умная версия lowpass — усиливает или ослабляет частоты выше заданной, частоты ниже пропускает без изменений.
Peaking
-------
*Рис. 14. Фильтр peaking.*
Это уже более «умная» версия notch — он усиливает или ослабляет частоты в заданном диапазоне и пропускает остальные частоты без изменений. Фильтр задаётся частотой, усилением и добротностью.
Фильтр allpass
--------------
*Рис. 15. Фильтр allpass.*
Allpass отличается ото всех остальных — он не меняет амплитудные характеристики сигнала, вместо чего делает фазовый сдвиг заданных частот. Фильтр задаётся частотой и добротностью.
Фильтр WaveShaperNode
---------------------
[Вейвшейпер](http://wikisound.org/Waveshaper) ([en](https://en.wikipedia.org/wiki/Waveshaper)) применяется для формирования сложных эффектов звуковых искажений, в частности с помощью него можно реализовать эффекты [«дисторшна»](https://en.wikipedia.org/wiki/Distortion_(music)), [«овердрайва»](https://ru.wikipedia.org/wiki/Овердрайв_%28звуковой_эффект%29) и [«фузза»](https://ru.wikipedia.org/wiki/Фузз_%28эффект%29). Данный фильтр применяет к входному сигналу специальную формирующую функцию. Принципы построения подобных функций довольно сложные и тянут на отдельную статью, поэтому я опущу их описание.
Фильтр ConvolverNode
--------------------
Фильтр, производящий [линейную свёртку](https://en.wikipedia.org/wiki/Convolution) входного сигнала с аудио-буфером, задающим некую [импульсную характеристику](https://en.wikipedia.org/wiki/Impulse_response). Импульсная характеристика — это ответ некой системы на единичный импульс. Простым языком это можно назвать «фотографией» звука. Если реальная фотография содержит информацию о световых волнах, о том, насколько они отражаются, поглощаются и взаимодействуют, то импульсная характеристика содержит аналогичную информацию о звуковых волнах. Свёртка аудио-потока с подобной «фотографией» как бы накладывает эффекты окружения, в котором была сняла импульсная характеристика на входной сигнал.
Для работы данного фильтра требуется разложение сигнала на частотные составляющие. Это разложение производится с помощью [быстрого преобразования Фурье](http://habrahabr.ru/post/196374/) (к сожалению, в русскоязычной Википедии совершенно несодержательная [статья](https://ru.wikipedia.org/wiki/Быстрое_преобразование_Фурье), написанная, судя по всему, для людей, которые и так знают, что такое БПФ и сами могут написать такую же несодержательную статью). Как я уже говорил во вступлении, не стану приводить в данной статье математику БПФ, однако не упомянуть краеугольный алгоритм для цифровой обработки сигналов было бы неправильно.
Данный фильтр реализует эффект [реверберации](https://en.wikipedia.org/wiki/Reverberation). Существует множество библиотек готовых аудио-буферов для данного фильтра, которые реализуют различные эффекты ([1](https://www.freesound.org/people/jorickhoofd/packs/9893/), [2](http://www.voxengo.com/impulses/)), подобные библиотеки хорошо находятся по запросу [impulse response mp3].
Материалы
=========
* [О понятии громкости в цифровом представлении звука и о методах её повышения](http://audiophilesoft.ru/publ/my/digital_loudness/11-1-0-86)
* [Звук](https://ru.wikipedia.org/wiki/Звук)
* [Амплитуда](https://ru.wikipedia.org/wiki/Амплитуда)
* [Частота](https://ru.wikipedia.org/wiki/Частота)
* [Цифровой сигнал](https://ru.wikipedia.org/wiki/Цифровой_сигнал)
* [Аналоговый сигнал](https://ru.wikipedia.org/wiki/Аналоговый_сигнал)
* [Цифровая обработка сигналов](https://ru.wikipedia.org/wiki/Цифровая_обработка_сигналов)
* [Интерактивный пример сложения волн и оцифровки сигнала](https://www.desmos.com/calculator/aojmanpjrl)
* [Аналогово-цифровой преобразователь](https://ru.wikipedia.org/wiki/Аналого-цифровой_преобразователь)
* [Цифро-аналоговый преобразователь](https://ru.wikipedia.org/wiki/Цифро-аналоговый_преобразователь)
* [Импульсно-кодовая модуляция](https://ru.wikipedia.org/wiki/Импульсно-кодовая_модуляция)
* [Формат PCM WAV](http://wav-pcm.narod.ru/)
* [Сэмплирование (en)](https://en.wikipedia.org/wiki/Sampling_%28signal_processing%29)
* [Частота дискретизации](https://ru.wikipedia.org/wiki/Частота_дискретизации)
* [Теорема Котельникова](https://ru.wikipedia.org/wiki/Теорема_Котельникова)
* [Частота Найквиста](https://ru.wikipedia.org/wiki/Частота_Найквиста)
* [Глубина дискретизации](https://ru.wikipedia.org/wiki/Квантование_%28обработка_сигналов%29)
* [Alias](https://ru.wikipedia.org/wiki/Алиасинг)
* [Децибел](https://ru.wikipedia.org/wiki/Децибел)
* [Строение уха](https://ru.wikipedia.org/wiki/Ухо)
* [Звуковое давление](https://ru.wikipedia.org/wiki/Звуковое_давление)
* [Воспринимаемая громкость](https://ru.wikipedia.org/wiki/Громкость_звука)
* [Клиппинг](https://en.wikipedia.org/wiki/Clipping_%28audio%29)
* [ReplayGain описание](https://en.wikipedia.org/wiki/ReplayGain)
* [ReplayGain спецификация](http://wiki.hydrogenaud.io/index.php?title=ReplayGain_specification)
* [Быстрое преобразование Фурье](http://habrahabr.ru/post/196374/), [вики](https://ru.wikipedia.org/wiki/Быстрое_преобразование_Фурье), [wiki](https://en.wikipedia.org/wiki/Fast_Fourier_transform)
* [Импульсная характеристика](https://ru.wikipedia.org/wiki/Импульсная_переходная_функция)
* [Фазо-частотная характеристика](https://ru.wikipedia.org/wiki/Фазо-частотная_характеристика)
* [Амплитудо-частотная характеристика](https://ru.wikipedia.org/wiki/Амплитудно-частотная_характеристика)
* [Фильтр с бесконечной импульсной характеристикой](https://ru.wikipedia.org/wiki/Фильтр_с_бесконечной_импульсной_характеристикой)
* [Фильтр с конечной импульсной характеристикой](https://ru.wikipedia.org/wiki/Фильтр_с_конечной_импульсной_характеристикой)
* [Биквадратный фильтр (en)](https://en.wikipedia.org/wiki/Digital_biquad_filter)
* [BiquadFilterNode](https://developer.mozilla.org/ru/docs/Web/API/BiquadFilterNode)
* [HTML5 Audio W3C](http://www.w3.org/TR/html5/embedded-content-0.html#the-audio-element)
* [Web Audio API](https://developer.mozilla.org/en-US/docs/Web/API/AudioContext)
* [Вейвшейпер](http://wikisound.org/Waveshaper)
* [Дисторшн](https://ru.wikipedia.org/wiki/Дисторшн)
* [Овердрайв](https://ru.wikipedia.org/wiki/Овердрайв_%28звуковой_эффект%29)
* [Фузз](https://ru.wikipedia.org/wiki/Фузз_%28эффект%29)
* [Реверберации](https://ru.wikipedia.org/wiki/Реверберация)
* [Свёртка](https://ru.wikipedia.org/wiki/Свёртка_%28математический_анализ%29)
* [Эквалайзер](https://ru.wikipedia.org/wiki/Эквалайзер)
Большое спасибо моим коллегам, которые помогали собирать материалы для этой статьи и давали полезные советы.
Отдельное спасибо Тарасу [Audiophile](https://habrahabr.ru/users/audiophile/) Ковриженко за описание алгоритмов нормализации и максимизации громкости и Сергею [forgotten](https://habrahabr.ru/users/forgotten/) Константинову за большое количество пояснений и советов по данной статье.
**UPD. Поправил раздел про фильтрацию и добавил ссылки по разным типам фильтров. Спасибо Денису [deniskreshikhin](https://habrahabr.ru/users/deniskreshikhin/) Крешихину и Никите [merlin-vrn](https://habrahabr.ru/users/merlin-vrn/) Киприянову за то, что обратили внимание.** | https://habr.com/ru/post/270765/ | null | ru | null |
# Загрузчик изображений. Закрывая тему
#### Предисловие
Всем привет. О создании загрузчика изображений я уже писал. Сначала — [загрузчик на flash](http://habrahabr.ru/blogs/Flash_Platform/132489/), затем — [на html5](http://habrahabr.ru/blogs/html5/133351/). По большому счёту, этих двух вариантов достаточно. И если вы поклонник рациональности, а сама тема особенного интереса не вызывает, то можете дальше не читать.
Рабочий пример загрузчика на Silverlight 4 привожу здесь же: [да вот он](http://alvaro.jdart.ru/wp-content/uploads/Uploader/Uploader.zip).
Напомню задачу. Необходимо реализовать пакетную загрузку изображений, ресайз на клиенте, а также удобное получение файлов на сервере(например, в массив $\_FILES в php). Ну и удобный интерфейс, разумеется.
Теперь перейдем к инструментарию. В данном случае мы используем Silverlight 4, а значит у нас есть мощь .Net, статическая типизация(да-да, я знаю, dynamic рулит), классный бесплатный редактор(Microsoft Visual Web Developer 2010 Express).
#### Работа с изображениями
Итак, C#. Язык мне нравится(даже диплом я на нём писал), однако после javascript, actionscript и php не очень привычно. Впрочем, это быстро проходит.
Чтобы получить список файлов, нам потребуется OpenFileDialog. Загрузить файлы тоже не проблема: через FileStream это легко сделать. Сами данные в Silverlight у нас есть, теперь нужно представить их виде изображений и потом ресайзить.
Удивительно, но представить данные в Bitmap мы можем(WriteableBitmap), но нет встроенных методов для ресайза и тем паче для кодирования обратно в png или jpeg. Всё это, естественно, можно сделать вручную. Но это тема для отдельной статьи, тем более подобные вопросы много раз пережевывались, и на Хабре в том числе. Поэтому возьмем библиотеку, которая даст больше возможностей. Я использовал ImageTools. Для своих нужд написал класс MyImage, который реализует требующийся мне функционал:
```
using System;
using System.Net;
using System.Windows;
using System.IO;
using System.Windows.Media.Imaging;
using ImageTools;
using ImageTools.IO.Bmp;
using ImageTools.IO.Jpeg;
using ImageTools.IO.Png;
using ImageTools.Helpers;
using ImageTools.Filtering;
using ImageTools.IO;
namespace Uploader.Libs
{
public class MyImage
{
private ExtendedImage im; //базовый класс из библиотеки ImageTools
public string name { get; set; }
public string extension { get; set; }
public FileInfo origin { get; set; }
public int originSize
{
get
{
return origin != null ? Utils.ByteToKB((int)origin.Length) : 0; //Utils - мой класс для всяких доп.функций
}
}
public MyImage(FileInfo fileinfo)
{
name = fileinfo.Name;
extension = fileinfo.Extension;
origin = fileinfo;
WriteableBitmap bmp = new WriteableBitmap(1, 1);
bmp.SetSource(origin.OpenRead());
im = bmp.ToImage();
}
public MyImage(ExtendedImage im, string name, string extension)
{
this.name = name;
this.extension = extension;
this.im = im;
}
public MyImage resize(int width, int height)
{
string prefix = width.ToString() + "_" + height.ToString() + "_";
ExtendedImage rImage = ExtendedImage.Resize(im, width, height, new ImageTools.Filtering.NearestNeighborResizer()); //пользуемся возможностями библиотеки для ресайза
return new MyImage(rImage, prefix + name, extension);
}
//ресайз, сохраняя пропорции
public MyImage scale(int value)
{
double width = im.PixelWidth;
double height = im.PixelHeight;
double max = width > height ? width : height;
double sc = max > value ? value / max : 1;
int nWidth = (int)Math.Round(sc * width);
int nHeight = (int)Math.Round(sc * height);
return resize(nWidth, nHeight);
}
//метод для получения оригинала изображения
public byte[] getOrigin()
{
byte[] buffer;
if (origin != null)
{
FileStream fStream = origin.OpenRead();
buffer = new byte[fStream.Length];
fStream.Read(buffer, 0, buffer.Length);
}
else buffer = null;
return buffer;
}
//метод для получения конечного byte-контейнера, именно он нужен для загрузки
public byte[] toByte(string extension = "")
{
MemoryStream mStream = new MemoryStream();
string ext = extension != String.Empty ? extension : this.extension;
dynamic encoder; //кодируем изображение в тот формат, который имеет оригинал, поэтому воспользуемся dynamic
switch (ext)
{
case ".png":
encoder = new PngEncoder();
break;
default:
encoder = new JpegEncoder();
break;
}
encoder.Quality = 100; //кодируем с максимальным качеством
encoder.Encode(im, mStream);
return mStream.ToArray();
}
//base64 нам потребуется для вывода в html превью изображения
public string toBase64(byte[] data = null)
{
byte[] iData = data != null ? data : toByte();
return "data:image/" + extension.Substring(1) + ";base64," + Convert.ToBase64String(iData);
}
}
}
```
Итак, у нас есть изображения, есть функционал для работы с ними, в итоге есть массив byte[] для отправки на сервер.
#### Шапка
Вообще взаимодействие с сервером на silverlight тема для отдельной статьи(разберусь побольше и напишу, скорее всего). Достаточно сказать, что просто передать переменные на сервер(без использования веб-сервиса, soap) не так-то просто. В итоге, как и для flash придется формировать шапку запроса самим, эмулируя, таким образом, отправку формы. В итоге получилась очередная реинкарнация моего класса для формирования шапки:
```
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Browser;
namespace Uploader.Libs
{
public class FormBuilder
{
private string BOUND;
private string ENTER = "\r\n";
private string ADDB = "--";
UTF8Encoding encoding;
private List Data;
public string bound
{
get { return BOUND; }
}
public FormBuilder()
{
BOUND = getBoundary();
Data = new List();
encoding = new UTF8Encoding();
}
public void addFile(string name, byte[] buffer)
{
string encode\_name = HttpUtility.UrlEncode(name);
StringBuilder header = new StringBuilder();
header.Append(ADDB + BOUND);
header.Append(ENTER);
header.Append("Content-Disposition: form-data; name='" + encode\_name + "'; filename='" + encode\_name + "'");
header.Append(ENTER);
header.Append("Content-Type: application/octet-stream");
header.Append(ENTER);
header.Append(ENTER);
Data.AddRange(encoding.GetBytes(header.ToString()));
Data.AddRange(buffer);
Data.AddRange(encoding.GetBytes(ENTER));
}
public void addParam(string name, string value)
{
StringBuilder header = new StringBuilder();
header.Append(ADDB + BOUND);
header.Append(ENTER);
header.Append("Content-Disposition: form-data; name='" + name + "'");
header.Append(ENTER);
header.Append(ENTER);
header.Append(value);
header.Append(ENTER);
Data.AddRange(encoding.GetBytes(header.ToString()));
}
public byte[] getForm()
{
StringBuilder header = new StringBuilder();
header.Append(ENTER);
header.Append(ENTER);
header.Append(ADDB + BOUND + ADDB);
Data.AddRange(encoding.GetBytes(header.ToString()));
byte[] formData = new byte[Data.Count];
Data.CopyTo(formData);
return formData;
}
private string getBoundary()
{
string \_boundary = "";
Random rnd = new Random();
for (int i = 0; i < 0x20; i++)
{
\_boundary += (char)(97 + rnd.NextDouble() \* 25);
}
return \_boundary;
}
}
}
```
#### Асинхронность
Вот мы и перешли к самому интересному. Собственно, к механизмам загрузки данных на сервер и получению ответа. В нашем случае понадобится HttpWebRequest. Вообще идеология работы с этим классом и с запросами в silverlight не столь очевидна, поэтому имеет смысл расписать последовательность действий:
1) Создание экземпляра HttpWebRequest, указание url назначения, метода отправки(Post,Get), заголовка(Content-type).
2) Далее вызов метода BeginGetRequestStream. У этого метода 2 параметра. Первый — это делегат функции, которая и будет вызвана. Второй — параметры переданные этой функции. Вообще, зачем нам эта функция? Она нужна для того, чтобы получить доступ к потоку(Stream), записывающему данные на сервер. Поток можно получить методом EndGetRequestStream.
Стоит отметить, что функция вызывается асинхронно и в отдельном потоке(не путать со Stream), то есть доступа к пользовательскому интерфейсу у нас нет. С этим можно побороться двумя путями: через вызов Dispatcher.BeginInvoke(вызов функции в потоке пользовательского интерфейса) или же через SynchronizationContext сначала сохранить контекст синхронизации для потока пользовательского интерфейса, а потом в требуемом месте вызвать функцию, которая асинхронно выполнится в этом потоке.
3) Далее просто записываем через Write данные(тут же можно и отслеживать процент загрузки).
4) Далее вызов метода BeginGetResponse, который запрашивает ответ от сервера. Параметры у метода такие же как и для BeginGetRequestStream, и функция тоже вызывается асинхронно.
5) В этой функции получаем экземпляр HttpWebResponse(методом EndGetResponse объекта HttpWebRequest).
6) Далее получаем поток(Stream) с ответом(вызвав метода GetResponseStream объекта HttpWebResponse). А из потока уже получаем сам ответ(через StreamReader.ReadToEnd).
Я понимаю, что объяснение корявое, но по-другому я не сумел. Надеюсь, пример кода будет наглядней(ну и некоторые комментарии в коде тоже присутствуют):
```
SynchronizationContext sync; //контекст синхронизации для потока пользовательского интерфейса
Dictionary images; //собственно коллекция изображений
HtmlView mainView; //это мой класс для вывода в представление html
string script = "../upload.php"; //php-скрипт, обрабатывающий полученные файлы
private void upload()
{
if (images.Count > 0)
{
MyImage im = (MyImage)(images.First().Value);
MyImage mini = im.scale(300); //ресайзим
FormBuilder builder = new FormBuilder(); //класс формирования шапки
builder.addFile(im.name, im.getOrigin());
builder.addFile(mini.name, mini.toByte());
byte[] formData = builder.getForm();
Uri uri = new Uri(script, UriKind.Relative);
HttpWebRequest request = (HttpWebRequest)WebRequestCreator.BrowserHttp.Create(uri); // здесь мы используем Browser Http Stack для того, чтобы можно было отправлять куки
request.Method = "POST";
request.ContentType = "multipart/form-data; boundary=" + builder.bound;
request.ContentLength = formData.Length;
List uploadState = new List(); //собственно объект, который мы передаем в функцию
uploadState.Add(request);
uploadState.Add(formData);
request.BeginGetRequestStream(new AsyncCallback(GetRequestStream), uploadState);
}
}
private void GetRequestStream(IAsyncResult result)
{
List state = (List)result.AsyncState;
HttpWebRequest request = (HttpWebRequest)state[0];
byte[] data = (byte[])state[1];
int k = 0;
int h = data.Length / 100;
int ost = data.Length % 100;
int dLength = data.Length - ost;
Stream writeStream = request.EndGetRequestStream(result); //получаем поток
for (int i = 0; i < dLength; i += h)
{
writeStream.Write(data, i, h);
k++;
Dispatcher.BeginInvoke(() =>
{
mainView.setPercent(k); //отслеживаем загрузку
});
}
if (ost > 0) writeStream.Write(data, dLength, ost);
writeStream.Close();
request.BeginGetResponse(new AsyncCallback(GetResponse), request);
}
private void GetResponse(IAsyncResult result)
{
HttpWebRequest request = (HttpWebRequest)result.AsyncState;
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result);
sync.Post(onComplete, response); //вызываем функцию в потоке пользовательского интерфейса
}
private void onComplete(object state)
{
HttpWebResponse response = (HttpWebResponse)state;
if (response.StatusCode == HttpStatusCode.OK)
{
StreamReader reader = new StreamReader(response.GetResponseStream());
string responseText = reader.ReadToEnd();
reader.Close();
}
images.Remove(images.First().Key); //удаляем загруженное изображение из коллекции
mainView.setRowComplete();
upload(); //переходим к следующему изображению
}
```
Такая вот загрузка. Зато на сервере ничто не мешает нам воспользоваться банальным и знакомым скриптом:
```
foreach($_FILES as $key => $value){
$filename = substr_replace($key, '.', -4, 1);
move_uploaded_file($value['tmp_name'], "upload/". urldecode($filename));
}
echo 'complete';
```
#### Представление
Остался вопрос, как должен выглядеть интерфейс загрузсика(xaml или html). Тут уж каждый решает, как ему больше нравится. Я сделал в виде html. То есть кнопка вызова диалога выбора файлов, конечно, на silverlight(в силу ограничения безопасности). Зато всё остальное на html(включая и превью изображений, их я выводил в виде base64). В этом мне помогли замечательные классы Html Bridge, позволяющие работать с DOM-деревом прямо из silverlight.
Вот так выглядит демка загрузчика:
#### За скобками
Хочется сказать спасибо хабраюзеру [Demetros](https://habrahabr.ru/users/demetros/) за отличные статьи на эту же тему, а также хабраюзерам, кто в комментариях к моим предыдущим статьям давал ссылки на готовые решения. Те, кто заинтересуются этой темой, могут найти что-то для своих задач.
Поздравляю всех с Новым годом и желаю, чтобы ваша работа была продолжением ваших увлечений! | https://habr.com/ru/post/135481/ | null | ru | null |
# Новый HAProxy Data Plane API: два примера программной конфигурации
Используйте HAProxy Data Plane API для динамического управления конфигурацией балансировщика нагрузки с помощью HTTP-команд.
Проектирование для высокой доступности почти всегда означает наличие высокого уровня прокси / балансировщика нагрузки. Прокси-сервер предоставляет основные услуги, такие как:
* обнаружение и удаление неисправных серверов
* очередь соединений
* разгрузка шифрования TLS
* компрессия
* кэширование
Задача состоит в том, чтобы поддерживать ваши конфигурации в актуальном состоянии, что особенно сложно, поскольку сервисы перемещаются в контейнеры, и эти контейнеры становятся эфемерными. Доступный начиная с [HAProxy 2.0](https://www.haproxy.com/blog/haproxy-2-0-and-beyond/) вы можете использовать новый [HAProxy Data Plane API](https://www.haproxy.com/documentation/hapee/1-9r1/configuration/dataplaneapi/) (Перевод: <https://habr.com/ru/post/508132/>), который является современным REST API.
HAProxy Data Plane API дополняет [гибкий язык конфигурации](https://www.haproxy.com/blog/the-four-essential-sections-of-an-haproxy-configuration/) HAProxy, который предоставляет строительные блоки для определения простых и сложных правил маршрутизации. Это также идеальное дополнение к существующему [Runtime API](https://www.haproxy.com/blog/dynamic-configuration-haproxy-runtime-api/), которое позволяет запускать, останавливать и пропускать трафик с серверов, изменять вес сервера и управлять проверками работоспособности.
Новый Data Plane API дает вам возможность динамически добавлять и настраивать внешние интерфейсы, внутренние интерфейсы и логику маршрутизации трафика. Вы также можете использовать его для обновления конечных точек ведения журнала и создания фильтров SPOE. По сути, почти весь балансировщик нагрузки может быть настроен с помощью HTTP-команд. В этой статье вы узнаете, как лучше его использовать.
Управление конфигурацией
------------------------
Обычно при настройке HAProxy вам нужно вручную отредактировать файл конфигурации `/etc/haproxy/haproxy.cfg`. Этот файл используется для управления всеми функциями балансировщика нагрузки. Он в основном разделен на `frontend` разделы, определяющие общедоступные IP-адреса, к которым подключаются клиенты, и `backend` разделы, содержащие вышестоящие сервера, на которые направляется трафик. Но вы можете сделать гораздо больше, в том числе установить глобальные параметры, влияющие на работающий процесс, установить значения по умолчанию, добавить анализ поведения трафика с помощью таблиц флеш-памяти, прочитать файлы карт, определить правила фильтрации с помощью ACL и многое другое.
Хотя редактировать файл вручную довольно просто, это не всегда целесообразно, особенно при работе с десятками или даже сотнями сервисов и прокси. Это позволяет всему трафику проходить от прокси к прокси, по существу абстрагируя сеть и ее непостоянство от смежных сервисов приложений. Прокси на этом уровне могут добавить к вашим услугам логику повторных попыток, авторизацию и шифрование TLS. Тем не менее, количество прокси будет быстро расти, так как для каждой услуги есть свой прокси.
В этом случае крайне важно иметь возможность вызвать HTTP API для динамического обновления определений прокси. В сервисной сетке программное обеспечение Data Plane контролирует прокси и динамически вызывает API конфигурации. HAProxy Data Plane API позволяет интегрировать HAProxy с этими платформами. Более того, API использует API времени выполнения для внесения изменений, которые по возможности не требуют перезагрузки.
Data Plane API использует Go пакеты [config-parser](https://github.com/haproxytech/config-parser) и [client-native](https://github.com/haproxytech/client-native) для парсинга конфигурации HAProxy и вызова команд Runtime API соответственно. Вы можете использовать их в своих собственных проектах для интеграции с HAProxy.
Динамическое конфигурирование HAProxy
-------------------------------------
С помощью Data Plane API вы можете многое сделать. В этом разделе вы узнаете, как создать `backend` с серверами и `frontend`, который направляет трафик на него. Но сначала следуйте [официальной документации](https://www.haproxy.com/documentation/hapee/1-9r1/configuration/dataplaneapi/) по установке и настройке API.
После того как он будет установлен и запущен, вызовите GET в конечной точке **/v1/services/haproxy/configuration/backends**, чтобы увидеть уже определенные разделы `backend`, например:
```
$ curl --get --user admin:mypassword \
http://localhost:5555/v1/services/haproxy/configuration/backends
```
Если вы хотите добавить новый `backend`, вызовите тот же endpoint с помощью POST. Есть два способа внести изменения в это состояние — индивидуальные вызовы или пакетные команды внутри транзакции. Поскольку мы хотим внести несколько связанных изменений, давайте начнем с создания транзакции.
Вызовите endpoint **/v1/services/haproxy/transactions** для создания новой транзакции. Для этого потребуется параметр версии в URL, но командам внутри транзакции он не нужен. Всякий раз, когда вызывается команда POST, PUT или DELETE, должна быть включена версия, которая затем записывается в файл конфигурации HAProxy. Это гарантирует, что если несколько клиентов будут использовать API, они избежать конфликтов. Если версия, которую вы передаете, не соответствует версии, указанной в файле конфигурации, вы получите сообщение об ошибке. При использовании транзакции эта версия указывается заранее при ее создании.
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
http://localhost:5555/v1/services/haproxy/transactions?version=1
```
Вы найдете идентификатор транзакции в возвращенном документе JSON:
```
{"_version":5,"id":"9663c384-5052-4776-a968-abcef032aeef","status":"in_progress"}
```
Затем используйте endpoint **/v1/services/haproxy/configuration/backends**, чтобы создать новый бэкэнд, отправив идентификатор транзакции в качестве параметра URL:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "test_backend", "mode":"http", "balance": {"algorithm":"roundrobin"}, "httpchk": {"method": "HEAD", "uri": "/", "version": "HTTP/1.1"}}' \
http://localhost:5555/v1/services/haproxy/configuration/backends?transaction_id=9663c384-5052-4776-a968-abcef032aeef
```
Затем вызовите endpoint **/v1/services/haproxy/configuration/servers** для добавления серверов в `backend`:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "server1", "address": "127.0.0.1", "port": 8080, "check": "enabled", "maxconn": 30, "weight": 100}' \
"http://localhost:5555/v1/services/haproxy/configuration/servers?backend=test_backend&transaction_id=9663c384-5052-4776-a968-abcef032aeef"
```
Затем добавьте `frontend` с помощью endpoint **/v1/services/haproxy/configuration/frontends** :
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "test_frontend", "mode": "http", "default_backend": "test_backend", "maxconn": 2000}' \
http://localhost:5555/v1/services/haproxy/configuration/frontends?transaction_id=9663c384-5052-4776-a968-abcef032aeef
```
У этого `frontend` еще нет никаких `bind` операторов. Добавьте одно, используя endpoint **/v1/services/haproxy/configuration/binds**, как на примере:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "http", "address": "*", "port": 80}' \
"http://localhost:5555/v1/services/haproxy/configuration/binds?frontend=test_frontend&transaction_id=9663c384-5052-4776-a968-abcef032aeef"
```
Затем, чтобы зафиксировать транзакцию и применить все изменения, вызовите endpoint **/v1/services/haproxy/transactions/[transaction ID]** с помощью PUT, например:
```
$ curl -X PUT --user admin:mypassword \
-H "Content-Type: application/json" \
http://localhost:5555/v1/services/haproxy/transactions/9663c384-5052-4776-a968-abcef032aeef
```
Вот как выглядит конфигурация сейчас:
```
frontend test_frontend
mode http
maxconn 2000
bind *:80 name http
default_backend test_backend
backend test_backend
mode http
balance roundrobin
option httpchk HEAD / HTTP/1.1
server server1 127.0.0.1:8080 check maxconn 30 weight 100
```
Этот балансировщик нагрузки готов принимать трафик и перенаправлять его на вышестоящий сервер.
Поскольку в спецификации Data Plane API используется OpenAPI, его можно использовать для [генерации клиентского кода](https://github.com/OpenAPITools/openapi-generator) на многих поддерживаемых языках программирования.
Во время этого упражнения мы упаковали все команды внутри транзакции. Вы также можете вызывать их одну за другой. В этом случае вместо включения параметра URL с именем `transaction_id` вы должны включить одну `версию`, которая будет увеличиваться с каждым вызовом.
Другой пример
-------------
Вы увидели простоту и мощь HAProxy Data Plane API. С помощью нескольких HTTP-команд вы можете динамически изменять конфигурацию. Давайте рассмотрим другой пример. Мы создадим ACL, который будет проверять имеет ли заголовок *Host* значение **example.com**. Если это так, то строка **use\_backend** будет направлена на другой сервер с именем **example\_servers**. Мы также добавим правило **http-request deny**, которое будет отклонять любые запросы для пути URL **/admin.php**, если исходный IP-адрес клиента не находится в сети **192.168.50.20/24**.
Сначала используйте endpoint **/v1/services/haproxy/transactions** для создания новой транзакции и получения ее идентификатора:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
http://localhost:5555/v1/services/haproxy/transactions?version=2
{"_version":2,"id":"7d0d6737-655e-4489-92eb-6d29cdd69827","status":"in_progress"}
```
Затем используйте endpoint **/v1/services/haproxy/configuration/backends** вместе с идентификатором транзакции, чтобы создать новый `backend` с именем *example\_servers*:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "example_servers", "mode":"http", "balance": {"algorithm":"roundrobin"}}' \
http://localhost:5555/v1/services/haproxy/configuration/backends?transaction_id=7d0d6737-655e-4489-92eb-6d29cdd69827
```
Используйте endpoint **/v1/services/haproxy/configuration/servers** для добавления **server** в **backend**:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"name": "server1", "address": "127.0.0.1", "port": 8081, "check": "enabled", "maxconn": 30, "weight": 100}' \
"http://localhost:5555/v1/services/haproxy/configuration/servers?backend=example_servers&transaction_id=7d0d6737-655e-4489-92eb-6d29cdd69827"
```
Используйте endpoint **/v1/services/haproxy/configuration/acls**, чтобы определить ACL с именем *is\_example*, который проверяет, имеет ли заголовок узла значение **example.com**:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"id": 0, "acl_name": "is_example", "criterion": "req.hdr(Host)", "value": "example.com"}' \
"http://localhost:5555/v1/services/haproxy/configuration/acls?parent_type=frontend&parent_name=test_frontend&transaction_id=7d0d6737-655e-4489-92eb-6d29cdd69827"
```
Используйте **/v1/services/haproxy/configuration/backend\_switching\_rules**, чтобы добавить строку **use\_backend**, которая оценивает ACL *is\_example*:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"id": 0, "cond": "if", "cond_test": "is_example", "name": "example_servers"}' \
"http://localhost:5555/v1/services/haproxy/configuration/backend_switching_rules?frontend=test_frontend&transaction_id=7d0d6737-655e-4489-92eb-6d29cdd69827"
```
Используйте endpoint **/v1/services/haproxy/configuration/http\_request\_rules**, чтобы добавить правило **http-request deny**, которое проверяет, является ли путь **/admin.php**, а исходный IP-адрес клиента не находится в сети **192.168.50.20/24**:
```
$ curl -X POST --user admin:mypassword \
-H "Content-Type: application/json" \
-d '{"id": 0, "cond": "if", "cond_test": "{ path /admin.php } !{ src 192.168.50.20/24 }", "type": "deny"}' \
"http://localhost:5555/v1/services/haproxy/configuration/http_request_rules?parent_type=frontend&parent_name=test_frontend&transaction_id=7d0d6737-655e-4489-92eb-6d29cdd69827"
```
Затем подтвердите транзакцию, чтобы изменения вступили в силу:
```
$ curl -X PUT --user admin:mypassword \
-H "Content-Type: application/json" \
http://localhost:5555/v1/services/haproxy/transactions/7d0d6737-655e-4489-92eb-6d29cdd69827
```
Ваша конфигурация HAProxy теперь выглядит вот так:
```
frontend test_frontend
mode http
maxconn 2000
bind *:80 name http
acl is_example req.hdr(Host) example.com
http-request deny deny_status 0 if { path /admin.php } !{ src 192.168.50.20/24 }
use_backend example_servers if is_example
default_backend test_backend
backend example_servers
mode http
balance roundrobin
server server1 127.0.0.1:8081 check maxconn 30 weight 100
backend test_backend
mode http
balance roundrobin
option httpchk HEAD / HTTP/1.1
server server1 127.0.0.1:8080 check maxconn 30 weight 100
```
Заключение
----------
В этой статье вы ознакомились с HAProxy Data Plane API, который позволяет полностью настроить HAProxy с использованием современного REST API. Более подробную информацию можно найти в [официальной документации](https://www.haproxy.com/documentation/hapee/1-9r1/configuration/dataplaneapi/) (Перевод: <https://habr.com/ru/post/508132/>). У него имеются три мощных функции, которые включают гибкий язык конфигурации HAProxy и API времени выполнения. Data Plane API открывает двери для многостороннего использования, в частности, с использованием HAProxy в качестве уровня прокси в сетке сервиса.
Мы рады будущему использованию нового API для создания новых партнерских отношений и разнообразных функций. HAProxy продолжает обеспечивать высокую производительность и устойчивость в любой среде и в любом масштабе.
Если вам понравилась эта статья и вы хотите быть в курсе похожих тем, подпишитесь на этот блог. Вы также можете подписаться на нас в [Твиттере](https://twitter.com/haproxy) и присоединиться к разговору на [Slack](https://slack.haproxy.com/). HAProxy Enterprise позволяет легко приступить к работе с Data Plane API, поскольку его можно установить в виде удобного системного пакета. Он также включает в себя надежную и передовую кодовую базу, корпоративный набор дополнений, экспертную поддержку и профессиональные услуги. Хотите узнать больше? Свяжитесь с нами сегодня и скачайте бесплатную пробную версию.
P.S. Телеграм чат HAproxy <https://t.me/haproxy_ru> | https://habr.com/ru/post/509174/ | null | ru | null |
# Kodi перестал обновлять информацию о фильмах, потому что TMDB заблокировал доступ пользователям из России
[Kodi](https://kodi.tv/download/) - это мультимедийный центр со свободным кодом, который в том числе позволяет представить все локальные файлы с фильмами в виде своего собственного собственного домашнего кинотеатра с описанием и постерами. Kodi стал для меня аналогом ТВ-приставки любого оператора связи, только без ежемесячной оплаты и с возможностью работы без интернета.
[The Movie Database (TMDB)](https://www.themoviedb.org/) - это популярная редактируемая пользователями база данных фильмов и сериалов, которая содержит описания большинства фильмов и обложки на русском языке.
При помощи [своего парсера Kodi](https://kodi.wiki/view/Scrapers) может получать информацию из названия файла, а затем скачивать все описания с TMDB и оформлять как на скриншоте ниже.
Скриншот Kodi на телевизоре Блокировка доступа пользователям из России к TMDB произошла примерно в апреле 2022 года, но я разбираюсь с этим сейчас, потому что актуальным для меня стало только теперь, а конкретного решения проблемы коди не скачивает обложки, не работает скрепер я не нашёл.
TL;DRРешение: отредактируйте hosts, текстовый файл, в котором находятся данные доменов и их IP по адресу`\\192.168.XXX.XXX\Configfiles\hosts.conf`:
```
108.157.4.61 themoviedb.org
65.9.49.79 www.themoviedb.org
108.157.4.61 api.themoviedb.org
89.187.169.39 image.tmdb.org
```
### Получите доступ к Kodi по сети
Убедитесь, что оба компьютера находятся в одной локальной сети, а затем определите IP-адрес компьютера с Kodi. В моём случае это `\\192.168.165.7\`для Windows или `smb://192.168.165.7/` для Linux.
IP-адрес Kodi вы можете посмотреть на роутере или на вкладке Соединения.
Вкладка СоединенияНастройки SambaНа компьютере, с которого вы хотите получить доступ, откройте проводник или файловый менеджер и выберите пункт "Сеть". Выберите целевой компьютер с Kodi из списка устройств в сети и подключитесь к нему, используя его IP-адрес. Теперь вы можете просматривать и манипулировать файлами на целевом компьютере.
\\192.168.165.7\ под Windows### Найдите файл hosts.conf
`hosts.conf` - это файл конфигурации для системы управления доменными именами (DNS). Он содержит список ассоциаций между доменными именами и IP-адресами. В данном случае будем использовать его для переопределения доступа к TMDB на уровне системы.
Отредактируйте `hosts`, текстовый файл `\\192.168.XXX.XXX\Configfiles\hosts.conf`, внеся в него следующие записи:
```
108.157.4.61 themoviedb.org
65.9.49.79 www.themoviedb.org
108.157.4.61 api.themoviedb.org
89.187.169.39 image.tmdb.org
```
### Настройте штатный скрепер Kodi
Установите плагин скрепера. Вы можете найти плагины скрепера в официальном репозитории Kodi или в сторонних источниках.
Настройте плагин скрепера. Укажите, какие источники информации вы хотите использовать (IMDb, TMDb или другие). У IMDb проблема в том что не все описания на русском.
Выберите тип содержимого для вашей папки и настройте скрепер. в Universal Movie Scraper очень много настроек, поэтому можно выбрать какой-нибудь другой.
Выберите тип содержимогоШтатные скреперы или парсерыНастройка для сериалов Add-on:The TVDB v4Настройка для сериалов Add-on:The TVDB v4Настройка Add-on:Universal Movie ScraperAdd-on:Universal Movie ScraperAdd-on:Universal Movie ScraperAdd-on:Universal Movie Scraper### Протестируйте работу скрепера с обязательной перезагрузкой Kodi
Отсканируйте файлы в вашей библиотеке. Скрепер будет использовать информацию из выбранных источников, чтобы сопоставить фильмы с их метаданными.
Просмотрите информацию о фильмах в Kodi. Метаданные, такие как название, год выпуска, жанры, актеры, описание и постер, будут доступны в вашей библиотеке после обновления.
После перезагрузки Kodi скачает информацию с названием и актерами, но не обложки. Обложки с русскими названиями скачиваются только после ещё одной перезагрузки.
### Итоги
При помощи [своего парсера Kodi](https://kodi.wiki/view/Scrapers) может идентифицировать фильм по названию файла, а затем скачать описание, обложку, актёров и многое другое с TMDB.
Автор: [Михаил Шардин](https://shardin.name/),
30 января 2023 г. | https://habr.com/ru/post/712180/ | null | ru | null |
# Идеальный SAST. Парсер
Цикл статей посвящен описанию оптимального подхода для реализаций инструментов статического анализа кода, рассчитан на специалистов. Целью работы являются подходы, модели и методики для получения максимальной производительности инструмента при минимизации трудоемкости разработки и поддержки/изменения инструмента. В данной статье рассматривается способ ускорения работы парсера и снижения потребления памяти. Статья построена таким образом, что читатель прочел руководство написанное Терренсом Парром.
Использование ANTLR на полную
-----------------------------
ANTLR наиболее хорошо работает примерно в пределах 1 кб — 10 кб, файлы большего размера не будут анализироваться данной библиотекой с максимальным быстродействием. Так же отладка работы на больших файлах становится почти невозможной. Основной причиной, по которой необходимо держать объем входных данных для парсера в заданных пределах — алгоритмы прогнозирования ветвлений для ANTLR активно используют стек, соответственно любыми способами необходимо избавляться от циклов в грамматике, когда одно правило вызывает само себя через множество других правил в том числе с определенными условиями активации такой связи, рассмотрим на примере:
```
var f = fun a(b) { b = 10; return b; }
```
Данный код можно описать следующей грамматикой:
```
start: stmt* EOF;
stmt: varDecl | funDecl | expr ';' | 'return' expr ';';
varDecl: 'var' id '=' expr;
expr: id ('=' expr)? | number;
funDecl: 'fun' id '(' id* ')' '{' stmt* '}'
```
Легко заметить, что stmt вызывается внутри правила funDecl, что формирует цикл, который в реальных приложениях может привести к тому, что файл в 100 кб потребует хипа на 4 ГБ ОЗУ для максимальной производительности, а то и вовсе возможности работать, что является совершенно недопустимой ситуацией.
Одним из способов для преодоления такого недостатка является добавление специальных модификаций в процессе создания токенов, а именно — свертка блоков {} в токен, с обработкой этих токенов позднее в новом парсере, на вход которого будут переданы свернутые токены.
Для этого в ANTLR имеется возможность переопределить метод org.antlr.v4.runtime.Lexer#nextToken лексера, где можно реализовать функционал свертки:
```
override def nextToken(): Token = super.nextToken() match {
case x: RScanToken if x.getType == foldOpen => buildFoldToken(x)
case x: Token => x
}
def buildFoldToken(start: RScanToken): RScanToken = {
val (token, list) = createFoldBlockBody(
mutable.MutableList[RScanToken]()
++ List(start.asInstanceOf[RScanToken])
)
val result = new RScanToken(path, _tokenFactorySourcePair, foldBlock, Lexer.DEFAULT_TOKEN_CHANNEL, start.getStartIndex, token.getStopIndex)
result.setLine(start.getLine)
result.setCharPositionInLine(start.getCharPositionInLine)
result.setFoldedTokens(list)
result
}
private def createFoldBlockBody(list: mutable.MutableList[RScanToken]): (RScanToken, mutable.MutableList[RScanToken]) = {
var current: RScanToken = null
while (current == null || current.getType != Token.EOF && current.getType != foldClose) {
current = nextToken().asInstanceOf[RScanToken]
list += current
}
if (current.getType == Token.EOF)
throw new IllegalStateException()
(current, list)
}
```
Грамматика должна быть дополнена:
```
startJavaScript
: HashBangLine? jsFileBody? EOF
;
startFoldBlock
: block EOF
;
block
: LBRACE stmtList? RBRACE
| FoldBlock
// сохраняем информацию в специальный узел,
// что бы потом вызвать startFoldBlock
;
```
При таком подходе содержимое свертки не будет обрабатываться лишний раз, так как рекурсивный алгоритм будет поглощать токены и сохранять их.
Скорость обработки вырастает от 2 до 10 раз, особенно заметна разница становится на минифицированных js файлах.
Влияние на работу ANTLR предлагаемой оптимизации на примере нескольких javascript файлов:
| Файл | Размер, кб | До оптимизации, мс | После оптимизации, мс |
| --- | --- | --- | --- |
| normalize-and-load-metadata.js | 10 | 1839 | 1372 |
| rewrite-live-references.js | 8 | 899 | 528 |
| dom.umd.min.js | 130 | 43852 | 6607 |
| react.pure.umd.min.js | 139 | 51668 | 6495 |
| tsserver.js | 8151 | 362857 | 117787 |
Без оптимизации работа осуществляется в один поток, с оптимизацией, если возможно, то обработка параллелится.
Запуск осуществлялся на машине с 64 гб ОЗУ, Intel® Core(TM) i7-9700K CPU @ 3.60GHz, OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.4+11).
Ключи запуска JVM: -Xmx4G -XX:+UseG1GC -XX:MaxHeapFreeRatio=30 -XX:MinHeapFreeRatio=10
Для файла tsserver.js ключ -Xmx32G, при этом потребление памяти достигло 22 гб! В то время как минифицированные файлы до 200 кб с оптимизацией анализируются с лимитом хипа в 128 мб в параллельном режиме без необходимости сборщику мусора оказывать нагрузку на процессор, максимум 2%!
### Профилирование
ANTLR поддерживает профилирование работы парсера/лексера в рантайме, что бы включить, нужно вызвать метод: org.antlr.v4.runtime.Parser#setProfile до выполнения каких-либо правил. Далее можно получить всю информацию, например таким способом:
```
private def printProfileInfo(parser: AbstractRScanParser, tokenStream: TokenStream): Unit = {
// do the actual parsing
val parseInfo = parser.getParseInfo
val atn = parser.getATN
for (di <- parseInfo.getDecisionInfo if di.ambiguities.size() > 0) {
val ds = atn.decisionToState.get(di.decision)
val ruleName = parser.ruleName(ds.ruleIndex)
log.debug("Ambiguity in rule '" + ruleName + "' -> {}", di)
log.debug("=========================")
log.debug(tokenStream.getText)
log.debug("=========================")
}
}
```
Очевидным плюсом при таком способе является уменьшение объема данных, которые вам необходимо анализировать, так как свертки можно заменить на {} и работать всегда в локальной свертке, что значительно ускоряет процесс оптимизации грамматики.
Заключение
----------
В данной статье предложен метод оптимизации работы формальных грамматик, реализованных с помощью библиотеки ANTLR, хотя сам подход можно попытаться применить и к другим библиотекам. Особенностью оптимизации является уменьшение количества переходов вперед для валидации входного потока токенов. Так же она позволяет анализировать большие файлы (более 1 мб) при затратах памяти в 512 мб при однопоточной обработке, в то время как отсутствие оптимизации будет требовать в 50 раз больше памяти для быстрой работы с использованием той же самой грамматики.
Исходный код доступен на [гитхабе](https://github.com/lastrix/rscan-js-public). Данный проект сделан для демонстрации работы оптимизации. Проект упрощен максимально, начать изучение рекомендуется в класса GrammarTester, для него сделана конфигурация запуска, вам останется прописать только путь к папке с входными данными. Обратите внимание на ключ rscan.tester.cache.dir, в эту папку будут писаться временные файлы, успешный анализ файла закрепляется в этой папке и не позволит парсеру анализировать его второй раз — удобно для исправления ошибок. В данный момент грамматика протестирована на 17 тыс файлах из node\_modules, создаваемого для базового приложения react. Игнорировались только вложенные node\_modules.
В следующей статье будут рассмотрены варианты организации данных и модель R (Отражение) для оптимального представления исходных данных в виде объектов анализа с минимальным потреблением памяти, возможностью реализовать алгоритмы поиска элементов со сложностью О(1), при этом иметь возможность сохранять на диск в сериализованном виде все объекты, а так же юнит-тестировать части инструмента. | https://habr.com/ru/post/487716/ | null | ru | null |
# Компиляция. 7: назначение регистров
> File names are infinite in length, where infinity is set to 255 characters.
>
> *--Peter Collinson: The Unix File System*
Итак, у нас есть программа на п-коде, и в её распоряжении неограниченное количество регистров (т.е. 255). Число регистров у реального процессора куда меньше (предположим, четыре). Что будем делать?
### Далее в посте:
1. Разбор п-кода
2. Время жизни
3. Реализация
4. Простые оптимизации
5. Расщепление версий
6. Работа с памятью
7. Что получилось?
### Разбор п-кода
В прошлом посте был дамп скомпилированной программы. Её 40 команд несложно расшифровать:
```
00 mov r01, 0
01 mov r02, 0x3e8
02 echo 0x126
03 echo r01
04 echo 0xa0
05 echo r02
06 echo 0xa7
07 le r03, r01, r02
08 jz r03, +0x1d (=0x26)
09 add r04, r01, r02
0a mov r05, 2
0b div r06, r04, r05
0c echo 0x162
0d echo r06
0e echo 0xcc
0f input r07
10 mov r08, 1
11 eq r09, r07, r08
12 jz r09, +4 (=0x17)
13 mov r0a, 1
14 sub r0b, r06, r0a
15 add r02, r0b, 0
16 jz 0, +e (=0x25)
17 mov r0c, 2
18 eq r0d, r07, r0c
19 jz r0d, +4 (=0x1e)
1a mov r0e, 1
1b add r0f, r06, r0e
1c add r01, r0f, 0
1d jz 0, +7 (=0x25)
1e mov r10, 3
1f eq r11, r07, r10
20 jz r11, +3 (=0x24)
21 echo 0x146
22 hlt
23 jz 0, +1 (=0x25)
24 echo 0x16a
25 jz 0, -0x1f (=7)
26 echo 0xff
27 hlt
```
Видно, что не все регистры используются одновременно: большинство хранят промежуточные значения, которые нужны только для следующей команды. Например, `r03` используется только в командах `07-08`, а `r0f` только в командах `1b-1c`. Значит, нет никаких препятствий задействовать для хранимых значений один и тот же физический регистр: в командах `07-08` он будет использоваться для одного значения, а в `1b-1c` — для другого. Любые два регистра, которые не используются *одновременно для разных значений*, можно объединить в один физический регистр.
Есть небольшая тонкость по поводу определения «используются одновременно для разных значений». Во-первых, нельзя считать временем жизни регистра просто промежуток от его первого упоминания до последнего: код может содержать прыжки во все стороны, например:
```
...
10 mov r, 42
11 jz 0, 20
12 echo r
...
20 ...
...
30 jz 0, 12
...
```
Даже хотя `r` упоминается только в командах 10-12, он неявно используется и в команде 20, потому что после неё возможен прыжок обратно на 12; и значит, `r` нельзя объединять с другими регистрами, используемыми в команде 20.
Вторая тонкость:
```
...
10 mov r, 42
11 echo r
...
20 ...
...
30 mov r, 24
31 echo r
...
```
В команде 20 регистр `r` на самом деле не используется, хотя упоминается и перед этим (10-11), и после этого (30-31). Можем хранить в нём любые другие значения, потому что перед следующим использованием (31) значение ему будет присвоено по-новой. В принципе, мы даже можем назначить разные физические регистры для `r` в 10-11 и в 31-31, потому что значения всё равно будут храниться разные. Но для этого нужно обнаружить, что у `r` две независимые «версии», и обрабатывать их по-отдельности.
### Время жизни
Определить набор команд, в которых регистр используется, можно итеративно:
* регистр нужен команде, которая *читает* его значение;
* если из команды A можно перейти на B (непосредственно или прыжком), и регистр нужен B, то он нужен и А;
* регистр не нужен команде, которая *задаёт* его значение.
Для каждой команды определяем набор регистров, которые нужны ей «на входе» и «на выходе», и применяем три правила до тех пор, пока эти наборы не установятся. Вот что получим для нашей программы:
```
номер итерации: 1(вход/вых) 2(вход/выход) 3(вход/выход) 4(вход/выход) ... итог(вход/выход)
00 mov r01, 0 /r01
01 mov r02, 0x3e8 /r01 r01/r01,r02
02 echo 0x126 /r01 r01/r01 r01/r01 r01,r02/r01,r02
03 echo r01 r01/ r01/ r01/ r01/r02 r01,r02/r01,r02
04 echo 0xa0 /r02 r02/r02 r02/r02 r01,r02/r01,r02
05 echo r02 r02/ r02/ r02/ r02/r01,r02 r01,r02/r01,r02
06 echo 0xa7 /r01,r02 r01,r02/r01,r02 r01,r02/r01,r02 r01,r02/r01,r02
07 le r03, r01, r02 r01,r02/ r01,r02/r03 r01,r02/r03 r01,r02/r01,r02,r03 r01,r02/r01,r02,r03
08 jz r03, +0x1d (=0x26) r03/ r03/r01,r02 r01,r02,r03/r01,r02 r01,r02,r03/r01,r02 r01,r02,r03/r01,r02
09 add r04, r01, r02 r01,r02/ r01,r02/ r01,r02/ r01,r02/r04 r01,r02/r01,r02,r04
0a mov r05, 2 /r04,r05 r04/r04,r05 r04/r04,r05 r01,r02,r04/r01,r02,r04,r05
0b div r06, r04, r05 r04,r05/ r04,r05/ r04,r05/ r04,r05/r06 r01,r02,r04,r05/r01,r02,r06
0c echo 0x162 /r06 r06/r06 r06/r06 r01,r02,r06/r01,r02,r06
0d echo r06 r06/ r06/ r06/ r06/ r01,r02,r06/r01,r02,r06
0e echo 0xcc r01,r02,r06/r01,r02,r06
0f input r07 /r07 r01,r02,r06/r01,r02,r06,r07
10 mov r08, 1 /r07,r08 r07/r07,r08 r07/r07,r08 r01,r02,r06,r07/r01,r02,r06,r07,r08
11 eq r09, r07, r08 r07,r08/ r07,r08/r09 r07,r08/r09 r07,r08/r09 r01,r02,r06,r07,r08/r01,r02,r06,r07,r09
12 jz r09, +4 (=0x17) r09/ r09/ r09/ r09/r06,r07 r01,r02,r06,r07,r09/r01,r02,r06,r07
13 mov r0a, 1 /r06,r0a r06/r06,r0a r06/r06,r0a r01,r06/r01,r06,r0a
14 sub r0b, r06, r0a r06,r0a/ r06,r0a/r0b r06,r0a/r0b r06,r0a/r0b r01,r06,r0a/r01,r0b
15 add r02, r0b, 0 r0b/ r0b/ r0b/ r0b/ r01,r0b/r01,r02
16 jz 0, +e (=0x25) r01,r02/r01,r02
17 mov r0c, 2 /r07,r0c r07/r07,r0c r07/r07,r0c r01,r02,r06,r07/r01,r02,r06,r07,r0c
18 eq r0d, r07, r0c r07,r0c/ r07,r0c/r0d r07,r0c/r0d r07,r0c/r0d r01,r02,r06,r07,r0c/r01,r02,r06,r07,r0d
19 jz r0d, +4 (=0x1e) r0d/ r0d/ r0d/ r0d/r06,r07 r01,r02,r06,r07,r0d/r01,r02,r06,r07
1a mov r0e, 1 /r06,r0e r06/r06,r0e r06/r06,r0e r02,r06/r02,r06,r0e
1b add r0f, r06, r0e r06,r0e/ r06,r0e/r0f r06,r0e/r0f r06,r0e/r0f r02,r06,r0e/r02,r0f
1c add r01, r0f, 0 r0f/ r0f/ r0f/ r0f/ r02,r0f/r01,r02
1d jz 0, +7 (=0x25) /r01,r02 r01,r02/r01,r02
1e mov r10, 3 /r07,r10 r07/r07,r10 r07/r07,r10 r01,r02,r07/r01,r02,r07,r10
1f eq r11, r07, r10 r07,r10/ r07,r10/r11 r07,r10/r11 r07,r10/r11 r01,r02,r07,r10/r01,r02,r11
20 jz r11, +3 (=0x24) r11/ r11/ r11/ r11/ r01,r02,r11/r01,r02
21 echo 0x146
22 hlt
23 jz 0, +1 (=0x25) /r01,r02 r01,r02/r01,r02
24 echo 0x16a /r01,r02 r01,r02/r01,r02
25 jz 0, -0x1f (=7) /r01,r02 r01,r02/r01,r02 r01,r02/r01,r02 r01,r02/r01,r02
26 echo 0xff
27 hlt
```
По поводу отдельных итераций:1. На входе каждой команды — используемые ей регистры; (правило №1)
2. На выход каждой команды копируем вход достижимых из неё команд; (правило №2)
3. На вход каждой команды копируем её выход, исключая записанный командой регистр; (правило №3)
4. На выход каждой команды копируем вход достижимых из неё команд; (правило №2)
Далее правила №2 и №3 повторяются поочерёдно.
После нескольких итераций получаем окончательную разметку «живучести регистров» — какие регистры нужны каждой команде. Тогда можем переименовывать регистры п-кода в физические — например, «по-жадному»: берём «самый нужный» регистр (нужный наибольшему количеством команд); переименовываем в физический, который ещё не занят в соответствующих командах; повторяем.
Оптимальный выбор, каким п-регистрам следует предоставить физические, чтобы хватило на как можно больше, — возможен только полным перебором: эта задача равносильна «раскраске графа в минимум цветов», про которую математики верят, что для неё не существует эффективного решения. Наше «жадное» приближение — не самое худшее из возможных.
Что делать, если для очередного п-регистра не окажется свободного физического? Например, в нашем коде есть команды (10-12, 17-19), использующие по 5 п-регистров: как минимум одному из них места не хватит. Понятно, что придётся хранить его в памяти.
Но просто сказать регистру «тебе не повезло, ты будешь храниться в памяти» мало: ведь команды нашего п-кода не умеют работать со значениями из памяти, равно как и команды большинства реальных процессоров. Необходимо на время использования доставать значение из памяти в регистр. Только в какой? Ведь потому и убрали значение в память, что все регистры заняты!
На этом месте выученная мной теория заканчивается, и идут догадки и эвристики. Я решил перед командой, на которую не хватает регистров, «выливать в память» лишние регистры, а после — читать их из памяти обратно. Тем самым, во «времени жизни» вылитых регистров появится дырка на месте этой команды, и в этой дырке сможем использовать освободившиеся регистры для других целей.
Чтобы можно было «раздвигать» код и вставлять в него команды чтения/записи в память, придётся чуточку поменять промежуточный формат: теперь это будет связанный список, и цель прыжка будет храниться не как смещение, а как указатель (превращая список в орграф). Во время генерации п-кода, для [бэкпатчинга](http://habrahabr.ru/blogs/programming/99592/) нам понадобится обращаться к командам и по индексу; для этого заведём отдельный вектор смещений.
`typedef std::list<struct commandn>::iterator pcommandn;
struct commandn {
command cmd;
pcommandn tgt; // цель прыжка
commandn(const command& cmd) : cmd(cmd), tgt(NULL) {}
};
std::list pcode;
std::vector pcodeidx;
inline int emit(const command& cmd) {
pcodeidx.push\_back(pcode.insert(pcode.end(), commandn(cmd)));
return pcode.size()-1;
}
inline int emit(command::opcodes opcode, regnum dest, regnum src1, regnum src2) {
return emit(command(opcode, dest, src1, src2));
}
inline int emit(command::opcodes opcode, regnum dest, short imm) {
return emit(command(opcode, dest, imm));
}
inline void fix(int index, command::opcodes opcode, regnum dest, short imm) {
\*pcodeidx[index] = commandn(command(opcode, dest, imm));
}`
Указатели на цель прыжка сложно заполнять во время генерации п-кода: в момент создания прыжков уже известен индекс цели, но ещё неизвестно, какая там будет стоять команда; ставить указатель на ещё не созданную команду проблематично. Поэтому после конца разбора и генерации п-кода обойдём сгенерированный код, и расставим указатели прыжков; потом выполним всю нужную работу с распределением регистров; и в конце, перед дампом p-кода в файл, нужно будет его «сериализовать» — определить окончательный индекс каждой команды, и заполнить смещения прыжков. Ради этого, добавим в `struct commandn` поле `int index;`
`int main() {
yyparse();
// расставить цели прыжков
for(int i=0; i
if(pcodeidx[i]->cmd.opcode==command::jz)
pcodeidx[i]->tgt = pcodeidx[i+1+pcodeidx[i]->cmd.imm];
// обработка / оптимизация
// ...
// сериализация / расстановка смещений
int index = 0;
foreach(i, pcode) i->index = index++;
foreach(i, pcode)
if (i->cmd.opcode==command::jz)
i->cmd.imm = i->tgt->index-i->index-1;
// запись п-кода в файл
// ...
}`
Дело за малым: реализовать «обработку / оптимизацию». Займёт она, как и можно ожидать, большую часть всего кода компилятора.
### Реализация
Для назначения регистров будем хранить для каждой команды (прямо в `struct commandn`) множества живых на входе и на выходе регистров: отдельно — регистров п-кода, для определения времени жизни; и отдельно — физических регистров, для определения сочетаемости при собственно назначении.
`typedef std::set aliveset;
enum physreg { firstp = 1, lastp = 4 };
typedef std::set alivesetp;
struct commandn {
// ...
aliveset onenter, onexit; // liveness check
alivesetp onenterp, onexitp; // phys reg allocation
// ...
};`
Ещё одна полезная вещь — определение по опкоду, какие регистры используются командой:
`inline bool hasnext(pcommandn cmd) {
return (cmd->cmd.opcode!=command::hlt &&!
(cmd->cmd.opcode==command::jz && !cmd->cmd.dest));
}
inline bool has2src(pcommandn cmd) {
return cmd->cmd.opcode>=command::add;
}
inline bool writesdest(pcommandn cmd) {
return cmd->cmd.opcode>=command::mov;
}
inline bool readsdest(pcommandn cmd) {
return cmd->cmd.opcode>=command::store &&
cmd->cmd.opcode<=command::echo;
}`
После этого, по приведённой выше схеме, рассчитываем для каждой команды множество нужных на входе и на выходе регистров; заодно считаем, сколько раз нужен каждый регистр, для жадного назначения.
`std::vector<int> liveness() { // returns usecount
std::vector<int> usecount(lastreg+1);
bool changed = false;
// rule 1
foreach(i, pcode) {
i->onenter = i->onexit = aliveset();
if (has2src(i)) {
if (i->cmd.src1) {
usecount[i->cmd.src1]++;
i->onenter.insert(i->cmd.src1);
}
if (i->cmd.src2) {
usecount[i->cmd.src2]++;
i->onenter.insert(i->cmd.src2);
}
} else if (readsdest(i) && i->cmd.dest) {
usecount[i->cmd.dest]++;
i->onenter.insert(i->cmd.dest);
}
if (i->onenter.size())
changed = true;
}
while (changed) {
changed = false;
foreach2(i, pcode, next) {
int oldsize = i->onenter.size()+i->onexit.size();
// rule 2 (next command)
if (hasnext(i))
i->onexit.insert(next->onenter.begin(), next->onenter.end());
// rule 2 (jmp target)
if (i->cmd.opcode==command::jz)
i->onexit.insert(i->tgt->onenter.begin(), i->tgt->onenter.end());
// rule 3
i->onenter.insert(i->onexit.begin(), i->onexit.end());
if (writesdest(i))
i->onenter.erase(i->cmd.dest);
if (i->onenter.size()+i->onexit.size() != oldsize)
changed = true;
}
}
return usecount;
}`
Использованный макрос `foreach2` позволяет в теле цикла смотреть и на текущий, и на следующий за ним элемент:
`#define foreach2(i, list, next) typedef typeof(list) TOKENPASTE2(T,\_\_LINE\_\_); \
for(TOKENPASTE2(T,\_\_LINE\_\_)::iterator next = list.begin(), i=next++; i != list.end(); i=next, next++)`
В принципе, можно было сократить общее число итераций, если обходить команды не «сверху вниз», а «снизу вверх», потому что нужность «распространяется» от каждой команды к предыдущим; обход «сверху вниз» выбран ради упрощения кода. В самом худшем случае, для кода длиной *N* команд потребуется 2*N* итераций (на каждой итерации нужность распространяется на расстояние полкоманды). Для `test.jsk` хватило 35 итераций, потому что прыжки сокращают расстояния.
Наконец, то, зачем мы всё это делали:
`// обработка / оптимизация:
while(1) { // пока все регистры не уложатся в физические
// предварительная обработка
// ...
std::vector<int> usecount = liveness();
std::vector physmap(lastreg+1);
foreach(i, pcode)
i->onenterp = i->onexitp = alivesetp();
while(1) {
// самый нужный регистр
std::vector<int>::iterator max = std::max\_element(usecount.begin(), usecount.end());
if (!\*max) break; // все регистры размещены
\*max = 0;
regnum r = max - usecount.begin();
// поищем физ. регистр для п-регистра №r
std::vector<int> collisions(lastp); // 0-based
for (physreg p=firstp; p<=lastp; p=(physreg)(p+1)) { // error: ISO C++ forbids incrementing an enum
foreach(i, pcode) {
if (contains(i->onenter, r) && contains(i->onenterp, p))
collisions[p-1]++;
if (contains(i->onexit, r) && contains(i->onexitp, p))
collisions[p-1]++;
}
if (collisions[p-1]) continue; // попробовать другой физ. рег
physmap[r] = p;
// разместили п-регистр №r в физическом №p
foreach(i, pcode) {
if (contains(i->onenter, r))
i->onenterp.insert(p);
if (contains(i->onexit, r))
i->onexitp.insert(p);
}
break; // успешное назначение
}
if (physmap[r]) continue; // нашлось куда разместить
// не хватило физ. регистра для п-регистра №r
// эвристика: найдём команду, в которой не хватает регистров
foreach2(i, pcode, next)
if ((i->cmd.opcode!=command::load && i->cmd.opcode!=command::store) &&
((contains(i->onenter, r) && i->onenterp.size()==lastp) ||
(contains(i->onexit, r) && i->onexitp.size()==lastp))) {
// найдём, какой регистр можно вылить, и выльем
// ...
goto afterspill;
}
// эвристика не сработала: что же делать?
yyerror("don't know how to proceed");
}
// все регистры размещены; переименовываем
foreach(i, pcode) {
i->cmd.dest = physmap[i->cmd.dest];
if (has2src(i)) {
i->cmd.src1 = physmap[i->cmd.src1];
i->cmd.src2 = physmap[i->cmd.src2];
}
}
break;
afterspill: // пост-обработка после "выливания регистра"
}`
Ещё не углубляясь в то, как именно мы выливаем регистр, стоит упомянуть, что у приведённого кода масса проблем. Во-первых, эвристика работает только в самых простых случаях; чаще встречаются ситуации навроде
```
...
10 нужны r1,r2,r3,r4
...
20 нужны r1,r3,r4,r5
...
30 нужны r2,r3,r4,r5
...
```
Регистру `r5` не хватает физического, потому что все физические израсходовались на `r1,r2,r3,r4`; но нет ни одной команды, где все пять регистров нужны одновременно.
Более жёсткая проблема — что каждый вылив засоряет программу бесполезными парами `store/load`, и их нужно вычищать — иначе используемые в них регистры создают достаточно «шума», чтоб регистров не хватило больше ни на что.
Ещё одна идея: дырка во времени жизни, образовавшаяся из-за вылива, может разделить исходный п-регистр на две независимых «версии», которые можно размещать в разных физических регистрах. Ради гибкости нашей системы, стоит реализовать расщепление версий: тогда с каждой итерацией внешнего цикла времена жизни регистров будут сокращаться, и распределять им физические будет становиться всё проще и проще.
И, раз уж мы пошли удалять лишние `load` и `store`, удалим заодно и прочие лишние команды. Учитывая, что у операций нашего п-кода нет других побочных эффектов, кроме вычисления регистра с результатом, — можно удалять команды, результат которых не жив на выходе. Может быть, программист присвоил значение неиспользуемой переменной, или употребил оператор наподобие `(2+2);`
Удаляем всё подряд — так удалим до кучи недостижимый код (например, jz после hlt), и сожмём цепочки прыжков (заменим прыжок на прыжок одним прыжком).
Для удаления команды, чтобы не искать и не исправлять все прыжки на неё, удобно заменить её на `nop`; в качестве него назначим безусловный прыжок на следующую команду (`jz r00, +0`). Выгода в том, что на следующей итерации прыжок на `nop` сожмётся по цепочке, и сам `nop` вычистится как недостижимая команда.
### Простые оптимизации
Для обнаружения недостижимых команд пользуемся обходом в глубину; чтобы следить, какие команды уже обошли, в `struct commandn` добавляем новое поле `int reachcnt;`
Нам хватило бы и булева поля; но «степень захода» каждой команды, может статься, ещё пригодится когда-нибудь потом.
`void markReachable(pcommandn cmd) {
while(!cmd->reachcnt++) {
if (cmd->cmd.opcode==command::jz)
markReachable(cmd->tgt);
if (hasnext(cmd))
cmd++;
else
break;
}
}
void nopOut(pcommandn cmd) {
pcommandn next = cmd; next++;
cmd->cmd = command(command::jz, 0,0);
cmd->tgt = next;
}
void simpleopt() {
// сжать цепочки прыжков
foreach(i, pcode)
if(i->cmd.opcode==command::jz)
while(i->tgt->cmd.opcode==command::jz && !i->tgt->cmd.dest)
i->tgt = i->tgt->tgt;
// удалить недостижимый код
foreach(i, pcode) i->reachcnt = 0;
markReachable(pcode.begin());
foreach2(i, pcode, next)
if(!i->reachcnt)
pcode.erase(i);
// удалить все nop: уже не могут быть целью прыжка
foreach2(i, pcode, next)
if(i->cmd.opcode==command::jz &&
!i->cmd.dest && i->tgt==next)
pcode.erase(i);
}
// предварительная обработка в цикле назначения регистров:
simpleopt();
// удалить команды с неживым результатом
liveness();
bool changed = false;
foreach(i, pcode)
if(writesdest(i) && !contains(i->onexit, i->cmd.dest)) {
nopOut(i);
changed = true;
}
if (changed) continue;
// расщепление версий
// ...`
### Расщепление версий
Если в «интервале нужности» регистра есть разрыв, т.е. значение из одного набора команд никогда не проникает в другой набор, — значит, регистр можно «расщепить» на пару регистров с более короткими временами жизни.
Для выделения безразрывных фрагментов из времён жизни пригодится ещё один графовый алгоритм: поиск компонент связности.
Стремимся больше к ясности кода, чем к его эффективности; поэтому у нас пвг внутри пвг, и слияние компонент выполняется обходом всего графа.
В `struct commandn` потребуется ещё одно поле, последнее на сегодня: `std::map version;`
В нём будем хранить для каждой команды соответствия «п-регистр -> номер версии».
Если регистр в команде используется, а соответствия в `version` ещё нет — значит, обход до этой команды ещё не дошёл.
Для внешнего же пвг, чтобы не заводить новое поле, пользуемся тем же `reachcnt`, что и в `markReachable()`
`std::map renameto; // для слияния компонент
void versionizeReg(pcommandn cmd, regnum r, regnum rv) { // переименовать r в rv во всей компоненте
while(!contains(cmd->version, r) &&
(contains(cmd->onenter, r) || contains(cmd->onexit, r))) {
// переименование
cmd->version[r] = renameto[rv];
if (cmd->cmd.dest==r) cmd->cmd.dest=renameto[rv];
if (has2src(cmd)) {
if (cmd->cmd.src1==r) cmd->cmd.src1=renameto[rv];
if (cmd->cmd.src2==r) cmd->cmd.src2=renameto[rv];
}
if (!contains(cmd->onexit,r)) return; // больше не живой
if (cmd->cmd.opcode==command::jz &&
contains(cmd->tgt->onenter, r)) {
versionizeReg(cmd->tgt, r, rv);
}
if (hasnext(cmd)) {
cmd++;
if (contains(cmd->onenter, r))
continue;
}
return; // зашли в тупик
}
// натолкнулись на другую версию?
if(contains(cmd->version, r) && cmd->version[r]!=renameto[rv]) {
// слить renameto[rv] и cmd->version[r]
regnum from = std::max(cmd->version[r], renameto[rv]),
to = std::min(cmd->version[r], renameto[rv]);
renameto[from] = to;
foreach(i, pcode) {
if (i->cmd.dest==from) i->cmd.dest = to;
if (has2src(i)) {
if (i->cmd.src1==from) i->cmd.src1 = to;
if (i->cmd.src2==from) i->cmd.src2 = to;
}
if(contains(i->version, r) && i->version[r]==from)
i->version[r] = to;
}
}
}
void versionize(pcommandn cmd) {
while(!cmd->reachcnt++) {
// versionize registers that live on exit
foreach(r, cmd->onexit)
if(!contains(cmd->version, \*r)) {
regnum rv = newreg();
renameto[rv] = rv;
versionizeReg(cmd, \*r, rv);
}
if (cmd->cmd.opcode==command::jz)
versionize(cmd->tgt);
if (hasnext(cmd))
cmd++;
else
break;
}
}
// расщепление версий:
foreach(i, pcode) {
i->version.clear();
i->reachcnt = 0;
}
renameto.clear();
int lastbasereg = lastreg;
versionize(pcode.begin());
// переименовать версии, чтоб начинались с 1
foreach(i, pcode) {
if (i->cmd.dest) i->cmd.dest-=lastbasereg;
if (has2src(i)) {
if (i->cmd.src1) i->cmd.src1-=lastbasereg;
if (i->cmd.src2) i->cmd.src2-=lastbasereg;
}
}
lastreg -= lastbasereg;`
Осталось реализовать собственно вылив регистра. Конкретизируем эвристику: вылить можно любой регистр, который жив, но командой не используется.
`regnum spillable(pcommandn cmd) { // найти регистр, который можно вылить
aliveset alive;
alive.insert(cmd->onenter.begin(), cmd->onenter.end());
alive.insert(cmd->onexit.begin(), cmd->onexit.end());
alive.erase(cmd->cmd.dest);
if (has2src(cmd)) {
alive.erase(cmd->cmd.src1);
alive.erase(cmd->cmd.src2);
}
if (!alive.size()) return 0;
return *alive.begin();
}`
В отдельном `map` будем хранить по номеру регистра «адрес» его копии в памяти, чтобы все выливы регистра попадали в одно и то же место. Адрес присваивается регистру лишь в момент первого вылива.
`// spill slots
std::mapint> spill;
int lastspill = 0;
void spillAt(pcommandn cmd, regnum victim, pcommandn next) {
// найти / выделить слот
int spslot = spill[victim];
if(!spslot) {
spslot = ++lastspill;
spill[victim] = spslot;
}
// вставить store перед и load после
pcommandn me = pcode.insert(next, \*cmd);
cmd->cmd = command(command::store, victim, spslot);
commandn load(command(command::load, victim, spslot));
if(hasnext(me))
pcode.insert(next, load);
if(me->cmd.opcode==command::jz)
me->tgt = pcode.insert(me->tgt, load);
}`
Поскольку команда заменяется тройкой `store-cmd-load`, нужно, чтобы существующие прыжки на команду прыгали на вставленный перед ней `store`. Чтобы не искать такие прыжки по всему коду, мы вставляем *следующей* командой копию `cmd`, а потом *оригинал* команды заменяем на `store`.
Аналогично, если команда — условный переход, то нужно, чтобы `load` выполнился при обоих исходах; поэтому и добавим его следующей командой, и вставим перед целью прыжка.
(Немного досадно, что из-за возможности переезда команд из одного `commandn` в другой нам придётся связывать строки для `echo` с самими командами по «идентификатору», как и в первой древесной реализации: ни индексы команд, ни указатели не остаются неизменными.)
Вторая эвристика: если не удалось найти команду, в которой заняты все физические регистры, то возьмём тот физический регистр, который «лучше всего подходит» (меньше всего коллизий с уже назначенными регистрами), и попытаемся освободить его всюду, где он нужен, но занят.
`// не хватило физ. регистра для п-регистра №r
regnum victim;
// эвристика 1: найдём команду, в которой не хватает регистров
foreach2(i, pcode, next)
if ((i->cmd.opcode!=command::load && i->cmd.opcode!=command::store) &&
((contains(i->onenter, r) && i->onenterp.size()==lastp) ||
(contains(i->onexit, r) && i->onexitp.size()==lastp))) {
victim = spillable(i);
assert(victim);
spillAt(i, victim, next);
goto afterspill;
}
// эвристика 2: найдём "самый подходящий" регистр
physreg bestfit = (physreg)(std::max_element(collisions.begin(), collisions.end())-collisions.begin()+1);
foreach2(i, pcode, next)
if ((i->cmd.opcode!=command::load && i->cmd.opcode!=command::store) &&
((contains(i->onenter, r) && contains(i->onenterp, bestfit)) ||
(contains(i->onexit, r) && contains(i->onexitp, bestfit))) &&
(victim = spillable(i))) {
spillAt(i, victim, next);
goto afterspill;
}
yyerror("don't know how to proceed");`
При расщеплении версий нужно не забыть скопировать номер слота (все версии одного регистра хранятся в одном слоте), а потом, при переименовании версий, — не забыть обновить `spill`.
Компилятор уже почти работает; последняя проблема — что генерируется куча бесполезных `load` и `store`, и из-за них не остаётся регистров на осмысленные команды.
### Работа с памятью
Во-первых, может оказаться, что некоторые регистры используются исключительно в командах `load/store`
Такие команды бесполезны: регистр записывается всегда в тот же слот, из которого был прочитан.
Вставим чистку после расщепления версий: там у нас как раз должно получиться много регистров с коротким временем жизни.
`// вычистить бессмысленные регистры
std::vector<bool> used(lastreg+1);
foreach(i, pcode) {
if (writesdest(i) && i->cmd.opcode!=command::load)
used[i->cmd.dest] = true;
if (readsdest(i) && i->cmd.opcode!=command::store)
used[i->cmd.dest] = true;
if (has2src(i)) {
used[i->cmd.src1] = true;
used[i->cmd.src2] = true;
}
}
foreach(i, pcode)
if ((i->cmd.opcode==command::load && !used[i->cmd.dest]) ||
(i->cmd.opcode==command::store && !used[i->cmd.dest]))
nopOut(i);`
Во-вторых, если у нас есть цепочки одинаковых `load`, то все, кроме последней, удалятся за то, что прочитанный регистр не жив. А вот если у нас цепочки одинаковых `store`, то для их удаления нужно придумать нечто новое. Алгоритм очень похож на итеративное определение нужности регистров, только теперь определяем «несохранённость» — чтобы вычистить все сохранения уже сохранённых регистров.* регистр не сохранён в команде, которая *задаёт* его значение;
* если из команды A можно перейти на B (непосредственно или прыжком), и регистр не сохранён в A, то он не сохранён и в B;
* регистр сохранён в команде, которая *сохраняет* его значение.
Видим, что от предыдущего этот алгоритм отличается только направлением распространения: нужность распространяется от каждой команды к предыдущим, а несохранённость — к последующим.
В общем виде итеративный алгоритм вычисления множеств регистров в каждой точке программы называется *data flow analysis*, и применяется, кроме двух названных, и для многих других оптимизаций.
`void unsaved() {
bool changed = false;
// rule 1
foreach(i, pcode) {
i->onenter = i->onexit = aliveset();
if (writesdest(i)) {
i->onexit.insert(i->cmd.dest);
changed = true;
}
}
while (changed) {
changed = false;
foreach2(i, pcode, next) {
int oldsize = i->onenter.size()+i->onexit.size();
// rule 2 (next command)
if (hasnext(i))
next->onenter.insert(i->onexit.begin(), i->onexit.end());
// rule 2 (jmp target)
if (i->cmd.opcode==command::jz)
i->tgt->onenter.insert(i->onexit.begin(), i->onexit.end());
// rule 3
i->onexit.insert(i->onenter.begin(), i->onenter.end());
if (i->cmd.opcode==command::store)
i->onexit.erase(i->cmd.dest);
if (i->onenter.size()+i->onexit.size() != oldsize)
changed = true;
}
}
}
afterspill: // пост-обработка после "выливания регистра"
unsaved();
foreach(i, pcode)
if (i->cmd.opcode==command::store && !contains(i->onenter, i->cmd.dest))
nopOut(i);
}`
### Что получилось?
Весь компилятор вместе: [tyomitch.net.ru/jsk.y.regs.html](http://tyomitch.net.ru/jsk.y.regs.html)
Из полутысячи строк, к парсингу относится лишь пятая часть. Действительно кажется, что по сравнению с трудозатратами на остальную часть компилятора, парсер — неинтересная мелочь сбоку. Но это лишь потому, что создание парсеров обсосано до косточек, и нам остаётся лишь воспользоваться готовым; тогда как при обработке кода больше места выдумке.
В итоге назначения регистров и первых оптимизаций, генерируемый код удлинился всего на пару команд:
```
00 mov r01, 0
01 mov r02, 0x3e8
02 echo 0x12e
03 echo r01
04 echo 0xa8
05 echo r02
06 echo 0xaf
07 le r03, r01, r02
08 jz r03, +0x1f (=0x28)
09 add r03, r01, r02
0a mov r04, 2
0b div r03, r03, r04
0c echo 0x16a
0d echo r03
0e echo 0xd4
0f input r04
10 store r01, 1
11 mov r01, 1
12 eq r01, r04, r01
13 jz r01, +5 (=0x19)
14 load r01, 1
15 mov r02, 1
16 sub r02, r03, r02
17 add r02, r02, 0
18 jz 0, -0x12 (=0x7)
19 mov r01, 2
1a eq r01, r04, r01
1b jz r01, +4 (=0x20)
1c mov r01, 1
1d add r01, r03, r01
1e add r01, r01, 0
1f jz 0, -0x19 (=0x7)
20 load r01, 1
21 mov r03, 3
22 eq r03, r04, r03
23 jz r03, +2 (=0x26)
24 echo 0x14e
25 hlt
26 echo 0x172
27 jz 0, -0x21 (=7)
28 echo 0x107
29 hlt
```
Зато, поскольку используется только четыре регистра, этот п-код возможно будет перевести в машинный код реального процессора.
Продолжим в августе: уезжаю в отпуск, и дописываю этот пост прямо из аэропорта.
Всем приятного лета! | https://habr.com/ru/post/99595/ | null | ru | null |
# PHP5. «Безопасные шаблоны»
Исторически сложилось, что я не пользуюсь внешними шаблонизаторами типа Smarty или другими. Я использую основной «активный» шаблон, т.е. просто PHP файл в котором вызываются и вставляются данные для контент зон в виде простого HTML (как он формируется в данном случае не имеет значения). В предыдущей версии CMS, которая была не «коробочной» и в которой фактически не было разделения прав пользователей, данный аспект особо не напрягал — доступ к шаблону был либо «прямой» (фтп и прочее) либо через администраторский интерфейс для администратора. Но соответственно человек имеющий доступ к админке мог напихать вовнутрь этого файла любой php код. В новой версии CMS это неприемлемо, т.к. это фактически обход разграничения прав. Поэтому было решено отказаться от таких «небезопасных» шаблонов.
В поисках наиболее простого и изящного выхода, с использованием по минимуму «внешних» решений, я вспомнил об одной замечательной особенности встроенного в PHP XSLT процессора ([XSLTProcessor](http://ru2.php.net/manual/en/class.xsltprocessor.php)). А именно — использование в трансформациях функций PHP, при этом можно ограничить список этих фукнций. А этот как раз то, что необходимо.
Перейдем к примерам.
Стандартный «активный» шаблон выглядел следующим образом:
> `</fontphp
> $main\_ctx = CMSContentObj::getInstance()->getData("main\_ctx");
> $title = CMSContentObj::getInstance()->getTitle();
> // тут еще много вызовов
> ?>
> <html>
> <head>
> <meta content="text/html; charset=utf-8" http-equiv="Content-Type"/>
> <title></font=$title;?> - mysite.rutitle>
> <link href="/\_css/main.css" rel="stylesheet" type="text/css">
> <script type="text/javascript" src="/\_js/jquery.js">script>
> head>
> <body>
> …
> </font=$main\_ctx;?>
> …
> body>
> html>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/87417/ | null | ru | null |
# Анализ Crackme #1 от PE_Kill
### Предисловие
Я уже долгое время ничего не исследую, так сказать ушел на покой. Но тут мне на глаза попалась очередная поделка немало известного в определенных кругах PE\_Kill'a. Т.к. мне довелось решать его предыдущую поделку в рамках [CRACKL@B Contest 2010](http://exelab.ru/f/contest/), которая в свою очередь была довольно интересна, я решил взглянуть на его новое «детище».
Что вас ждет под катом: подделка CRC32, брут ключа для RC4, факторизация для RSA, а также использование коллизии для MD4 и генерация двух разных сообщений с одинаковыми хешеми. Всё это и многое другое под катом.
Статья рассчитана не на новичка, я не буду разжевывать все действия. Целью которой является написание кейгена.
### Введение
Как уже говорилось выше, я долгое время не занимался ресёчем. Потому пришлось потратить некоторое время на «раскачку». Также частично восстановить свой инструментарий, т.к. у меня осталась только [OllyDbg](http://ollydbg.de) и [IDA](http://www.hex-rays.com/products/ida/support/download_freeware.shtml). Последнее использоваться не будет. И вспоминая его задание с контеста, я ждал чего-то интересного, что заставит меня активизировать свой мозг намного больше чем обычно. И я не ошибся.
В бой
-----
### Получение разведданных
Ну, для начала нам понадобится сам [crackme](http://peco.at.ua/load/0-0-0-6-20). Открываем его в Ollydbg и видим, что он упакован с помощью UPX, ну им сейчас вряд ли кого испугаешь. Я пошел по пути наименьшего сопротивления, и распаковал его при помощи [QUnpack](http://tport.org/releases/tools/Quick_Unpack_2.2.Tool.tPORt.rar). Далее следуя своей технике выработанной годами, я решил проанализировать его на использование различных крипто, хеш, чексум алгоритмов. Для этого я воспользовался [SnD Reverser Tool](http://tuts4you.com/download.php?view.1923), которая мне сообщила, что нашла [CRC32](http://ru.wikipedia.org/wiki/CRC32), [RC4](http://ru.wikipedia.org/wiki/RC4), [MD4](http://ru.wikipedia.org/wiki/md4). Теперь зная всё это можно приступить к более активным действиям.
### В тылу врага
Итак, закончив статический анализ, переходим к динамическому анализу, т.е. айда дебажить. Снова открываем crackme (далее — крякми) в OllyDbg (далее — олька), но уже не оригинал, а распакованный. Жмем Ctrl+G и вводим GetDlgItemTextA, так мы перейдем к началу этой функции, ставим точку остановки и запускаем его. Вводим имя и некую лицензию для теста и нажимаем Check. Вот мы и стали по нашей точке остановки, жмем Alt+F9 и попадаем в код нашего крякми сразу после вызова функции получения имени.
После чего идут две проверке длины имени, первая это на то, что имя было введено, а вторая бессмысленная. Во второй проверки, если длина имени равна 50 нам сообщается, что имя длинное и выходим. Почему она бессмысленная, а потому что имя получается следующим образом:
>
> ```
> GetDlgItemTextA(hDlg, IDC_NAME, szName, 50);
> ```
>
А это значит, что максимум оно может считать строку длиной не больше 50 символов, где 50-ый символ – это символ конца строки, и того мы имеем, что длина строки никогда не будет превышать 49 символов. Точно тоже и с лицензией, но это не критично. После всего этого идет заветная функция, в которой и происходит всё самое интересное, я назвал ее – CheckLicense.
### Во вражеских окопах
И так мы в самом сердце. Первые пару функций это перевод символов лицензии в верхний регистр, а далее перевод лицензии в массив байт и там уже идет проверка на длину лицензии.
В функции перевода строки будет видно, что она проверяет лицензию на соответствие алфавиту (0–9, A-F), т.е. лицензия это какой-то массив данных, переведенный в хекс строку, и в конце проверяется, не равна ли длина полученного массива 0×90 байт. Отсюда следует, что лицензия должна иметь длину 0×90 \* 2 = 0×120 (288) символов.
После всего этого возвращаемся в основную функцию. Далее идет подсчет контрольной сумы первых 0×8С байт этого массива (далее этот массив будем называть — лицензия) с 4 байтовым числом, которое находится в конце лицензии.
А далее идет 10 кругов манипуляций с именем, результат каждого круга помещается в отдельный элемент массива 4-х байтовых чисел. Забегая наперед скажу, что этот массив будет ключом для RC4, поэтому буду называть его ключом.
Round 0–2:
Все круги кроме Round1 используются один раз, потому и воспринялись компилятором как инлайн-функции, а вот сам round1 будет еще использоваться в конце дважды как некая функция для получения контрольной сумы данных.
Round 3–4:
Round 5–7:
Round 8–9:
Как вы могли заметить, что round9 идентичен подсчету контрольной сумы лицензии, которая была в самом начале.
После всего этого с ключа несложными манипуляциями находим значения для последующего ксора этого же ключа. Также это значение будет использоваться еще в одной проверке после расшифровки тех самых первых 0×8С байт лицензии с помощью RC4 и с ключом, которое мы получили с имени. И еще в одной манипуляции, результата которой нам понадобится дальше.
Дальше получаем еще два значения, которые нам понадобятся дальше. С XorKey получим количество бит для сдвига, а с ключа нужный байт, который мы должны получить при сдвиги определенного значения на то количество бит, что получили выше. Ну и собственно сама расшифровка по RC4. Как я определил, что это именно оно, ну, во-первых я знаю список возможных алгоритмов, которые тут используются, во вторых по алгоритму инициализации ключа, кто не раз встречал этот алгоритм, тоже думаю, что быстро бы узнали его.
А вот и та проверка, где было нужно это значение. После расшифровки у нас должен находится в License[34] (если рассматривать лицензию как массив 4-х байтоных значений, что мы и будем дальше делать) значение идентичное XorKey. На этом заканчивается самая легкая часть в этом крякми. На то, что идет дальше мне потребовалось значительно больше времени и усилий.
Дальше идет подсчет CRC32 8 байт лицензии, которое должно равняться 0xFFB97FE0. Если всё проходит, то дальше эти 8 байт служат ключом для расшифровки двух захардкоденых значений по алгоритму RC4 и на выходе должны получить два фейса. Итак, вот первое интересное место, что есть в крякми. Погуглив я не нашел коллизий для RC4, которые бы мне помогли найти ключ, потому было принято решение брутить. Но брутить в лоб 8 байтов это немного глупо и долго. Хорошо, что я уже имел дело с подделкой CRC32 и я понял в какую сторону шагать. Для тех кто не в курсе, то в пару словах это звучит так – «с любых данных можно получить нужное нам CRC32, достаточно только дописать/заменить 4 нужных байта». Подробно об этом можно почитать [тут](http://www.rsdn.ru/article/files/classes/SelfCheck/crcrevrs.pdf). Отсюда имеем, что теперь нужно брутить не 8 байт, а 4, что значительно облегчает нам жизнь. Я решил не писать заумных брутеров с использованием разных технологий, многопоточности, распараллеливания вычислений. Я написал простой однопоточный брутер, который на моем AMD II X2 250 нашел ключ за 15 минут.
Вот так выглядит мой брутер:
>
> ```
> int main()
> {
> uint32_t key[2] = {0, 0};
> uint8_t *pkey = (uint8_t *)&key
>
> rc4_key skey;
> uint32_t rc4_data[2];
>
> do {
> fix_crc_end(pkey, 8, 0xFFB97FE0);
>
> prepare_key(pkey, 8, &skey);
> rc4_data[0] = 0xE6C5D5E1;
> rc4_data[1] = 0x41C98EAB;
> rc4((uint8_t *)rc4_data, 8, &skey);
> if (rc4_data[0] == 0xFACE0001 && rc4_data[1] == 0xFACE0002) {
> printf("Key: ");
> for (int i = 0; i < 8; i++) {
> printf("%02X", *pkey++);
> }
> printf("\n");
> break;
> }
> } while (key[0]++ <= 0xFFFFFFFF);
>
> printf("\n\n\t\tFin!\n");
>
> return 0;
> }
> ```
>
Я нашел правильный ключ, теперь я могу генерировать ключи, которые будут проходить все выше пройдённые проверки. Зная всё это можно представить общий вид лицензии:
>
> ```
> typedef struct _LICENSE {
> unsigned char M1[0x40];
> unsigned char M2[0x40];
> unsigned int FaceKey1;
> unsigned int FaceKey2;
> unsigned int AfterXorKey;
> unsigned int LicenseCheckSum;
> } LICENSE, *LPLICENSE;
> ```
>
Последние 4 значения уже разобраны, остается только первые 0×80 байт лицензии, забегая немного наперед скажу, что это два сообщения по 0×40 байт.
После фейсов сразу идет вызов функции, в которую передается указатель на лицензию, у меня она уже подписана как [RSA](http://ru.wikipedia.org/wiki/Rsa). Я постараюсь немного объяснить, как я это понял. После входа внутрь этой функции идут подряд 3 одинаковых функции, в которые передается указатель на массив данных, его размер и указатель на буфер с результатом. Эта функция читает с массива побайтово и в обратном порядке, т.е. от последнего элемента массива к первому. Это очень похоже на инициализацию больших чисел. Это первое, что пришло мне в голову.
Второй вызов этой функции только подтвердил мою догадку, когда я посмотрел в дамп на массив, с которого идет инициализация, я увидел эти заветные три байта 01 00 01. Это значение очень часто используется как экспонента в реализации RSA-расшифровке. Отсюда следует, что первая функция инициализировала открытый ключ N. После чего я его выдернул с дампа и факторизовал, для факторизации я использовал [msieve](http://sourceforge.net/projects/msieve/) под GPU. Ключ небольшой, всего 256 бит на его факторизацию ушло чуть более 4 минут.
Я раньше всегда старался придерживаться правила, что в кейгене нужно использовать такие же библиотеки и классы, что и в жертве. Поэтому я решил поискать подсказок, что за библиотека для больших чисел была использована. Немного потрейсив наткнулся вот на такое сообщение, вбив текст сообщения в гугл быстро нашел библиотеку, которая используется, ей оказалась [BigDigits](http://www.di-mgt.com.au/bigdigits.html).
После идет проверка на то что бы 6 элемент первого сообщения равнялся такому же элементу второго. А также чтобы это значение при сдвиги вправо на ShiftCount бит имело младший байт такой же, как и NeedByte. Все эти два значения мы получали выше.
После этого идет проверка на то, что CRC32 первого и второго сообщения не были равны, дальше такое же сравнение только функцией round1. После того ка всё разобрано можно увидить, что в этой части крякми вроде нет ничего особенного, также как и в следующей.
И в самом конце находятся MD4 хеши первого и второго сообщения, и если они равны, то мы удачно прошли проверку. Но подождите, если эти сообщения должны иметь разную контрольную суму по двум функциям значит сообщения должны быть разными, но при этом они должны иметь одинаковые хеши, что тут не вяжется.
И тут в игру снова вступает гугл с запросом «md4 collisions», и правда инфа по коллизиям для MD4 есть, и разная, есть статьи объемные, а есть поверхностные. И в одной с этих статей нахожу, что китайцы смогли создать два разных сообщения по 0×40 байт с одинаковыми хешами, вот оно. Теперь идем в гугл со следующем запросом «md4 collisions sources» и правда, есть исходники нахождения двух таких сообщений, но они были написаны под линукс, где функция random возвращает 4-х байтовое число, а в винде rand возвращает всего от 0 да RAND\_MAX (32767). Из-за чего у меня и были долго проблемы, почему оно генерит мне неправильные сообщения. После подсказки я переписал функцию random с Delphi, и всё заработало на ура.
### Пишем кейген
Я не буду описывать все шаги в написании кейгена, а только обращу внимание на некоторые важные моменты. Сперва создаем ключ для RC4 с имени, это я опущу, там нет ничего сложного, для ленивых можно просто всю эту часть рипнуть. Дальше нужно найти значение для ксора ключа и поксорить сам ключ, после чего с этого значения найти ShiftCount и NeedByte. Эту часть тоже можно рипнуть, для нахождения нужного байта нужно еще рипнуть таблицу размерностью 256 байт. Записываем XorKey значение в лицензию согласно структуры, которая приведенна выше. Также можно записать два значения, которые являются ключом для нахождения фейсов, они будут постоянны и одинаковы для всех. После чего нужно сгенерировать два сообщения, но дело в том, что там, если вы помните, 6 элемент должен иметь определенный формат. Сама функция генерирование сообщений не имеет никаких параметров, но так как нужно передать в нее два значения, это ShiftCount и NeedByte. Меняем прототип и дописываем еще пару строк в сам код этой функции. Было:
>
> ```
> if(X0[ 5] != X1[ 5])
> continue;
> ```
>
А стало:
>
> ```
> if(X0[ 5] != X1[ 5])
> continue;
> else
> if (((X0[5] >> c) & 0xFF) != b)
> continue;
> ```
>
где c – ShiftCount, b – NeedByte.
После чего сообщения помещаются в Х0 и Х1 соответственно. Дальше соединяем эти сообщение в одно большое и засовываем его в RSACrypt. Сама расшифровка идет блоками по 0×20 байт, поэтому так и будем шифровать. Но вот из-за этого тоже было у меня проблем, кто не знает, то сообщение (М – наш блок в 0×20 байт) должен быть меньше открытого ключа (N), в крякми это не учитывается, и он расшифровывает всё подряд. Поэтому это должны учесть мы. Я добавил проверку в функцию шифровки, если N < M, то выходим и генерируем новые сообщения, из-за чего время генерации лицензии затягивается до 15 секунд. После того как всё удачно зашифровали по RSA шифруем всю лицензию без последнего значения в структуре с помощью RC4 с ключом, которое получили с имени. И последний шаг – это подсчет контрольной сумы той части лицензии, что зашифровали по RC4 и запись его в последние значение структуры и перевод всей этой лицензии хекс-строку.
Вот и всё!
Материалы
---------
• [www.rsdn.ru/article/files/classes/SelfCheck/crcrevrs.pdf](http://www.rsdn.ru/article/files/classes/SelfCheck/crcrevrs.pdf) – подделка CRC32
• [www.en.wikipedia.org/wiki/MD4#Collision\_Attacks](http://www.en.wikipedia.org/wiki/MD4#Collision_Attacks) – MD4 коллизии
• [www.google.com](http://www.google.com)
• [www.wikipedia.org](http://www.wikipedia.org)
Исходники
---------
• [github.com/reu-res/Keygen-for-CrackMe-1-by-PE\_Kill](https://github.com/reu-res/Keygen-for-CrackMe-1-by-PE_Kill) – Брутер и кейген
**P.S.** Кейген принимает кириллицу, но это зависит от того как настроена консоль. У меня лично не принимала с консоли, а если захардкодить, то всё отлично. Мне лениво было переписывать под окошки. | https://habr.com/ru/post/135255/ | null | ru | null |
# Ловим баги на клиенте: как мы написали свою систему для сбора клиентских ошибок
У нас в Badoo довольно много клиентских приложений. Помимо основных продуктов Badoo и Bumble, у которых есть как веб-версии (десктопная и мобильная), так и клиенты под нативные платформы (Android и iOS), ещё есть с десяток внутренних инструментов со своими UI. Для сбора клиентских ошибок мы используем собственную разработку под кодовым названием Gelatо. Последние два года я работал над её серверной частью и за это время открыл для себя много нового из мира разработки Error Tracking систем.
Поэтому, если вам интересно узнать, что из себя представляет разработка системы сбора клиентских ошибок и о чём стоит подумать, если вы решите разрабатывать собственную систему, добро пожаловать под кат.
---
Что вас ждёт:
* я расскажу, как мы работаем с ошибками, какие инструменты использовали раньше и почему разработали свою систему, а не выбрали готовое решение.
* дам краткий обзор нашей системы, её архитектуры и технологического стека;
* перечислю особенности, которые нужно учитывать, если вы решите разрабатывать свою систему сбора клиентских ошибок.
### Как мы используем информацию об ошибках
**Первое** и самое очевидное — отслеживаем ошибки на продакшене. От багов на продакшене никто не застрахован, поэтому важно отслеживать такие проблемы, понимать, сколько пользователей они затронули, и оперативно фиксить наиболее критичные из них.
**Второе** — проводим анализ ошибок. Мы в Badoo релизимся довольно часто:
— веб-приложения: один-два раза в день, включая серверную часть;
— нативные приложения: раз в неделю (хотя многое зависит от того, как быстро билд примут в App Store и Google Play).
Одним из этапов выпуска новой версии приложения является анализ ошибок. Поэтому релиз-менеджеру необходимо быстро получать сводную информацию об ошибках в конкретной версии, чтобы понимать, можно ли деплоить билд на продакшен или всплыл непротестированный баг и нужно убрать проблемную фичу из релиза.
**Третье**. Информация об ошибках, собранная в одном месте, значительно упрощает работу разработчиков и QA-инженеров.
### Что использовали раньше
Исторически для сбора клиентских ошибок в Badoo использовались две системы: [HockeyApp](https://habr.com/ru/company/microsoft/blog/246169/) для сбора краш-репортов из нативных приложений и самописная система для сбора JS-ошибок.
#### HockeyApp
HockeyApp полностью удовлетворяла наши потребности, до тех пор пока в 2014 году её не приобрела Microsoft и не начала менять политику использования, чтобы подтолкнуть людей к переходу на свою систему App Center. App Center на тот момент нашим требованиям не соответствовала: она находилась на стадии активной разработки, и часть необходимой нам функциональности отсутствовала, в частности деобфускация стек-трейсов Android-приложений с использованием DexGuard mapping-файлов, без которой невозможна группировка ошибок. О деобфускации я расскажу ниже; если вы слышите об этом впервые, значит, точно узнаете что-то новое.
Microsoft установила дедлайн — 16 октября 2019 года, к этому дню все пользователи HockeyApp должны были мигрировать в App Center. К слову, поддержка DexGuard появилась в App Center лишь в конце декабря 2019 года, спустя несколько месяцев после официального закрытия HockeyApp.
В дополнение к этому мы столкнулись с проблемой некорректного подсчёта общего количества ошибок в HockeyApp. Так как Microsoft фактически остановила разработку HockeyApp, нам пришлось начать дублировать эту информацию во внутреннюю систему аналитики, чтобы понимать реальное количество ошибок. Это послужило ещё одним толчком к поиску альтернативного решения.
#### Наша система для сбора JS-ошибок
Что касается самописной системы для сбора JS-ошибок, то долгие годы она работала без нареканий, хотя обладала лишь базовой функциональностью.
Архитектура у неё была довольно простой:
* данные хранились в MySQL (мы хранили информацию о последних 10—20 релизах);
* для каждой версии приложения была отдельная таблица;
* работал поиск по фиксированному набору полей средствами MySQL, плюс мы использовали Sphinx для полнотекстового поиска.
В 2017 году у нас примерно в два раза увеличилась команда фронтенд-разработки. Системой начали пользоваться более активно — и разработчики стали всё чаще упираться в её ограничения. Кому-то не хватало возможности поиска по произвольным полям, кто-то хотел видеть историю ошибок между релизами, кого-то не устраивало, что мы храним информацию только о последних релизах.
Собрав и проанализировав все требования, мы поняли, что обойтись малой кровью не получится. Система, которая разрабатывалась в 2014 году, морально устарела, и затраты на её рефакторинг превысили бы стоимость внедрения нового решения.
Поэтому мы решили постепенно переходить на новую систему, которая бы покрывала весь существующий функционал и удовлетворяла всем нашим актуальным требованиям.
### Требования к новой системе
* Хранение всех клиентских ошибок в одном месте.
* Хранение событий минимум за полгода без семплирования. При исследовании фантомного бага (бага, у которого нет чёткого сценария воспроизведения) возможность посмотреть ошибки для конкретного пользователя в определённый момент времени может значительно облегчить жизнь инженера. Поэтому чем больше информации мы можем хранить, тем лучше.
* Лёгкое масштабирование. Периодически случаются ошибки, которые порождают миллионы событий. Система должна быть способна обработать такой поток данных.
* Отказоустойчивость — чтобы минимизировать риск потери данных.
* Способность давать ответ не только на вопрос «Сколько произошло ошибок?», но и на вопрос «Сколько пользователей это затронуло?».
* Группировка похожих ошибок с сохранением мета-информации (время первой и последней ошибки в группе, в каком релизе появилась ошибка, статус ошибки и т. п.).
* Гибкий поиск по любой комбинации полей с поддержкой полнотекстового поиска.
* Разнообразная статистика: количество ошибок за период, количество ошибок в разбивке по релизам, по браузерам, по операционным системам и т. п.
* Интеграция с Jira. Наша разработка ведётся с использованием Jira, поэтому нам необходима возможность создавать тикеты для определённых ошибок.
* Self-hosted. Мы хотим, чтобы система работала на нашем железе. Это обеспечит нам полный контроль над данными и возможность в любой момент изменить конфигурацию кластера.
### Почему мы не выбрали готовое решение
Конечно, прежде чем писать своё решение, мы проанализировали существующие на рынке системы.
#### Платные сервисы
Сбором клиентских ошибок занимаются многие [SaaS-решения](https://stackshare.io/exception-monitoring), и это неудивительно: быстрое обнаружение и исправление ошибок — один из ключевых аспектов современной разработки. Среди самых популярных решений можно выделить [Bugsnag](https://www.bugsnag.com/), [TrackJS](https://trackjs.com/), [Raygun](https://raygun.com/), [Rollbar](https://rollbar.com/) и [Airbrake](https://airbrake.io/). Все они обладают богатым функционалом и в целом соответствуют нашим требованиям, но мы не рассматривали облачные решения: не было уверенности в том, что ценовая политика и политика использования со временем не изменятся, как это случилось с HockeyApp. А миграция на новое решение — довольно сложная и длительная процедура.
#### Open-source-решения
С open-source-системами всё было не так радужно. Большинство из них либо перестали развиваться, либо так и не вышли из стадии разработки и были непригодны для использования в продакшене.
Фактически лишь [Sentry](https://sentry.io/) продолжал активно развиваться и обладал функциональностью, покрывающей большую часть наших потребностей. Но на тот момент (начало 2018 года) восьмая версия сервиса не подошла нам по следующим причинам:
* вместо хранения всех событий в ней использовалось семплирование;
* в качестве базы данных использовалась PostgreSQL, с которой у нас не было опыта работы;
* были сложности с добавлением новой функциональности, так как система написана на Python, а наши основные языки — PHP и Go;
* отсутствие части необходимой нам функциональности (например, интеграции с Jira).
В июле 2018 года вышла девятая версия Sentry, в которой появилась интеграция с issue-трекерами и был заложен фундамент для одного из ключевых, на мой взгляд, улучшений — перехода на ClickHouse для хранения событий (рекомендую к прочтению [серию статей об этом](https://blog.sentry.io/2019/05/16/introducing-snuba-sentrys-new-search-infrastructure)). Но к сожалению, на момент нашего ресёрча всего этого ещё не было даже в планах. Поэтому мы решили, что оптимальным вариантом в нашем случае будет реализация собственной системы, заточенной под наши процессы, которую легко интегрировать с другими внутренними продуктами.
Так на свет появилась система под кодовым названием **Gelato** (General Error Logs And The Others), о разработке которой и пойдёт речь дальше.
### Краткий обзор системы
Как говорится, лучше один раз увидеть, чем сто раз услышать, поэтому для начала я покажу, что умеет наша система сейчас, чтобы стало ясно, как мы работаем с ошибками. Это важно для понимания архитектуры системы: от того, как работают с данными, зависит то, как их следует хранить.
На главной странице находятся список приложений и общая статистика ошибок по заданному критерию.
Кликнув на то или иное приложение, мы попадём на страницу со статистикой по его релизам.
Кликнув на версию, мы попадём на страницу со списком ошибок.
Здесь можно узнать, какие ошибки произошли, сколько их было, сколько пользователей это затронуло, когда ошибка встретилась впервые и время последнего события. Также есть сортировка по большинству полей и возможность создания тикета в Jira для любой ошибки.
Так эта страница выглядит для нативных приложений:
Кликнув на ошибку, мы попадём на страницу с детальной информацией о ней.
Здесь доступны общая информация об ошибке (1), график общего количества ошибок (2) и различная аналитика (3).
Также можно получить информацию о конкретных событиях, что в основном используется для анализе проблемы.
Ещё одна интересная возможность, которую я не встречал в аналогичных системах, — сравнение версий. Это позволяет довольно легко обнаруживать ошибки, которые появились в новой версии, и те, что были исправлены в прошлых релизах, но начали воспроизводиться снова спустя какое-то время (регресс).
Выбираем версии для сравнения:
И попадаем на страницу со списком ошибок, которые есть в одной версии и которых нет в другой:
Как вы могли заметить, у нас реализован лишь базовый набор функций, который покрывает большинство кейсов. Но мы не планируем останавливаться на этом и в ближайшем будущем собираемся добавить много полезностей, расширяющих возможности системы, среди которых:
* интеграция с нашим A/B-фреймворком — для отслеживания ошибок, которые появились в том или ином сплит-тесте;
* система уведомлений о новых ошибках;
* расширенная аналитика (больше графиков и диаграмм);
* email-дайджесты со статистикой по приложениям.
### Общая схема работы
Теперь поговорим о том, как всё устроено под капотом. Схема довольно стандартная и состоит из трёх этапов:
1. Сбор данных.
2. Обработка данных.
3. Хранение данных.
Схематически это можно изобразить следующим образом:
Давайте для начала разберёмся со сбором данных.
### Сбор данных
Мы исходим из того, что разработчики клиентского приложения уже позаботились об обработке ошибок на своей стороне и всё, что требуется от нашего сервиса, — это предоставить API для отправки информации об ошибках в определённом формате.
Что входит в задачи API:
* прочитать данные;
* проверить данные на соответствие требуемому формату, чтобы сразу отсечь «шум» (чаще всего это запросы от «мамкиных хакеров», которые «натравили» сканеры на наше API);
* сохранить всё в промежуточную очередь.
**Для чего нужна промежуточная очередь?**
Если полагаться на то, что у нас достаточно низкий EPS (errors per second), и на то, что все части нашей системы будут работать стабильно всё время, то можно значительно упростить систему и сделать весь процесс синхронным.
Но мы-то с вами знаем, что в реальном мире так не бывает и на каждом из этапов в самый неподходящий момент может произойти нечто непредвиденное. И к этому наша система должна быть готова. Так, ошибка в одной из внешних зависимостей приложения приведёт к тому, что оно начнёт крашиться, что повлечёт за собой рост EPS (как это было [с iOS Facebook SDK 10 июля 2020 года](https://developers.facebook.com/status/issues/1739188102911114/)). Как следствие, значительно увеличится нагрузка на всю систему, а вместе с этим и время обработки одного запроса.
Или, например, временно будет недоступна база — и система попросту не сможет сохранить данные. Причин может быть много: проблемы с сетевым оборудованием, сотрудник дата-центра случайно задел провод — и сервер выключился, закончилось место на диске.
Поэтому, чтобы снизить риск потери данных и сделать их сбор максимально быстрым (чтобы клиенту не нужно было долго ждать ответа), мы сохраняем все входящие данные в промежуточную очередь, которая разбирается отдельным скриптом в нашем скриптовом облаке.
**Что можно использовать в качестве очереди?**
1. Первое, что приходит в голову, — популярные брокеры сообщений, например [Redis](https://redis.io/) или [RabbitMQ](https://www.rabbitmq.com/).
2. Также можно использовать [Apache Kafka](https://kafka.apache.org/), которая хорошо подходит для случаев, когда требуется хранить хвост входящих данных за определённый период (например, для какой-то внутренней аналитики). Kafka используется в частности в последней (десятой) версии Sentry.
3. Мы остановились на [LSD](https://habr.com/ru/company/badoo/blog/310352/) (Live Streaming Daemon). По сути, это очередь на файлах. Система используется в Badoo довольно давно и хорошо себя зарекомендовала, плюс у нас в коде уже есть вся необходимая обвязка для работы с ней.
### Хранение данных
Тут нужно ответить на два вопроса: «Где хранить?» (база данных) и «Как хранить?» (модель данных).
#### База данных
При реализации прототипа системы мы остановились на двух претендентах: Elasticsearch и ClickHouse.
**Elasticsearch**
Из очевидных плюсов данной системы можно выделить следующие:
* горизонтальное масштабирование и репликация из коробки;
* большой набор агрегаций, что удобно при реализации аналитической части нашей системы;
* полнотекстовый поиск;
* поддержка UPDATE по условию (процесс обработки данных у нас асинхронный, и нужна возможность выполнять некоторые шаги пайплайна повторно, а значит, и возможность обновлять определённые поля у конкретных событий);
* поддержка DELETE по условию (мы храним данные за полгода, а значит, нам нужна возможность удалять устаревшие данные);
* гибкая настройка через API, что позволяет разработчикам менять настройки индексов в зависимости от задач.
Конечно, как у любой системы, у Elasticsearch есть и недостатки:
* сложный язык запросов, поэтому документация всегда должна быть под рукой (в последних версиях появилась поддержка синтаксиса SQL, но это доступно только в платной версии (X-Pack) либо при использовании [Open Distro](https://opendistro.github.io/for-elasticsearch/) от Amazon);
* JVM, которую нужно «уметь готовить», в то время как наши основные языки — это PHP и Go (например, для оптимизации сборщика мусора под определённый профиль нагрузки требуется глубокое понимание того, как всё работает под капотом; мы столкнулись с этой проблемой при обновлении с версии 6.8 до 7.5, благо тема не нова и есть довольно много статей в интернете (например, [тут](https://e-mc2.net/elasticsearch-garbage-collection-hell) и [тут](https://medium.com/naukri-engineering/garbage-collection-in-elasticsearch-and-the-g1gc-16b79a447181)));
* плохое сжатие строк; мы планируем хранить довольно много данных и, хотя железо с каждым годом дешевеет, хотим использовать ресурсы максимально эффективно (конечно, можно использовать deflate-сжатие вместо LZ4, но это увеличит потребление CPU, что может негативно сказаться на производительности всего кластера).
**ClickHouse**
Плюсы данной базы:
* отличная производительность на запись;
* хорошее сжатие данных, особенно длинных строк;
* MySQL-совместимый синтаксис запросов, что избавляет от необходимости учить новый язык запросов, как в случае с Elasticsearch;
* горизонтальное масштабирование и репликация из коробки, хоть это и требует больше усилий по сравнению с Elasticsearch.
Но на начало 2018 года в ClickHouse отсутствовала часть необходимых нам функций:
* Поддержка DELETE по условию (мы планировали хранить данные за полгода, поэтому нам была необходима возможность удаления устаревших данных; в ClickHouse удаление данных по произвольному критерию предусмотрено не было, а партиционирование по произвольному полю (в нашем случае — по дате) на тот момент находилось на стадии экспериментальной фичи и не рекомендовалось к использованию в продакшене);
* поддержка UPDATE по условию: ClickHouse заточена под неизменяемые данные, поэтому реализация обновления произвольных записей — задача не из лёгких (этот вопрос не раз поднимался на [GitHub](https://github.com/ClickHouse/ClickHouse/issues/167) — и в конце 2018 года функцию всё же [реализовали](https://clickhouse.tech/docs/ru/sql-reference/statements/alter/update/), но она не подходит для частых обновлений);
* полнотекстовый поиск (была опция поиска по RegExp, но он требует сканирования всей таблицы (full scan), а это довольно медленная операция).
На самом деле, все упомянутые ограничения можно было обойти (и в Сети даже было несколько статей на эту тему ([например](https://clickhouse.tech/blog/en/2016/how-to-update-data-in-clickhouse/))). Но мы хотели реализовать прототип нашей системы с минимальными затратами, и для этого нам требовалась более гибкая база данных, поэтому мы остановили свой выбор на Elasticsearch.
Конечно, в плане производительности на запись Elasticsearch уступает ClickHouse, но для нас это было не критично. Куда важнее были поддержка нужной нам функциональности и масштабируемость из коробки. Сыграло свою роль и то, что у нас уже был кластер Elasticsearch, который мы использовали для [сбора логов от демонов](https://habrahabr.ru/company/badoo/blog/280606/), — отпадала необходимость в поднятии инфраструктуры.
#### Модель данных
Теперь немного поговорим о том, как мы храним события.
Все данные у нас разбиты на несколько групп и хранятся в отдельных индексах:
* мета-информация;
* сырые события.
Данные изолированы в рамках конкретного приложения (отдельный индекс) — это позволяет кастомизировать настройки индекса в зависимости от нагрузки. Например, для непопулярных приложений можно хранить данные на warm-нодах в кластере (мы используем [hot-warm-cold-архитектуру](https://www.elastic.co/blog/implementing-hot-warm-cold-in-elasticsearch-with-index-lifecycle-management)).
Для того чтобы в одной системе можно было хранить и JS-ошибки, и краш-репорты нативных приложений, мы вынесли на верхний уровень всё, что используется для формирования общей статистики (время ошибки, в каком релизе она произошла, информация о пользователе, ключ группировки). А то, что уникально для каждого типа ошибки, хранится во вложенном поле attributes со своим маппингом.
Сама идея была позаимствована из Sentry и незначительно доработана в процессе эксплуатации. В Sentry у события есть базовые поля, есть поле tags для данных, по которым нужна возможность поиска, и поле extra — для всех остальных специфических данных.
### Обработка данных
Вот мы и подошли к, на мой взгляд, самому интересному в разработке системы сбора клиентских ошибок — обработке данных. Без неё информация, которую мы собрали на предыдущем этапе, будет бесполезна и мы не сможем получить ничего, кроме сигнала, что в нашем приложении что-то пошло не так. А ведь наша цель — иметь возможность максимально быстро отслеживать и фиксить наиболее критичные ошибки.
Начнём со случая попроще.
#### Обработка краш-репортов из Android-приложений
Чтобы максимально уменьшить размер приложения, в Android-мире принято при сборке билда использовать специальные утилиты, которые:
* удаляют весь неиспользуемый код (code shrinking — сокращение);
* оптимизируют всё, что осталось после первого этапа (optimization — оптимизация);
* переименовывают классы, методы и поля в соответствии со специальным форматом, что позволяет уменьшить размер кодовой базы, а также усложнить процесс реверс-инжиниринга приложения (obfuscation — обфускация).
*Подробнее про это можно узнать из* [*официальной документации*](https://developer.android.com/studio/build/shrink-code).
Сегодня есть несколько популярных утилит:
* ProGuard (бесплатная версия);
* DexGuard на базе ProGuard (платная версия с расширенным функционалом);
* R8 от Google.
Если приложение собрано с режимом обфускации, то стек-трейс будет выглядеть примерно так:
```
o.imc: Error loading resources: Security check required
at o.mef.b(:77)
at o.mef.e(:23)
at o.mef$a.d(:61)
at o.mef$a.invoke(:23)
at o.jij$c.a(:42)
at o.jij$c.apply(Unknown Source:0)
at o.wgv$c.a_(:81)
at o.whb$e.a_(:64)
at o.wgs$b$a.a_(:111)
at o.wgy$b.run(:81)
at o.vxu$e.run(:109)
at android.os.Handler.handleCallback(Handler.java:790)
at android.os.Handler.dispatchMessage(Handler.java:99)
at android.os.Looper.loop(Looper.java:164)
at android.app.ActivityThread.main(ActivityThread.java:6626)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:438)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:811)
```
Из него мало что можно понять, за исключением сообщения об ошибке. Чтобы извлечь полезную информацию из такого стек-трейса, его нужно расшифровать. Процесс дешифрования обфусцированных классов и методов называется **деобфускацией**, для этого необходим специальный файл mapping.txt, который генерируется в момент сборки билда. Вот фрагмент такого файла:
```
AllGoalsDialogFragment -> o.a:
java.util.LinkedHashMap goals -> c
kotlin.jvm.functions.Function1 onGoalSelected -> e
java.lang.String selectedId -> d
AllGoalsDialogFragment$Companion Companion -> a
54:73:android.view.View onCreateView(android.view.LayoutInflater,android.view.ViewGroup,android.os.Bundle) -> onCreateView
76:76:int getTheme() -> getTheme
79:85:android.app.Dialog onCreateDialog(android.os.Bundle) -> onCreateDialog
93:97:void onDestroyView() -> onDestroyView
```
Следовательно, нам нужен сервис, которому мы могли бы скормить обфусцированный стек трейс и mapping-файл — и на выходе получить оригинальный стек-трейс.
Нам не удалось найти подходящих готовых решений в открытом доступе (может, конечно, плохо искали), но, к счастью, инженеры ProGuard (а мы используем DexGuard для обфускации) позаботились о разработчиках и выложили в открытый доступ утилиту [ReTrace](https://www.guardsquare.com/en/products/proguard/manual/retrace), которая реализует весь необходимый функционал для деобфускации.
На её базе наши Android-разработчики написали простенький сервис на Kotlin, который:
* принимает на вход стек-трейс и версию приложения;
* скачивает необходимый mapping-файл из Ceph (маппинги заливаются автоматически при сборке релиза в TeamCity);
* деобфусцирует стек-трейс.
#### Обработка краш-репортов из iOS-приложений
Краш-репорты из iOS-приложения содержат в себе довольно много полезной информации, включая стек-трейсы всех запущенных в момент падения тредов (подробнее про формат краш-репортов можно почитать [тут](https://developer.apple.com/library/archive/technotes/tn2151/_index.html) и [тут](https://www.raywenderlich.com/2805-demystifying-ios-application-crash-logs#toc-anchor-003)). Но есть одна загвоздка: стек-трейсы содержат лишь информацию об адресах памяти, по которым располагаются классы и методы.
```
Thread 0:
0 libsystem_kernel.dylib 0x00000001bf3468b8 0x1bf321000 + 153784
1 libobjc.A.dylib 0x00000001bf289de0 0x1bf270000 + 105952
2 Badoo 0x0000000105c9c6f4 0x1047ec000 + 21694196
3 Badoo 0x000000010657660c 0x1047ec000 + 30975500
4 Badoo 0x0000000106524e04 0x1047ec000 + 30641668
5 Badoo 0x000000010652b0f8 0x1047ec000 + 30667000
6 Badoo 0x0000000105dce27c 0x1047ec000 + 22946428
7 Badoo 0x0000000105dce3b4 0x1047ec000 + 22946740
8 Badoo 0x0000000104d41340 0x1047ec000 + 5591872
```
Процесс сопоставления адреса памяти с именем функции называется **символикацией**. Для того чтобы символицировать краш-репорт, необходимы специальные архивы с дебаг-символами (dSYM), которые генерируются в момент сборки билда, и софт, который с этими архивами умеет работать.
**Что можно использовать для символикации?**
* Можно написать свой сервис на базе [консольных утилит](https://www.bugsnag.com/blog/symbolicating-ios-crashes), но, скорее всего, он подойдёт только для ручной символикации и будет доступен только на macOS. У нас же, например, всё работает на Linux.
* Можно взять сервис [Symbolicator](https://github.com/getsentry/symbolicator) от Sentry, который недавно был выложен в открытый доступ (рекомендую почитать [статью](https://blog.sentry.io/2019/06/13/building-a-sentry-symbolicator) о том, как он разрабатывался). Мы какое-то время экспериментировали с ним и пришли к выводу, что as is этот сервис будет сложно интегрировать в нашу схему: пришлось бы допиливать его под наши нужды, а опыта использования Rust у нас нет.
* Можно написать свой сервис на базе библиотеки [Symbolic](https://github.com/getsentry/symbolic) от Sentry, которая, хоть и написана на Rust, но предоставляет C-ABI — её можно использовать в языке с поддержкой FFI.
Мы остановили свой выбор на последнем варианте и написали сервис на Golang с учётом всех наших нюансов, который под капотом обращается к Symbolic через cgo.
#### Группировка ошибок
И ещё один процесс, которому следует уделить внимание, — группировка ошибок. От неё зависит, как быстро вы сможете обнаруживать наиболее критичные ошибки среди всех остальных событий.
Человек, не знакомый с тем, как устроены системы обработки ошибок, может подумать, что в них используются какие-то сложные алгоритмы для определения схожести строк. Но в действительности все популярные системы используют группировку по ключу (fingerprint), потому что это просто в реализации и покрывает большинство кейсов. В самом элементарном случае это может быть хеш от текста ошибки и стек-трейса. Но это подходит не для всех типов ошибок, поэтому некоторые системы позволяют явно указывать, какие ключи вы хотите использовать для подсчёта ключа группировки (либо же вы можете передать ключ явно).
Мы решили не усложнять свою систему и остановились на группировке по хешу:
* JS-ошибки группируются по полям message, type и origin;
* Android краш-репорты группируются по первым трём строчкам стек-трейсов (плюс немного магии);
* iOS краш-репорты группируются по первому несистемному фрейму из упавшего треда (тред, который отмечен как crashed в краш-репорте).
### В качестве заключения
Путь от идеи до полноценного перехода на новую систему занял у нас практически два года, но мы довольны результатом и уже вынашиваем много планов по совершенствованию системы и интеграции её с другими нашими внутренними продуктами.
Однако если сегодня перед вами стоит задача начать собирать и обрабатывать клиентские ошибки, то я рекомендую присмотреться к Sentry, так как этот сервис активно развивается и является одним из лидеров рынка.
Ну а если вы решите последовать нашему примеру и станете разрабатывать собственную систему, то в этой статье я постарался максимально раскрыть основные моменты, на которые следует обратить внимание.
Если резюмировать, то:
* храните как можно больше данных: это может сэкономить вам драгоценные часы и нервы, которые в противном случае придётся потратить на дебаг;
* будьте готовы к резкому росту количества ошибок;
* чем больше аналитики вы построите, тем лучше;
* символикация iOS краш-репортов — это сложно, присмотритесь к [Symbolicator](https://github.com/getsentry/symbolicator);
* предусмотрите систему уведомления о новых ошибках: это даст вам больше контроля и возможность своевременно реагировать на резкий рост ошибок;
* запаситесь терпением и приготовьтесь к увлекательному путешествию в мир разработки систем сбора ошибок. | https://habr.com/ru/post/522600/ | null | ru | null |
# PE (Portable Executable): На странных берегах
Эта статья представляет из себя рассказ о том как устроены исполняемые файлы (в точку! Это именно те штуки, которые получаются после компиляции приложений с расширением .exe). После того, как написан код, подключены библиотеки, подгружены к проекту ресурсы (иконки для окон, какие-либо текстовые файлы, картинки и прочее) всё это компонуется в один единственный исполняемый файл, преимущественно с расширением .exe. Вот именно в этот омут мы и погрузимся.
*\*Статья находится под эгидой «для начинающих» поэтому будет изобиловать схемами и описанием важных элементов загрузки.*
#### Введение
PE формат — это формат исполняемых файлов всех 32- и 64- разрядных Windows систем. На данный момент существует два формата PE-файлов: PE32 и PE32+. PE32 формат для x86 систем, а PE32+ для x64. Описанные структуры можно наблюдать в заголовочном файле [WINNT.h](https://source.winehq.org/source/include/winnt.h), который поставляется вместе SDK. Описание сего формата от microsoft можно скачать [здесь](https://msdn.microsoft.com/en-us/windows/hardware/gg463119.aspx), а я же пока оставлю здесь небольшое схематическое представление. Просто пробегитесь глазами, в процессе статьи вы начнёте схватывать и всё разложится по полочкам.
Любой файл, это есть лишь последовательность байт. А формат, это как специальная карта (сокровищ) для него. То есть показывает что где находится, где острова с кокосами, где с бананами, где песчаные берега, а где Сомалийские, куда лучше-бы не соваться. Так давайте же изучим широкие просторы этого океана. Отдать швартовы!
> «Сейчас вы услышите грустную истори. о мальчике Бобби»
>
> (Остров сокровищ)
#### Dos-Header (IMAGE\_DOS\_HEADER) и Dos-stub
Dos заголовок. Это самая первая структура (самый первый островок который нам встретился на пути) в файле и она имеет размер 64 байта. В этой структуре наиболее важные поля это *e\_magic* и *e\_lfnew*. Посмотрим как выглядит структура:
Изучать все поля на данном этапе ни к чему, т.к. особой смысловой нагрузки они не несут. Рассмотрим только те, которые необходимы для загрузки и представляют особенный интерес. (Дальше и ниже по тексту, формат описания полей будет вида *name*: TYPE — description).
*e\_magic*: WORD — сигнатура находящаяся по смещению 0 от начала файла и равная “MZ”. Поговаривают, что MZ сокращение от Марк Збиновски — ~~самый злобный пират на всём водном пространстве~~ ведущий разработчик MS DOS и EXE формата. Если данная сигнатура не равна MZ, то файл не загрузится.
*e\_lfnew*: DWORD — смещение PE заголовка относительно начала файла. PE заголовок должен начинаться с сигнатуры (характерная запись/подпись) PE\x0\x0. PE заголовок может располагаться в любом месте файла. Если посмотреть на структуру, то можно увидеть, что *e\_lfnew* находится по смещению 0x3C (60 в десятичной). То есть чтобы прочитать это значение, мы должны от указателя на начало файла (введём обозначение — ptrFile) “плюсануть” 60 байт и тогда мы встанем face to face перед e\_lfnew. Читаем это значение (пусть будет peStep) и плюсуем к ptrFile значение peStep. Mission completed — мы на месте шеф, это должен быть PE заголовок. А узнать это наверняка мы можем сверив первые четыре байта этого заголовка. Как было сказано выше, они должны равняться PE\x0\x0.
После 64 первых байт файла стартует dos-stub (пираты также называют его dos заглушка). Эта область в памяти которая в большинстве своём забита нулями. (Взгляните ещё раз на структуру — заглушка лежит после dos-header(а) и перед PE заголовком) Служит она только для обратной совместимости, нынешним системам она ни к чему. В неё может быть записана мини версия dos программы ограниченную в 192 байта (256 — конец заглушки, 64 — размер dos заголовка). Но легче найти Access Point в Зимбабве, нежели такую программу. Стандартное поведение, если запустить программу на dos, то она выведет сообщения вида “This program cannot be run in DOS mode.” или “This program must be run under win32”. Если увидите эти строки, это значит что вы попали… в далёкий 85-ый.
> “-К чёрту деньги, я говорю о бумагах Флинта!”
>
> (Остров сокровищ)
#### PE-Header (IMAGE\_NT\_HEADER)
Прочитали *e\_lfnew*, отступили от начала файла на peStep байт. Теперь мы может начинать анализировать PE заголовок. Это новый для нас остров и он должен располагаться на просторах следующих 0x18 байт. [Структура](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680336(v=vs.85).aspx) представлена ниже:
```
typedef struct _IMAGE_NT_HEADERS {
DWORD Signature;
IMAGE_FILE_HEADER FileHeader;
IMAGE_OPTIONAL_HEADER OptionalHeader;
} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS;
```
Это интересная структура, т.к. она содержит в себе подструктуры. Если представить PE файл как океан, каждая структура это материк (или остров). На материках расположены государства, которые могут рассказать о своей территории. А рассказ складывается из истории отдельных городов (полей) в этом государстве. Так вот — NT Header — это материк, которой содержит такие страны, как Signature (город-государство), FileHeader, OptionalHeader. Как уже было сказано, *Signature*: DWORD — содержит 4-ёх байтовую сигнатуру, характеризующую формат файла. Рассмотрим что ещё может поведать нам этот материк.
#### File-Header (IMAGE\_FILE\_HEADER)
Это страна ~~где вечно стреляют, торгуют наркотиками и занимаются проституцией~~ где каждый город рассказывает в каком идеальном государстве он расположен. Это что касается неформального описания, а формальное заключается в следующем — набор полей, описывающий базовые характеристики файла. Давайте рассмотрим данную ~~державу~~ [структуру](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680313(v=vs.85).aspx):
```
typedef struct _IMAGE_FILE_HEADER {
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
```
Я лишь сухо опишу данные поля, т.к. названия интуитивно понятные и представляют из себя непосредственные значения, а не VA, RVA, RAW и прочие ~~страшные~~ интригующие штуки, о которых пока, мы только слышали от старых пиратов. Хотя с RAW мы уже сталкивались — это как раз смещения относительно начала файла (их ещё называют сырыми указателями или file offset). То есть если мы имеем RAW адрес, это значит что нужно шагнуть от начала файла на RAW позиций (ptrFile + RAW). После можно начинать читать значения. Ярким примером данного вида является *e\_lfnew* — что мы рассмотрели выше в Dos заголовке.
\**Machine*: WORD — это число (2 байта) задаёт архитектуру процессора, на которой данное приложение может выполняться.
*NumberOfSections*: DWORD — количество секций в файле. Секции (в дальнейшем будем называть таблицей секций) следуют сразу после заголовка (PE-Header). В документации сказано что количество секций ограничено числом 96.
*TimeDateStamp*: DWORD — число хранящее дату и время создания файла.
*PointerToSymbolTable*: DWORD — смещение (RAW) до таблицы символов, а SizeOfOptionalHeader — это размер данной таблицы. Данная таблица призвана служить для хранения отладочной информации, но отряд не заметил потери бойца с самого начала службы. Чаще всего это поле зачищается нулями.
*SIzeOfOptionHeader*: WORD — размер опционального заголовка (что следует сразу за текущим) В документации указано, что для объектного файла он устанавливается в 0…
\**Characteristics*: WORD — характеристики файла.
\* — поля, которые определены диапозоном значений. Таблицы возможных значений представлены в описании структуры на оф. сайте и приводиться здесь не будут, т.к. ничего особо важного для понимая формата они не несут.
Оставим этот остров! Нам нужно двигаться дальше. Ориентир — страна под названием Optional-Header.
> “— Где карта, Билли? Мне нужна карта.”
>
> (Остров сокровищ)
#### Optional-Header (IMAGE\_OPTIONAL\_HEADER)
Название ~~сего материка~~ заголовка не очень удачное. Этот заголовок является обязательным и имеет 2 формата PE32 и PE32+ (IMAGE\_OPTIONAL\_HEADER32 и IMAGE\_OPTIONAL\_HEADER64 соответственно). Формат хранится в поле *Magic*: WORD. Заголовок содержит необходимую информацию для загрузки файла. [Как всегда](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680339(v=vs.85).aspx):
**IMAGE\_OPTIONAL\_HEADER**
```
typedef struct _IMAGE_OPTIONAL_HEADER {
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint;
DWORD BaseOfCode;
DWORD BaseOfData;
DWORD ImageBase;
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage;
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADE
R, *PIMAGE_OPTIONAL_HEADER;
```
\* Как всегда, мы изучим только основные поля, которые имеют наибольшее влияние на представление о загрузке и того, как двигаться дальше по файлу. Давайте условимся — в полях данной структуры, содержаться значения с VA (Virtual address) и RVA (Relative virtual address) адресами. Это уже адреса не такие как RAW, и их нужно уметь читать (точнее считать). Мы непременно научимся это делать, но только для начала разберём структуры, которые идут друг за другом, чтобы не запутаться. Пока просто запомните — это адреса, которые после расчётов, указывают на определённое место в файле. Также встретится новое понятие — выравнивание. Его мы рассмотрим в купе с RVA адресами, т.к. эти они довольно тесно связаны.
*AddressOfEntryPoint*: DWORD — RVA адрес точки входа. Может указывать в любую точку адресного пространства. Для .exe файлов точка входа соответствует адресу, с которого программа начинает выполняться и не может равняться нулю!
*BaseOfCode*: DWORD — RVA начала кода программы (секции кода).
*BaseOfData*: DWORD — RVA начала кода программы (секции данных).
*ImageBase*: DWORD — предпочтительный базовый адрес загрузки программы. Должен быть кратен 64кб. В большистве случаев равен 0x00400000.
*SectionAligment*: DWORD — размер выравнивания (байты) секции при выгрузке в виртуальную память.
*FileAligment*: DWORD — размер выравнивания (байты) секции внутри файла.
*SizeOfImage*: DWORD — размер файла (в байтах) в памяти, включая все заголовки. Должен быть кратен SectionAligment.
*SizeOfHeaders*: DWORD — размер всех заголовков (DOS, DOS-Stub, PE, Section) выравненный на FileAligment.
*NumberOfRvaAndSizes*: DWORD — количество каталогов в таблице директорий (ниже сама таблица). На данный момент это поле всегда равно символической константе IMAGE\_NUMBEROF\_DIRECTORY\_ENTRIES, которая равна 16-ти.
*DataDirectory*[NumberOfRvaAndSizes]: IMAGE\_DATA\_DIRECTORY — каталог данных. Проще говоря это массив (размером 16), каждый элемент которого содержит структуру из 2-ух DWORD-ых значений.
Рассмотрим что из себя представляет [структура IMAGE\_DATA\_DIRECTORY](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680305(v=vs.85).aspx):
```
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
```
Что мы имеем? Мы имеем массив из 16 элементов, каждый элемент которого, содержит адрес и размер (чего? как? зачем? всё через минуту). Встаёт вопрос чего именно это характеристики. Для этого, у microsoft имеется специальные константы для соответствия. Их можно увидеть в самом конце описания структуры. А пока:
```
// Directory Entries
#define IMAGE_DIRECTORY_ENTRY_EXPORT 0 // Export Directory
#define IMAGE_DIRECTORY_ENTRY_IMPORT 1 // Import Directory
#define IMAGE_DIRECTORY_ENTRY_RESOURCE 2 // Resource Directory
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION 3 // Exception Directory
#define IMAGE_DIRECTORY_ENTRY_SECURITY 4 // Security Directory
#define IMAGE_DIRECTORY_ENTRY_BASERELOC 5 // Base Relocation Table
#define IMAGE_DIRECTORY_ENTRY_DEBUG 6 // Debug Directory
// IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // (X86 usage)
#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE 7 // Architecture Specific Data
#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR 8 // RVA of GP
#define IMAGE_DIRECTORY_ENTRY_TLS 9 // TLS Directory
#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG 10 // Load Configuration Directory
#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT 11 // Bound Import Directory in headers
#define IMAGE_DIRECTORY_ENTRY_IAT 12 // Import Address Table
#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT 13 // Delay Load Import Descriptors
#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14 // COM Runtime descriptor
```
Ага! Мы видим, что каждый элемент массива, отвечает за прикреплённую к нему таблицу. Но увы и ах, пока эти берега недосягаемы для нас, т.к. мы не умеем работаться с VA и RVA адресами. А для того чтобы научиться, нам нужно изучить что такое секции. Именно они расскажут о своей структуре и работе, после чего станет понятно для чего нужны VA, RVA и выравнивания. В рамках данной статьи, мы затронем только экспорт и иморт. Предназначение остальных полей можно найти в оф. документации, либо в книжках. Так вот. Собственно поля:
*VirtualAddress*: DWORD — RVA на таблицу, которой соответствует элемент массива.
*Size*: DWORD — размер таблицы в байтах.
Итак! Чтобы добраться до таких экзотических берегов как таблицы импорта, экспорта, ресурсов и прочих, нам необходимо пройти квест с секциями. Ну что ж юнга, взглянем на общую карту, определим где мы сейчас находимся и будем двигаться дальше:
А находимся мы не посредственно перед широкими просторами секций. Нам нужно непременно выпытать что они таят и разобраться уже наконец с другим видом адресации. Нам хочется настоящих приключений! Мы хотим поскорее отправится к таким республикам как таблицы импорта и экспорта. Старые пираты говаривают, что не каждый смог до них добраться, а тот кто добрался ~~вернулся -с золотом и женщинами~~ со священными знаниями об океане. Отчаливаем и держим путь на Section header.
> “- Ты низложен, Сильвер! Слезай с бочки!”
>
> (Остров сокровищ)
#### Section-header (IMAGE\_SECTION\_HEADER)
Сразу за массивом *DataDirectory* друг за другом идут секции. Таблица секций представляет из себя суверенное государство, которое делится на *NumberOfSections* городов. Каждый город имеет своё ремесло, свои права, а также размер в 0x28 байт. Количество секций указано в поле *NumberOfSections*, что хранится в File-header-е. Итак, рассмотрим [структуру](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680341(v=vs.85).aspx):
```
typedef struct _IMAGE_SECTION_HEADER {
BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
union {
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
DWORD PointerToRawData;
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
```
*Name*: BYTE[IMAGE\_SIZEOF\_SHORT\_NAME] — название секции. На данный момент имеет длину в 8 символов.
*VirtualSize*: DWORD — размер секции в виртуальной памяти.
*SizeOfRawData*: DWORD — размер секции в файле.
*VirtualAddress*: DWORD — RVA адрес секции.
*SizeOfRawData*: DWORD — размер секции в файле. Должен быть кратен *FileAligment*.
*PointerToRawData*: DWORD — RAW смещение до начала секции. Также должен быть кратен *FileAligment*…
*Characteristics*: DWORD — атрибуты доступа к секции и правила для её загрузки в вирт. память. Например атрибут для определения содержимого секции (иниц. данные, не инициал. данные, код). Или атрибуты доступа — чтение, запись, исполнение. Это не весь их спектр. Характеристики задаются константами из того-же WINNT.h, которые начинаются с IMAGE\_SCN\_. Более подробно ознакомится с атрибутами секций можно [здесь](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms680341(v=vs.85).aspx). Также хорошо описаны атрибуты в книгах Криса Касперски — список литературы в конце статьи.
По поводу имени следует запомнить следующее — секция с ресурсам, всегда должна иметь имя .rsrc. В противном случае ресурсы не будут подгружены. Что касается остальных секций — то имя может быть любым. Обычно встречаются осмысленные имена, например .data, .src и т.д… Но бывает и такое:
Секции, это такая область, которая выгружается в виртуальную память и вся работа происходит непосредственно с этими данными. Адрес в виртуальной памяти, без всяких смещений называется Virtual address, сокращённо VA. Предпочитаемый адрес для загрузки приложения, задаётся в поле *ImageBase*. Это как точка, с которой начинается область приложения в виртуальной памяти. И относительно этой точки отсчитываются смещения RVA (Relative virtual address). То есть VA = *ImageBase* + RVA; *ImageBase* нам всегда известно и получив в своё распоряжение VA или RVA, мы можем выразить одно через другое.
Тут вроде освоились. Но это же виртуальная память! А мы то находимся в физической. Виртуальная память для нас сейчас это как путешествие в другие галактики, которые мы пока можем лишь только представлять. Так что в виртуальную память нам на данный момент не попасть, но мы можем узнать что там будет, ведь это взято из нашего файла.
#### Выравнивание
Для того чтобы правильно представлять выгрузку в вирт. память, необходимо разобраться с таким механизмом как выравнивание. Для начала давайте взглянем на схему того, как секции выгружаются в память.
Как можно заметить, секция выгружается в память не по своему размеру. Здесь используются выравнивания. Это значение, которому должны быть кратен размер секции в памяти. Если посмотреть на схему, то мы увидим, что размер секции 0x28, а выгружается в размере 0x50. Это происходит из-за размера выравнивания. 0x28 “не дотягивает” до 0x50 и как следствие, будет выгружена секция, а остальное пространство в размере 0x50-0x28 занулится. А если размер секции был бы больше размера выравнивания, то что? Например sectionSize = 0x78, а sectionAligment = 0x50, т.е. остался без изменений. В таком случае, секция занимала бы в памяти 0xA0 (0xA0 = 0x28 \* 0x04) байт. То есть значение которое кратно sectionAligment и полностью кроет sectionSize. Следует отметить, что секции в файле выравниваются аналогичным образом, только на размер *FileAligment*. Получив необходимую базу, мы можем разобраться с тем, как конвертировать из RVA в RAW.
> “Здесь вам не равнина, здесь климат иной.”
>
> (В.С. Высоцкий)
#### Небольшой урок арифметики
Перед тем как начать выполнение, какая то часть программы должна быть отправлена в адресное пространство процессора. Адресное пространство — это объём физически адресуемой процессором оперативной памяти. “Кусок” в адресном пространстве, куда выгружается программа называется виртуальным образом (virtual image). Образ характеризуется адресом базовой загрузки (Image base) и размером (Image size). Так вот VA (Virtual address) — это адрес относительно начала виртуальной памяти, а RVA (Relative Virtual Address) относительно места, куда была выгружена программа. Как узнать базовый адрес загрузки приложения? Для этого существует отдельное поле в опциональном заголовке под названием *ImageBase*. Это была небольшая прелюдия чтобы освежить в памяти. Теперь рассмотрим схематичное представление разных адресаций:
Дак как же всё таки прочитать информацию из файла, не выгружая его в виртуальную память? Для этого нужно конвертировать адреса в RAW формат. Тогда мы сможем внутри файла шагнуть на нужный нам участок и прочитать необходимые данные. Так как RVA — это адрес в виртуальной памяти, данные по которому были спроецированы из файла, то мы можем произвести обратный процесс. Для этого нам понадобится ~~ключ девять на шестнадцать~~ простая арифметика. Вот несколько формул:
```
VA = ImageBase + RVA;
RAW = RVA - sectionRVA + rawSection;
// rawSection - смещение до секции от начала файла
// sectionRVA - RVA секции (это поле хранится внутри секции)
```
Как видно, чтобы высчитать RAW, нам нужно определить секцию, которой принадлежит RVA. Для этого нужно пройти по всем секциям и проверить следующие условие:
```
RVA >= sectionVitualAddress && RVA < ALIGN_UP(sectionVirtualSize, sectionAligment)
// sectionAligment - выравнивание для секции. Значение можно узнать в Optional-header.
// sectionVitualAddress - RVA секции - хранится непосредственно в секции
// ALIGN_UP() - функция, определяющая сколько занимает секция в памяти, учитывая выравнивание
```
Сложив все пазлы, получим вот такой листинг:
```
typedef uint32_t DWORD;
typedef uint16_t WORD;
typedef uint8_t BYTE;
#define ALIGN_DOWN(x, align) (x & ~(align-1))
#define ALIGN_UP(x, align) ((x & (align-1))?ALIGN_DOWN(x,align)+align:x)
// IMAGE_SECTION_HEADER sections[numbersOfSections];
// init array sections
int defSection(DWORD rva)
{
for (int i = 0; i < numberOfSection; ++i)
{
DWORD start = sections[i].VirtualAddress;
DWORD end = start + ALIGN_UP(sections[i].VirtualSize, sectionAligment);
if(rva >= start && rva < end)
return i;
}
return -1;
}
DWORD rvaToOff(DWORD rva)
{
int indexSection = defSection(rva);
if(indexSection != -1)
return rva - sections[indexSection].VirtualAddress + sections[indexSection].PointerToRawData;
else
return 0;
}
```
\*Я не стал включать в код объявление типа, и инициализацию массива, а лишь предоставил функции, которые помогут при расчёте адресов. Как видите, код получился не очень сложным. Разве что малость запутанным. Это проходит… если уделить ещё немного времени колупанию в .exe через дизассемблер.
УРА! Разобрались. Теперь мы можем отправится в края ресурсов, библиотек импорта и экспорта и вообще куда душа желает. Мы ведь только что научились работать с новым видом адресации. В путь!
> “-Неплохо, неплохо! Всё же они получили свой паёк на сегодня!”
>
> (Остров сокровищ)
#### Export table
В самом первом элементе массива *DataDirectory* хранится RVA на таблицу экспорта, которая представлена структурой IMAGE\_EXPORT\_DIRECTORY. Эта таблица свойственна файлам динамических библиотек (.dll). Основной задачей таблицы является связь экспортируемых функций с их RVA. Описание представлено в [оф. спецификикации](https://msdn.microsoft.com/en-us/library/ms809762.aspx#IMAGE_EXPORT_DIRECTORY):
```
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name;
DWORD Base;
DWORD NumberOfFunctions;
DWORD NumberOfNames;
DWORD AddressOfFunctions;
DWORD AddressOfNames;
DWORD AddressOfNameOrdinals;
} IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
```
Эта структура содержит три указателя на три разные таблицы. Это таблица имён (функций) (*AddressOfNames*), ординалов(*AddressOfNamesOrdinals*), адресов(*AddressOfFunctions*). В поле Name хранится RVA имени динамической библиотеки. Ординал — это как посредник, между таблицей имён и таблицей адресов, и представляет из себя массив индексов (размер индекса равен 2 байта). Для большей наглядности рассмотрим схему:
Рассмотрим пример. Допустим i-ый элемент массива имён указывает на название функции. Тогда адрес этой функции можно получить обратившись к i-му элементу в массиве адресов. Т.е. i — это ординал.
**Внимание!** Если вы взяли к примеру 2-ой элемент в таблице ординалов, это не значит 2 — это ординал для таблиц имён и адресов. Индексом является значение, хранящееся во втором элементе массива ординалов.
Количество значений в таблицах имён (*NumberOfNames*) и ординалов равны и не всегда совпадают с количеством элементов в таблице адресов (*NumberOfFunctions*).
> “За мной пришли. Спасибо за внимание. Сейчас, должно быть, будут убивать!”
>
> (Остров сокровищ)
#### Import table
Таблица импорта неотъемлемая часть любого приложения, которая использует динамические библиотеки. Данная таблица помогает соотнести вызовы функций динамических библиотек с соответствующими адресами. Импорт может происходить в трёх разных режимах: стандартный, связывающем (bound import) и отложенном (delay import). Т.к. тема иморта достаточно многогранна и тянет на отдельную статью, я опишу только стандартный механизм, а остальные опишу только «скелетом».
Стандартный импорт — в *DataDirectory* под индексом IMAGE\_DIRECTORY\_ENTRY\_IMPORT(=1) хранится таблица импорта. Она представляет собой массив из элементов типа IMAGE\_IMPORT\_DESCRIPTOR. Таблица импорта хранит (массивом) имена функций/ординалов и в какое место загрузчик должен записать эффективный адрес этой функций. Этот механизм не очень эффективен, т.к. откровенно говоря всё сводится к перебору всей таблицы экспорта для каждой необходимой функции.
Bound import — при данной схеме работы в поля (в первом элементе стандартной таблицы импорта) TimeDateStamp и ForwardChain заносится -1 и информация о связывании хранится в ячейке *DataDirectory* с индексом IMAGE\_DIRECTORY\_ENTRY\_BOUND\_IMPORT(=11). То есть это своего рода флаг загрузчику о том что нужно использовать bound import. Так же для «цепочки bound импорта» фигурируют свои структуры. Алгоритм работы заключается в следующем — в виртуальную память приложения выгружается необходимая библиотека и все необходимые адреса «биндятся» ещё на этапе компиляции. Из недостатоков можно отметить то, что при перекомпиляции dll, нужно будет перекомпилировать само приложение, т.к. адреса функций будут изменены.
Delay import — при данном методе подразумевается что .dll файл прикреплён к исполняемому, но в память выгружается не сразу (как в предыдущих двух методах), а только при первом обращении приложения к символу (так называют выгружаемые элементы из динамических библиотек). То есть программа выполняется в памяти и как только процесс дошёл до вызова функции из динамической библиотеки, то вызывается специальный обработчик, который подгружает dll и разносит эффективные адреса её функций. За отложенным импортом загрузчик обращается к DataDirectory[IMAGE\_DIRECTORY\_ENTRY\_DELAY\_IMPORT] (элемент с номером 15).
Малость осветив методы импорта, перейдём непосредственно к таблице импорта.
> “-Это моряк! Одежда у него была морская. — Да ну? А ты думал найти здесь епископа?”
>
> (Остров сокровищ — Джон Сильвер)
#### Import-descriptor (IMAGE\_IMPORT\_DESCRIPTOR)
Для того чтобы узнать координаты таблицы импорта, нам нужно обратиться к массиву *DataDirectory*. А именно к элементу IMAGE\_DIRECTORY\_ENTRY\_IMPORT (=1). И прочитать RVA адрес таблицы. Вот общая схема пути, который требуется проделать:
Затем из RVA получаем RAW, в соответствии с формулами приведёнными выше, и затем “шагаем” по файлу. Теперь мы впритык перед массивом структур под названием IMAGE\_IMPORT\_DESCRIPTOR. Признаком конца массива служит “нулевая” структура.
```
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk;
} DUMMYUNIONNAME;
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name;
DWORD FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;
```
Я не смог выудить на msdn ссылку на описание структуры, но вы можете наблюдать её в файле WINNT.h. Начнём разбираться.
*OriginalFirstThunk*: DWORD — RVA таблицы имён импорта (INT).
*TimeDateStamp*: DWORD — дата и время.
*ForwarderChain*: DWORD — индекс первого переправленного символа.
*Name*: DWORD — RVA строки с именем библиотеки.
*FirstThunk*: DWORD — RVA таблицы адресов импорта (IAT).
Тут всё несколько похоже на экспорт. Также таблица имён (INT) и ~~и тоже рубище на нём~~ адресов (IAT). Также RVA имени библиотеки. Только вот INT и IAT ссылаются на массив структур IMAGE\_THUNK\_DATA. Она представлена в двух формах — для 64- и для 32-ый систем и различаются только размером полей. Рассмотрим на примере x86:
```
typedef struct _IMAGE_THUNK_DATA32 {
union {
DWORD ForwarderString;
DWORD Function;
DWORD Ordinal;
DWORD AddressOfData;
} u1;
} IMAGE_THUNK_DATA32,*PIMAGE_THUNK_DATA32;
```
Важно ответить, что дальнейшие действия зависят от старшего бита структуры. Если он установлен, то оставшиеся биты представляют из себя номер импортируемого символа (импорт по номеру). В противном случае (старший бит сброшен) оставшиеся биты задают RVA импортируемого символа (импорт по имени). Если мы имеем импорт по имени, то указатель хранит адрес на следующую структуру:
```
typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint;
BYTE Name[1];
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
```
Здесь *Hint* — это номер функции, а *Name* — имя.
Для чего это всё? Все эти массивы, структуры… Рассмотрим для наглядности замечательную схему с [exelab](https://exelab.ru/faq/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BC%D0%BF%D0%BE%D1%80%D1%82%D0%B0_PE_%D1%84%D0%B0%D0%B9%D0%BB%D0%B0):
Что здесь происходит… Поле *OriginalFirstThunk* ссылается на массив, где хранится информация по импортируемым функциям. Поле *FirstThunk* ссылается на аналогичный массив той же размерности, но разве что заполняется он во время загрузки эффективным адресами функций. Т.е. загрузчик анализирует *OriginalFirstThunk*, определяет реальный адрес функции для каждого его элемента и заносит этот адрес в *FirstThunk*. Другими словами происходит связывание импортируемых символов.
> “-Мне не нравится эта экспедиция! Мне не нравятся эти матросы! И вообще… что?!!! А, да! Нет! Мне вообще ничего не нравится, сэр!”
>
> (Остров сокровищ — Капитан Смоллетт)
#### За бортом
В статье была представлена лишь самая база по исполняемым файлам. Не затронуты другие виды импорта, поведение при конфликтующих (например физический размер секции, больше виртуального) или неоднозначных (в том же импорте — вопрос к какому методу прибегнуть) ситуациях. Но это всё уже для более детально изучения и зависит от конкретных загрузчиков в ОС и компиляторов, которые собрали программу. Также не затронуты каталоги ресурсов, отладки и прочих. Тем кому стало интересно, можно почитать более подробные руководства представленные в списке литературы в конце статьи.
> “-Скажи, Окорок, долго мы будем вилять, как маркитантская лодка? Мне до смерти надоел капитан. Хватит ему командовать! Я хочу жить в его каюте.”
>
> (Остров сокровищ)
#### Заключение
После того как мы вернулись из путешествия, немного подытожу, что мы увидели и что вынесли. ~~Сегодня мы многое поняли~~ А именно опишу процесс загрузки приложения в общих словах.
* Сначала происходит считывание заголовков и проверка их на то, что файл является исполняемым. В противном случае работа прекращается, не успев начаться.
* Загрузчик выделяет под приложение требуемый объём виртуальной памяти. Если это возможно, то приложение будет загружено по предпочтительному адресу. Если же нет, то под приложение выделится другой участок памяти и загрузится с этого адреса.
* Затем для каждой секции вычисляется её адрес в виртуальной памяти (относительно базового адреса загрузки) и требуемый размер. После чего для данной области устанавливаются атрибуты и секция выгружается в память.
* Если базовый адрес отличается от предпочтительного, то происходит настройка адресов.
* Выполняется анализ таблицы импорта и подтягивются необходимые dll. Затем происходит процесс связывания.
На это статья заканчивается. Я думаю этой информации вполне достаточно чтобы иметь базовое представление об исполняемых файлах. Самым любознательнательным путь на [exelab](https://exelab.ru/), [wasm](http://www.wasm.ru/), [msdn](https://msdn.microsoft.com/en-us/library/ms809762.aspx), [ассемблеру](http://asmworld.ru/) и дизассемблеру.
Для более чёткого понимания можно порекомендовать поизучать диаграммы. Это действительно даёт более полную картину происходящего внутри. В качестве примера могу предложить вот эту [статью](http://habrahabr.ru/post/148194/) пользователя [alizar](https://habr.com/ru/users/alizar/) или более общие схемы в [гугле](https://www.google.ru/search?q=pe+file+structure&newwindow=1&biw=1366&bih=656&source=lnms&tbm=isch&sa=X&ved=0CAYQ_AUoAWoVChMI8uSTyID1xwIVo49yCh3Ecgtu). Надеюсь вам понравилось наше путешествие.
#### Список литературы
[ru.wikipedia.org/wiki/Portable\_Executable](https://ru.wikipedia.org/wiki/Portable_Executable)
[msdn.microsoft.com/en-us/library/ms809762.aspx](https://msdn.microsoft.com/en-us/library/ms809762.aspx)
[acmvm2.srv.mst.edu/wp-content/uploads/2014/07/PE-Header-Bible.pdf](http://acmvm2.srv.mst.edu/wp-content/uploads/2014/07/PE-Header-Bible.pdf)
[cs.usu.edu.ru/docs/pe](http://cs.usu.edu.ru/docs/pe/)
[Крис Касперски — Техника отладки программ без исходных текстов](http://www.litres.ru/kris-kasperski/tehnika-otladki-programm-bez-ishodnyh-tekstov/)
[exelab.ru/faq](https://exelab.ru/faq/) | https://habr.com/ru/post/266831/ | null | ru | null |
# BleepingComputer обнаружил фишинговую кампанию, направленную на верифицированные аккаунты Twitter
Как [сообщают](https://www.bleepingcomputer.com/news/security/as-twitter-removes-blue-badges-for-many-phishing-targets-verified-accounts/) специалисты BleepingComputer, злоумышленники задействовали новую систему фишинговых атак, нацеленную на аккаунты Twitter с синей галочкой. Они рассылают потенциальным жертвам письма с призывом обновить свои данные, чтобы не потерять верификацию. BleepingComputer предполагает, что кампания вызвана инцидентами с изъятием синих галочек с реальных аккаунтов пользователей.
Twitter уже несколько лет испытывает проблемы с верификацией аккаунтов. В мае этого года соцсеть заверила, что перестроила работу системы и более чётко прописала правила выдачи галочек. Тем не менее, после обновления системы летом пользователь Twitter (специалист по обработке данных с ником Conspirador Norteño) [обнаружил](https://habr.com/ru/news/t/567604/) несколько фейковых аккаунтов с галочкой верификации. Эти профили не соответствовали собственным правилам соцсети, по которой она подтверждает аккаунты.
Twitter [призналась](https://www.dailydot.com/debug/twitter-verified-bot-accounts/), что подтвердила верификацию по ошибке, и заблокировала найденные профили. В августе соцсеть в очередной раз закрыла выдачу новых синих галочек, [возобновив](https://habr.com/ru/news/t/578134/) её в середине сентября. После этого известные пользователи начали жаловаться, что Twitter отбирает у них верификацию из-за несоответствия новым правилам. Эта волна совпала с приходом Парага Агравала на пост генерального директора Twitter.
Злоумышленники используют недовольство верифицированных пользователей и неразбериху для своих фишинговых атак. Они рассылают на аккаунты пользователей письма, копирующие дизайн писем от Twitter. В них содержится призыв обновить свои данные, чтобы сохранить галочку, и кнопка «Обновить здесь», ведущая на страницы — `https://www.cleancredit[.]in/wp-content/uploads/2021/12/index.html` и `https://dublock[.]com/dublock/twitter/.`. При переходе потенциальная жертва видит окошко, в котором предлагают ввести учётные данные.
После заполнения данных система отправляет пользователю код двухфакторной аутентификации и просит ввести его в следующем окне.
После система отправляет пользователя на домашнюю страницу Twitter. Таким образом, люди могут и не подозревать, что злоумышленники собрали их данные. BleepingComputer призывает владельцев аккаунтов остерегаться таких фишинговых писем и воздерживаться от открытия любых ссылок или вложений внутри писем. | https://habr.com/ru/post/593647/ | null | ru | null |
# Преобразование текста в речь на Android
Android предоставляет полезную функцию, которая преобразовывает текст в речь (TTS), и воспроизводит текст на разных языках. Это руководство объясняет, как создать данную функцию. В этом уроке я также объясню, как изменить тип языка, громкость и уровень скорости.
[Исходники](http://yoatom.com/AndroidTextToSpeech.zip)
Ниже я представил видео конечного результата.
Я разработал простой интерфейс с одним полем ввода и кнопкой, чтобы вызвать событие, которое будет принимать текст из поля ввода и воспроизводить данный текст.
1. Создайте новый проект, выбрав File ⇒ New Android Project и заполните необходимые данные.
2. Реализация вашего основного класса активности из TextToSpeech.OnInitListener
```
public class AndroidTextToSpeechActivity extends Activity implements TextToSpeech.OnInitListener {
```
3. Теперь добавьте следующий код в главный класс.
```
package com.androidhive.texttospeech;
import java.util.Locale;
import android.app.Activity;
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
public class AndroidTextToSpeechActivity extends Activity implements
TextToSpeech.OnInitListener {
/** Called when the activity is first created. */
private TextToSpeech tts;
private Button btnSpeak;
private EditText txtText;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
tts = new TextToSpeech(this, this);
btnSpeak = (Button) findViewById(R.id.btnSpeak);
txtText = (EditText) findViewById(R.id.txtText);
// button on click event
btnSpeak.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
speakOut();
}
});
}
@Override
public void onDestroy() {
// Don't forget to shutdown tts!
if (tts != null) {
tts.stop();
tts.shutdown();
}
super.onDestroy();
}
@Override
public void onInit(int status) {
if (status == TextToSpeech.SUCCESS) {
int result = tts.setLanguage(Locale.US);
if (result == TextToSpeech.LANG_MISSING_DATA
|| result == TextToSpeech.LANG_NOT_SUPPORTED) {
Log.e("TTS", "This Language is not supported");
} else {
btnSpeak.setEnabled(true);
speakOut();
}
} else {
Log.e("TTS", "Initilization Failed!");
}
}
private void speakOut() {
String text = txtText.getText().toString();
tts.speak(text, TextToSpeech.QUEUE_FLUSH, null);
}
}
```
4. И запустите проект.
### Изменение языка
Вы можете изменить язык, используя функцию **SetLanguage ()**. На данный момент поддерживаются многие языки.
```
tts.setLanguage(Locale.CHINESE); // Chinese language
```
### Изменение громкости
Вы можете изменить уровень громкости, используя функцию **setPitch ()**. По умолчанию значение равно 1.0.
```
tts.setPitch(0.6);
```
### Изменение скорости
Частоту воспроизведения можно установить с помощью функции **setSpeechRate ()**. По умолчанию значение равно 1.0.
```
tts.setSpeechRate(2);
``` | https://habr.com/ru/post/143118/ | null | ru | null |
# Почему гику стоит переходить на Linux
Вот уже четвертый год я являюсь счастливым пользователем ОС Linux. Должен сказать, что до этого, начиная примерно с 1996 года, я был сначала просто пользователем, а потом и убежденным сторонником продуктов Microsoft. Я очень долгое время работал с их ОС, от DOS 6.22 до Windows XP/2003 Server. В сторону Linux я тогда смотрел со стойким недоверием. Но, признаюсь, вникать не хотел, а поверхностно Windows выглядела сильнее. Как говорил мой начальник, «не любил я все эти оккультные вещи с демонами и прочим». В силу специфики работы через мои руки прошли десятки, а то и сотни Windows-машин. Так что все, что я буду хаять тут, выстрадано на опыте :) Скажу также, что стандартные аргументы о безопасности и стабильности в моем случае не особо срабатывали. Умеючи администрировать Windows, можно добиться вполне приемлемой стабильности и безопасности. Windows падала у меня за 10 лет считанные разы. Да, конечно бывали BSODы, но тоже не сильно часто (kernel panic — линкусового аналога BSOD — на своих машинах, правда, не видел ни разу). Заражений вирусами на домашней машине я вспомнить вообще не могу. На работе, как и все, попали под Blaster. Но в целом, все было не так плохо, как об этом говорили.
На закате моей эпохи Windows я работал .Net программистом. Тогда я уже прочитал «Running Linux» и еще какую-то книгу по общей архитектуре Unix-систем. Они потрясли мое мировоззрение :) Я увидел на сколько стройнее и правильнее можно делать вещи. Увидел на сколько корявыми и костылистыми являются некоторые решения Microsoft. В общем, морально я уже был готов. Но в 2005 году Mono все еще было неработоспособной штукой. Помнится, я даже качал с сайта проекта LiveCD с Mono Develop. Но среда рухнула с грохотом при попытке изменить размер какого-то фрейма. Такое средство разработки меня не устраивало. С Linux пришлось отложить до лучших времен. А времена настали, когда я поменял работу, предав .Net в пользу Java. Уж тут то привязок к операционной системе было по минимуму. Так что сам Бог велел. К тому же у меня дома появился отдельный ноутбук, на котором я мог безболезненно для остального человечества экспериментировать. За месяц я настроил до устраивающего меня состояния Kubuntu 6.10. С тех пор я все сильнее раздражался с каждым разом, когда мне приходилось общаться с Windows XP на компьютере жены.
Итак, не холивара ради, а пользы для, посмотрим, что же получает IT-специалист от использования Linux?
##### Управление установленными программами
На Windows у меня была 30-гигабайтная папка «D:\Distribs». Софт в ней устаревал с пугающей скоростью. И большая часть оттуда вообще никогда не запускалась, а лежала на всякий случай. После перехода, я смело ее грохнул, а про проблему поиска и **обновления** софта забыл напрочь. Практически в каждом дистрибутиве вы найдете какой-нибудь менеджер пакетов. В моем случае это был apt. Система репозиториев с ПО просто великолепна. Вам достаточно узнать имя пакета, который нужен, и, скорее всего, он уже есть в репозитории вашего дистрибутива. После выполнения одной команды все, что необходимо, будет установлено и сконфигурированно. С подтягиванием всех зависимостей, справочными файлами и настройками GUI при необходимости. Вам не придется общаться с многошаговым инсталлятором, в котором все равно подавляющее большинство людей просто давят «Дальше». Установленное таким образом приложение автоматически обновится, когда нужно. А удалить программу можно также просто, одной командой, без всего этого ужаса со специальными деинсталляторами, мусором в реестре и куче других мест по системе. Windows, конечно, тоже позволяет обновлять саму себя. В случае критических уязвимостей она даже делает это довольно шустро. На сколько я знаю, есть даже способ обновлять кое-какой сторонний софт, но этим пользуются уже доли процентов пользователей. Здесь же вы получаете обновления не только системы, но и всего, что установлено у вас на машине. Если в каком-нибудь приложении вдруг найдется серьезная уязвимость, в течении дней или даже часов, вам предложат его обновить. В случае же с Windows, вам придется самостоятельно обновлять какой-нибудь Acrobat Reader, через дырку в котором работают десятки червей. В лучшем случае, программа сама умеет проситься в интернет на предмет обновиться.
##### Структура файловой системы
В Windows меня бесили диски. C:\ D:\ и прочие смайлики в начале пути, кажущиеся такими естественными для привычного Windows пользователя, на взгляд человека, видевшего альтернативу, являются настоящим бредом! В Linux вы получаете «единую» файловую систему с одним корнем. Вы вольны подключать ваши разделы куда вам угодно. Разложить информацию с дисков в нужном вам виде. Да, я помню, что в Windows была возможность «подключить раздел как папку». Я ей никогда не пользовался. Для меня тогда это казалось слишком непрозрачно. Так же много раз у меня происходила интересная вещь — буквы дисков менялись местами. Например, после подключения еще одного устройства на шлейф или запуска монстра, типа Acronis Partition Expert. Переназначить буквы, если был «затронут» системный раздел, было невозможно. Система, вместе с программами и пользователем сходила с ума. Я до сих пор не понимаю, как в чью-то светлую голову могла прийти идея с буквами.
Дальше — больше. Linux имеет некоторые рекомендации по поводу того, где программы должны хранить свои файлы. В сруктуре файловой системы есть некоторые стандартные пути, которые имеют заранее известное предназначение. Это сильно упрощает поиски нужного тебе файла и вообще администрирование системы. Я знаю где искать настройки, логи, бинарные файлы. В Windows же было полнейшее разнообразие. Некоторые приложения норовили нагадить прямо под себя в Program Files, некоторые — и того хуже — в C:\Windows! Часть файлов хранилась по ужасному пути «C:\Documents and settings\User\Application data», часть — на уровень выше. Некоторые программы вообще использовали, прости Господи, реестр. При этом, переустановка системы, которая проводилась обычно с очисткой системного раздела, приводила к потере всех этих настроек и данных, если не знать где они живут и как их спасти. В Linux же мы имеем стройную и безусловно работающую концепцию домашних каталогов, где программа хранит все, что ей важно. Для каждого пользователя каталог свой. У каждого пользователя программа будет вести себя так, как хотел этот пользователь. Более того, даже после переустановки Linux (что мне приходилось делать несколько раз, после каких-нибудь неудачных апдейтов на альфы :) ) Достаточно установить пакет приложения, и оно будет вести себя точно так же, как до этого, если /home вынесен на отдельный раздел. Я знаю, что в Windows это, в принципе, тоже реализовано. Но на момент моего предательства, только кросс-платформенные открытые приложения правильно использовали в Windows эту концепцию.
Поддержка симлинков дает дополнительную степень свободы при огранизации файловой системы. В Windows, вроде бы, тоже можно каким-то образом делать символические ссылки, но это опять же тайные знания. Простые пользователи дальше ярлыков не заходят. А тем временем символические ссылки позволяют делать среду гораздо более удобной и гибкой.
##### Настоящая консоль
В силу профессиональных нужд, сначала будучи админом, потом разработчиком, мне время от времени приходилось делать что-то в консоли Windows. Это было ужасно :) Наверное именно негуманноидность консоли Windows привела к гиперразвитию графических средств. Даже для простых операций с файлами пользватели вынуждены были ставить какой-нибудь менеджер. В моем случае это сначала был Windows(Total) Commander, потом Far. Хотя я видел даже людей, пользующихся проводником. Моя мама, например. В Linux же, мы получаем настоящую, крайне функциональную коммандную оболочку. Практически сразу я начал выполнять подавляющую долю операций с файлами из консоли. Ведь гораздо эффективней сказать системе что ты хочешь, чтобы она сделала, в виде команды, чем делать это собственными руками, прыгая по панелям и окнам, выделя и перетаскивая файлы и нажимая лишние кнопки. «Множество мелких, суетливых движений» — прекрасная характеристика метода работы, которым мне сейчас вспоминается Windows-период. Для примера, создайте в Проводнике или Far стандартную структуру maven-проекта:
```
project/
`-- src
|-- main
| |-- java
| `-- resources
`-- test
|-- java
`-- resources
```
Наверняка для этого есть средства, может даже встроенные. Но я, в свое время, с такими простыми вещами мучился. А в консоли Linux это будет одна команда:
`mkdir -p project/src/{main,test}/{java,resources}`
Практически все задачи администрирования выполнимы из консоли. Да что и говорить, некоторые выполнимы только из нее. Многие вещи, делаются из консоли гораздо быстрее, чем через GUI. От использования консоли в Windows также отталкивает совершенно непрозрачная работа переменных окружения. Мне редко удавалось добиться того, чтобы $PATH работала так, как должна. Часто, чтобы запустить команду из консоли, приходилось писать полный путь до бинарника. В Linux с этим все замечательно.
Также Linux представляет широчайшие возможности по автоматизации, с использованием shell-скриптов, или любого удобного вам языка. Тем не менее во всех дистрибутивах, ориентированных на «обычного» пользователя, есть очень богатый GUI, по возможностям не отстающий (по слухам) от Windows 7. И уж точно превосходящий интерфейс XP.
##### Планировщик
В Windows есть Запланированные задания. Я однажды даже пытался ими воспользоваться. У меня не получилось :) Оно просто не нашло бинарника, который надо запустить. С тех пор я использовал какую-то стороннюю программу, которая имитировала Linux планировщик cron. Вот что работало безотказно! И, конечно, работать с оригиналом этой замечательной программы еще приятней. cron — очень простая и предсказуемая программа. Никаких сбоев или неожиданностей. Работает как часы :)
##### Удаленная работа
Помню, как я радовался в Windows возможности работать через RDP. 2 конкурентных сессии, забудешь выйти — перегружай машину. На XP того хуже. На толстом канале, иначе лаги. С глитчами многих приложений.
В Linux вы получите ssh — безопасный shell на удаленной машине, с возможностью прокинуть порты в любую сторону или даже графическое приложение, передавать файлы, монтировать удаленные файловые системы, запускать любые другие команды. Последние несколько лет — это незаменимый и неотъемлимый инструмент в моей работе. С помощью него можно управлять как огромными фермами, так и мобильными телефонами. Я не представляю, как можно без этого жить :) Но никто не отменял и VNC, который в исключительных случаях может быть полезен и Linux-пользователю.
##### Поддержка устройств
Этот контраргумент поклонников Windows в моем случае возымел обратное действие. В последнее время, поддержка устройств в Linux не вызывает никаких нареканий. Даже наоборот. Например, noname веб-камера, которая в Windows заводилась только с драйверами с диска из коробки, который я уже давно потерял, прекрасно распозналась и заработала в Linux. Ядро просто знает, как работать с чипом в этой камере, что, подозреваю, дает ему возможность работать с любыми камерами, построенными на этом чипе. Я сейчас не помню устройства, для которого мне приходилось бы искать драйверы. Максимум, поискать в интернете, как заставить работать устройство. Система или сама предлагает мне скачать какой-нибудь проприетарный модуль, или все работает и так… или не работает никак :) Но это относится к совсем экзотическим и, обычно, очень «китайским» устройствам. Популярные устройства известных, надеждых, производителей, способных и желающих написать поддержку своего устройства для Linux, работают не хуже, чем в Windows. В общем, про поддержку устройств я практически забыл. Мой старый ноутбук, новый нетбук и неттоп работают из коробки.
##### Документация
Справочная система Windows была, мягко говоря, бесполезной. Единственный нормальный источник информации был тогда — MSDN. И тот затрагивал только произведения самой Microsoft. Не в пример этому, встроенная система документации Linux — крайне полезная штука, достаточная для решения большинства задач. Вы получите исчерпывающую информацию об использовании команды, возможно даже с примерами, а иногда и на русском.
Кроме того, огромного количество решений различных проблем нагенерированно самим сообществом. Всевозможные форумы, wiki, блоги. Для человека, умеющим пользоваться поисковиком, доступна практически любая документация. В крайнем случае, есть огромное количество мест, где можно задать вопрос, и, что важно, получить ответ.
##### Что делать, когда решитесь
Перед тем, как бросаться в омут, я бы посоветовал сделать несколько вещей. Пересмотрите еще раз все (или хотя бы основные) задачи, которые вы решаете на Windows. Какие программы для этого применяются? Будут ли эти задачи стоять перед вами в другой ОС? Есть для этого инструменты? Рекомендую поискать решения заранее. Для более мягкого перехода, лучше уже на Windows перейти на кросс-платформенные аналоги часто используемых программ.
Особые сложности, говорят, возникают с играми и CAD-подобными программами. А таже какой-нибудь экзотикой. Для этого придется или пробовать wine, или держать Windows в виртуальной машине.
Попробуйте выбранный дистрибутив на вашем конкретном железе. В случае, если используется что-то, не сильно популярное или просто от производителя, который не хочет поддерживать Linux, даже сейчас могут возникнуть проблемы. Попробуйте хотя-бы Live-версию дистрибутива. Альтернатива — поискать примеры использования дистрибутивов на вашем железе. Особенно хорошо, если это ноутбук, или другое несборное устройство. Больше вероятность найти. Хотя можно и по компонентам поискать.
Учите английский :) Возможно, придется много читать. Читать хорошую, полезную документацию на английском.
В целом, приведенные выше преимущества — это то, что сделало для меня, как IT-специалиста, работу приятней и, главное, эффективней, чем это было в Windows. Наверняка есть еще ряд преимуществ, которые я не упоминал. Если перед вами часто стоят технические задачи и среда позволяет, очень рекомендую попробовать Linux. Также рекомендую его простым домашним и офисным пользователям, в задачи которых входятит работа с интернетом, документами, мультимедиа. Все это прекрасно можно делать в Linux.
В моей нынешней компании больше половины разработчиков использует на машинах Linux (C++ и Java разработка). В прошлой компании весь отдел разработки успешно смигрировал на Linux с Windows.
Надеюсь, я не задел ни чьих религиозных или иных чуств. | https://habr.com/ru/post/88737/ | null | ru | null |
# Легенды вирусостроения: В тисках шифратора
Лето 1994 года запомнилось многим. Чем оно запомнилось? Ответ не сложен, хотя прошло больше 15 лет, эти три строки у некоторых из читателей могут вызвать неприятные ощущения «под ложечкой»:
`Dis is one half.
Press any key to continue…
Did you leave the room?`
Если вам не довелось видеть этого в живую, то позвольте описать ощущения, возникающие у лицезреющих эти строки: *недоумение* (примерно 1 минуту), *банальный страх* (~2 минуты), *лихорадочный поток мыслей* (*что это? что делать?* — в среднем 5-10 минут), *гнев* (*что за х…?*) и снова *лихорадочный поток мыслей и действий* (где же эта гребаная дискета с *Web’ом*?), вот примерно те пограничные эмоциональные ощущения, которые чувствовали владельцы зараженных машин.
Если вы еще не догадались, то речь идет о вирусе, который большинство помнят как — **OneHalf**, хотя он также известен и под другими именами — *Slovak Bomber, Explosion-II, Freelove*.
Впервые вирус был обнаружен в мае 1994 года в США и Европе, но было уже поздно и вирус уже широко распространился по всему миру. Распространялся **OneHalf** в основном через съемные носители (тогда это были в основном дискеты). Он является чрезвычайно примечательным по своим свойствам даже сейчас, а в то время это было новое слово в ремесле вирмастеров, если можно так выразиться конечно.
Во-первых, **OneHalf** — полиморф (не первый и далеко последний, но современные вирусы без полиморфизма просто не выживают, для несведущих полиморфным считается такой вирус, каждая новая копия которого может ни в одном байте не совпадать с предыдущей), во-вторых, вирус был файлово-загрузочным (заражал [MBR](http://ru.wikipedia.org/wiki/%D0%93%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C) и *boot*-сектора дискет, а также *COM* и *EXE* файлы), в-третьих, тело вируса было зашифровано, в-четвертых, до создания нормальных средств противодействия, **OneHalf** гарантировано разрушал данные, ну и пожалуй последнее, стелс-функциональность, встроенная в вирус, позволяла оставаться ему невидимым для системы.
### А теперь разберем некоторые детали
Зашифрованное тело вируса длиной *3544 байта* в зараженном файле находится после конца файла, при этом зараженный файл содержит в себе 10 *«пятен»-фрагментов* кода расшифровщика и таблицу размещения *«пятен»*, размещающуюся вначале файла и содержащую также информацию о смещении начала тела вируса от начала файла.
**Зараженный файл (приращение длины 3544 байт):**
* Таблица размещения «пятен» кода расшифровщика
* «Пятна», в которых содержится расшифровщик тела вируса
* Тело зараженного файла
* Зашифрованное тело вируса
### Механизм заражения файлов
Эпидемия передавалась *дискетно-ручным* способом. При обращении зараженной системы к дискете для записи OneHalf перехватывал его и проверял размер, имя (не трогал файлы с именами *SCAN, CLEAN, FINDVIRU, GUARD, NOD, VSAFE, MSAV, CHKDSK, AIDS, ADINF, WEB*) и зараженность файла. Если размер, имя не соответствовали алгоритму или файл уже был заражен, то заражение не производилось. Если же файл был чист и соответствовал требованиям вируса, то производилось его заражение.
В файле создавались 10 пустых мест (*«пятен»*) для записи расшифровщика, при этом вирь создавал их в случайном порядке, при единственном условии — не менее 10 байт между ближайшими *«пятнами»*. Маршрутная таблица размещения *«пятен»* кода расшифровщика размещалась в начале файла, в ней также хранился случайный ключ с помощью которого зашифровывалось тело вируса, которое находилось в конце заражаемого файла. В случае если по каким-то причинам запись не удавалась *«пятна»* уничтожались и файл оставался чистым, иначе зараженный файл записывался на дискету, ожидая свою следующую жертву.
### Механизм заражения компьютера
При пользовании зараженной дискетой (загрузки с нее или запуске зараженного файла), вирус при помощи собственного обработчика прерывания **Int12h** оценивал размеры свободной оперативной памяти и наличие в ней своей копии — прерывание **Int21h**.
Если вируса в памяти не было и ее больше 4 [кБ], он искал признаки заражения *MBR*, если таковых не находилось он заражал *MBR*. Для этого он на место оригинального *MBR* записывал свой обработчик загрузки тела вируса, затем записывал 7 секторов кода своего тела в 7 секторов от конца нулевой дорожки диска в скрытых секторах, а после всего этого оригинальный *MBR* в восьмой сектор от конца нулевой дорожки диска. После записи своего тела на диск или при обнаружении уже зараженного *MBR*, **OneHalf** проверял память и при отсутствии своей копии переписывал ее с диска в память.
После того, как вирус оказывался загружен в оперативу, руль системы был у него в руках. Дальше злодей считывал из *MBR* нижнюю границу зашифрованной дорожки и если она не дошла до 7 дорожки от начала, то вирь шифровал две дорожки вверх от нижней границы уже зашифрованных, при этом использовался *случайный* ключ, содержащийся в *MBR*. Если шифрование прошло удачно, в *MBR* записывалось новое значение нижней границы зашифрованных дорожек. (для работы он использовал свои обработчики прерываний [Int01h](http://www.codenet.ru/progr/dos/int_0001.php), [Int12h](http://www.codenet.ru/progr/dos/int_0011.php), [Int1Ch](http://www.codenet.ru/progr/dos/int_0021.php), [Int13h](http://www.codenet.ru/progr/dos/int_0012.php), [Int21h](http://www.codenet.ru/progr/dos/int_0026.php), [Int24h](http://www.codenet.ru/progr/dos/int_0034.php)). Если же нижняя граница дошла до 7 дорожки, шифрование не производилось во избежание повреждения системных областей диска.
Затем **OneHalf** анализировал три параметра: зашифрованость половины диска, кратность системной даты четырем и четность счетчика заражений (содержался в теле самого вируса); при положительной проверке на дисплей выводилось сообщение:
`Dis is one half.
Press any key to continue…`
а зловред ожидал нажатия той самой клавиши *«Any»*.
Если проверка параметров отрицательна (т. е. половина диска не зашифрована, счетчик нечетен или системная дата не подходящая), то сообщение не выводилось, а вирус отдавал управление оригинальному загрузчику до следующей загрузки компьютера, при этом *сохраняя свои обработчики прерываний*.
При работе пользователь ничего не замечал, поскольку **OneHalf**, сидящий в памяти перехватывал обращения к уже зашифрованным дорожкам и расшифровывал их на лету без всяких тормозов, скрывал уменьшение размера оперативки и приращение длины зараженных файлов для всех программ кроме **CHKDSK** и **Norton Commander**, но это ничего не давало, поскольку при попытке трассировки вируса в памяти он 100%-но вешал систему *циклом без выхода* с помощью своего обработчика прерываний *Int01h*.
В зависимости от модификации **OneHalf** варьировались размеры приращений зараженных файлов, 3544, 3577 или 3518 байта, — в связи с чем в антивирусных базах версии так и назывались *OneHalf.3544, OneHalf.3577 и OneHalf.3518*.
Также в разных версиях **OneHalf** при зашифровке половины диска на дисплей выдавались разные сообщения:
`Dis is one half.
Press any key to continue …
Dis is TWO HALF.
Fucks any key to Goping…
HET — фu3uke u ucTopuu B pacnucaHuu uy7!
Disk is Tpu half.
(Bepx, Hu3 u Pe6po)
Dis is 3 HALF !.
Fucks any key to LoHing…
A cup of Beer ?.
See you later…`
### Борьба
Почему произошла эта эпидемия? Мне думается, что дело было так. Вирус появился на свет где-то зимой 1994 года, ближе к весне произошло массовое распространение, продолжавшееся еще несколько месяцев незаметно для пользователей и разработчиков антивирусов. Первые известия о роковых строках на экранах дисплеев появились только в мае-июне, так как для полной шифровки винчестера емкостью 0.5 [ГБ], необходимо было перезагрузить компьютер около 500 раз, что при нормальной эксплуатации ПК занимало несколько месяцев. Поэтому **OneHalf** и был упущен, а эпидемия разошлась, чуть не став пандемией.
Что немаловажно, так это то, что для избавления от вируса недостаточно было простой перезаписи *MBR*, которая привела бы только к утере ключа к шифрованным данным, а вследствие этого и к потере данных. Для гарантированного избавления необходима была тонкая работа антивирусных утилит, как по обезвреживанию, так и по расшифровке данных.
Распространение вируса и его модификаций происходило еще несколько лет, но не такими взрывными темпами, даже сейчас он еще бродит по старым дискетам и раритетным компам.
P.S.
----
Какие я могу здесь подвести итоги? В общем не так уж и давно я осознал тот факт, что в школе и в универе нам не зря ставили *«жбаны»* (двойки :) если палили, что мы не проверяли только что вставленные в привод дискеты на вирусы, ох не зря…
→ OneHalf на сайте **[f-secure](http://www.f-secure.com/v-descs/one_half.shtml)**
→ OneHalf на **[securelist](http://www.securelist.com/ru/viruses/encyclopedia?virusid=19554)**
→ OneHalf на **[viruslist](http://www.viruslist.com/en/viruses/encyclopedia?virusid=19555)**
→ О OneHalf на страницах **[«Компьютер-информ»](http://www.ci.ru/inform12_97/onehalf.htm)**
→ **[Эссе](http://www.csie.ntu.edu.tw/~wcchen/asm98/asm/proj/b85506050/ORIGIN/ONEHAL~1.HTM)** Евгения Касперского о вирусе OneHalf **[ENG]** | https://habr.com/ru/post/74373/ | null | ru | null |
# Бэрримор, что за шум вокруг Voximplant? Внедрили веб-сокеты, сэр
[](https://habr.com/ru/company/Voximplant/blog/476902/)
WebSocket — это прогрессивный стандарт полнодуплексной (двусторонней) связи между клиентом и сторонним сервисом в режиме реального времени. Веб-сокеты используются для организации непрерывного обмена данными без дополнительных HTTP-запросов.
И мы рады сообщить вам, что все это стало возможным в Voximplant благодаря новому модулю [VoxEngine](https://voximplant.com/docs/references/voxengine), который называется – сюрприз – [WebSocket](https://voximplant.com/docs/references/voxengine/websocket). Отныне вы сможете передавать текст и аудио, пользуясь преимуществами веб-сокетов в полной мере. Проще говоря, у вас появился еще один инструмент, чтобы прокачать ваше приложение.
Из этой статьи вы узнаете, как создать исходящее WebSocket-соединение, передать через него аудиопоток и преобразовать его в текст с помощью [Google Cloud Speech-to-Text API](https://cloud.google.com/speech-to-text/).
> Обратите внимание, что у Voximplant есть встроенная функциональность преобразования речи в текст в реальном времени под управлением [модуля ASR](https://voximplant.com/docs/references/voxengine/asr). Данный модуль использует функции от Google, Yandex и Tinkoff, см. подробности [здесь](https://voximplant.com/docs/howtos/stt/asr).
>
>
>
> Текущая же статья описывает случай, когда вы хотите использовать сторонний сервис преобразования речи в текст и/или тратить средства с его аккаунта, а не с аккаунта Voximplant.
Наш модуль предусматривает два формата работы:
* создание исходящего соединения;
* прием входящего соединения и создание веб-сокета для него.
### Исходящее
Первое, что вам нужно сделать при создании исходящего соединения — это запустить сценарий VoxEngine. Затем вызвать метод [VoxEngine.createWebSocket](https://voximplant.com/docs/references/voxengine/voxengine/createwebsocket), который создаст объект [WebSocket](https://voximplant.com/docs/references/voxengine/websocket/websocket). Данный метод принимает 2 параметра: URL в формате 'wss: // + domain + path' и protocols (опционально). Вот как это будет выглядеть в коде:
```
VoxEngine.addEventListener(AppEvents.CallAlerting, function(e) {
const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_link/");
// Здесь вы можете обработать исходящее соединение
});
```
Если все сработало, метод [call.sendMediaTo](https://voximplant.com/docs/references/voxengine/call#sendmediato) направит аудиопоток в сокет, а [WebSocket.send](https://voximplant.com/docs/references/voxengine/websocket/websocket#send), в свою очередь, будет пересылать декодированный аудиопоток в формате JSON через него. В результате чего вам будут приходить сообщения от сервиса, обрабатывающего запросы.
Метод [WebSocket.close](https://voximplant.com/docs/references/voxengine/websocket/websocket#close) нужен, чтобы закрыть соединение. Обратите внимание, что соединение может быть закрыто как со стороны клиента, так и со стороны сервера.
### Входящее
Для того, чтобы разрешить входящие соединения, необходимо сообщить об этом через [VoxEngine.allowWebSocketConnections](https://voximplant.com/docs/references/voxengine/voxengine/allowwebsocketconnections), а также подписаться на событие [AppEvents.WebSocket](https://voximplant.com/docs/references/voxengine/appevents#websocket). После чего можно будет принять входящее соединение и получить объект WebSocket: event.WebSocket. Смотрите код ниже:
```
VoxEngine.allowWebSocketConnections();
VoxEngine.addEventListener(AppEvents.WebSocket, function(e) {
// Здесь вы можете обработать входящее соединение
});
```
Для создания входящего веб-сокета нужен управляющий accessSecureURL. Его можно взять из события [AppEvents.Started](https://voximplant.com/docs/references/voxengine/appevents#started) или ответа на HTTP-запрос, который запустил сессию. Обратите внимание, что «https» должно быть изменено на 'wss' в URL.
Остальные шаги идентичны представленным в схеме исходящего соединения.
Вам понадобятся
---------------
Чтобы заимплементить технологию WebSocket и распознавание речи в ваше приложение, вам понадобятся:
* аккаунт Voximplant. Если у вас его нет, смело регистрируйтесь по [ссылке](https://manage.voximplant.com/auth/sign_up);
* приложение Voximplant, а также сценарий, правило и один пользователь. Все это будет создано в данном туториале;
* простой бэкенд (мы запустим сервер на node.js) с подключенным Cloud client library для Speech-to-Text API;
* веб-клиент для совершения звонка (мы будем использовать вебфон на [phone.voximplant.com](https://phone.voximplant.com/)).
1. Настройки VOXIMPLANT
-----------------------
Для начала авторизуйтесь в вашем аккаунте на [manage.voximplant.com/auth](https://manage.voximplant.com/auth). В меню слева нажмите «Приложения», создайте новое и назовите его websocket. Зайдите в ваше приложение, переключитесь на вкладку «Сценарии», создайте сценарий и вставьте в него следующий код:
```
require(Modules.WebSocket);
VoxEngine.addEventListener(AppEvents.CallAlerting, function(e) {
call = e.call;
call.answer();
const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_ngrok_link/");
webSocket.addEventListener(WebSocketEvents.ERROR, function(e) {
Logger.write("LOG OUTGOING: WebSocketEvents.ERROR");
call.sendMessage("LOG OUTGOING: WebSocketEvents.ERROR");
});
webSocket.addEventListener(WebSocketEvents.CLOSE, function(e) {
Logger.write("LOG OUTGOING: WebSocketEvents.CLOSE: " + e.reason);
call.sendMessage("LOG OUTGOING: WebSocketEvents.CLOSE: " + e.reason);
});
webSocket.addEventListener(WebSocketEvents.OPEN, function(e) {
Logger.write("LOG OUTGOING: WebSocketEvents.OPEN");
Logger.write(JSON.stringify(e))
call.sendMessage("LOG OUTGOING: WebSocketEvents.OPEN");
});
webSocket.addEventListener(WebSocketEvents.MESSAGE, function(e) {
Logger.write("LOG OUTGOING: WebSocketEvents.MESSAGE: " + e.text);
call.sendMessage("LOG OUTGOING: WebSocketEvents.MESSAGE: " + e.text);
if (e.text == "Hi there, I am a WebSocket server") {
call.sendMediaTo(webSocket, {
encoding: WebSocketAudioEncoding.ULAW,
"tag": "MyAudioStream",
"customParameters": {
"param1": "12345"
}
});
}
});
call.addEventListener(CallEvents.Disconnected, function(e) {
Logger.write("LOG OUTGOING: terminating in 1 sec");
webSocket.close();
setTimeout(VoxEngine.terminate, 1000);
});
});
```
Этот сценарий VoxEngine отправляет аудиопоток в WebSocket, а также отслеживает его события (ERROR, CLOSE, OPEN, MESSAGE). Углубиться в детали сценария мы сможем немного позже.
А сейчас давайте перейдем на вкладку «Роутинг», нажмем «Новое правило» и назовем его socketRule. Теперь осталось лишь выбрать ваш сценарий, а маску оставить по умолчанию ( .\* ).
Последнее, что требуется сделать на данном этапе – создать пользователя. Переключитесь на вкладку «Пользователи», нажмите «Создать пользователя», укажите имя (например, socketUser) и пароль, затем кликните «Создать». Эта пара логин-пароль понадобится нам для аутентификации в веб-клиенте на последнем шаге.
Конфигурация завершена, но прежде чем приступить к созданию сервера, давайте рассмотрим, как работает модуль WebSocket в нашем сценарии.
2. Детали сценария
------------------
Модуль WebSocket позволяет разработчикам открывать устойчивое соединение и отправлять через него данные. Чтобы использовать этот модуль, мы должны подключить его в самом начале сценария:
```
require(Modules.WebSocket);
```
Через метод createWebSocket мы определяем URL-адрес и protocols (опционально). Вы можете узнать, как получить URL для WebSocket из следующего раздела.
```
const webSocket = VoxEngine.createWebSocket( /*url*/ "wss://your_ngrok_link/");
```
После создания объекта WebSocket мы продолжаем управление звонком внутри обработчика. А именно, отправляем медиа объекту WebSocket с помощью метода call.sendMediaTo.
Здесь можно установить предпочтительный формат кодировки, тэг и некоторые кастомные параметры. Если вы не установите кодировку, по умолчанию будет использоваться PCM8.
Данный метод вызывается, когда приходит [сообщение](https://voximplant.com/docs/references/voxengine/websocket/websocketevents#message) об успешном соединении. В нашем сценарии код вызова выглядит так:
```
call.sendMediaTo(webSocket, {
encoding: WebSocketAudioEncoding.ULAW,
"tag": "MyAudioStream",
"customParameters": {
"param1": "12345"
}
});
```
Все остальные события WebSocket, которые вы видите в коде, предназначены для отладки, они отправляют сведения в лог Voximplant-сессии. Вы можете убрать их, если хотите.
Наконец, мы добавляем правильный обработчик завершения передачи данных. В нашем случае сессия Voximplant закончит свою работу через 1 секунду после завершения установленного вызова ([Disconnected](https://voximplant.com/docs/references/voxengine/callevents#disconnected)):
```
call.addEventListener(CallEvents.Disconnected, function(e) {
Logger.write("LOG OUTGOING: terminating in 1 sec");
webSocket.close();
setTimeout(VoxEngine.terminate, 1000);
});
```
Теперь, когда логика сценария ясна, пришло время перейти к следующей, очень важной части нашего примера.
3. Backend
----------
Во-первых, убедитесь, что на вашем компьютере установлен Node.js. Скачать его можно с основного [сайта Node.js](https://nodejs.org/en/download/). Затем выполните следующие команды в окне терминала одну за другой, чтобы настроить рабочую среду:
```
npm install express
npm install ws
npm install @google-cloud/speech
```
А когда это будет сделано, создайте пустой JS-файл и поместите туда следующий код (нюансы кода будут освещены ниже):
```
const app = require('express')();
const http = require('http').createServer(app);
const WebSocket = require('ws');
const fs = require('fs');
const wss = new WebSocket.Server({
server: http
});
// Импортируем клиентскую библиотеку для Google Cloud
const speech = require('@google-cloud/speech');
// Создаем инстанс клиента
const client = new speech.SpeechClient();
const config = {
encoding: 'MULAW',
sampleRateHertz: 8000,
languageCode: 'ru-RU',
};
const request = {
config,
interimResults: true,
};
let audioInput = [];
let recognizeStream = null;
process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = 0;
app.get('/', function(req, res) {
res.send('Hello world
===========
');
});
wss.on('connection', (ws) => {
// Создаем поток, позволяющий сохранить переданные данные в файл
var wstream = fs.createWriteStream('myBinaryFile');
// Очищаем текущий audioInput
audioInput = [];
// Инициируем распознавание аудиопотока
recognizeStream = client
.streamingRecognize(request)
.on('error', err => {
ws.close();
})
.on('data', data => {
ws.send(data.results[0].alternatives[0].transcript)
process.stdout.write(
data.results[0] && data.results[0].alternatives[0] ?
`Transcription: ${data.results[0].alternatives[0].transcript}\n` :
`\n\nError occurred, press Ctrl+C\n`
)
});
ws.on('close', (message) => {
console.log('The time limit for speech recognition has been reached. Please disconnect and call again.');
wstream.end();
})
// Соединение установлено, добавляем логику для события message
ws.on('message', (message) => {
// Помещаем аудио в формате base64 в recognizeStream
try {
let data = JSON.parse(message)
if (data.event == "media") {
let b64data = data.media.payload;
let buff = new Buffer.from(b64data, 'base64');
recognizeStream.write(buff);
wstream.write(buff);
}
} catch (err) {
console.log(message)
}
});
// Отправляем уведомление об установке соединения
ws.send('Hi there, I am a WebSocket server');
});
http.listen(3000, function() {
console.log('listening on *:3000');
});
```
Теперь, когда сервер настроен, он поможет нам выполнить распознавание речи. Протестируйте свое решение локально, создав туннель на localhost 3000 с помощью ngrok.
Для этого выполните следующие действия:
1. Установите ngrok, следуя инструкциям на его [сайте](https://dashboard.ngrok.com/).
2. Укажите свой authtoken для ngrok, чтобы привязать клиента к этой учетной записи.
3. Выполните команду `node your_file_name.js`, чтобы запустить ваш сервер на localhost: 3000.
4. Перейдите в папку ngrok на вашем компьютере и выполните команду `./ngrok http 3000`, чтобы сделать туннель между работающим локальным сервером и публичным URL.
Обратите внимание на сгенерированный публичный URL, мы используем его в качестве WebSocket URL с префиксом 'wss' в сценарии:
4. Распознавание речи
---------------------
Вы наверняка заметили, что код нашего бэкенда содержит строки, относящиеся к Google Cloud.
Сама библиотека импортируется следующим образом:
```
const speech = require('@google-cloud/speech');
```
Теперь вам нужно указать, как обрабатывать запрос на распознавание речи. Для этого выберите encoding, sampleRateHertz и languageCode в создаваемом config:
```
const config = {
encoding: 'MULAW',
sampleRateHertz: 8000,
languageCode: 'en-US',
};
```
Далее, создайте поток на запись, позволяющий сохранить переданные данные в файл:
```
var wstream = fs.createWriteStream('myBinaryFile');
```
Когда все настроено, необходимо распарсить сообщение и поместить аудиоданные в формате base64 в recognizeStream:
```
let data = JSON.parse(message)
if (data.event == "media") {
b64data = data.media.payload;
let buff = new Buffer.from(b64data, 'base64');
recognizeStream.write(buff);
wstream.write(buff);
}
```
Сразу после этого будет инициирован запрос на распознавание и начнется обработка этого запроса:
```
recognizeStream = client
.streamingRecognize(request)
.on('data', data => {
ws.send(data.results[0].alternatives[0].transcript)
});
```
И наконец, предоставьте учетные данные вашего service account, чтобы подключить библиотеку Google к ее бэкенду. Для этого перейдите на [страницу аутентификации Google](https://cloud.google.com/docs/authentication/getting-started) и выполните все шаги, перечисленные там. Затем запустите команду экспорта в той же рабочей области (в той же вкладке «Терминал»), что и команду `node your_file_name.js:`
```
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/[FILE_NAME].json"
```
Запускаем сокеты
----------------
Откройте [phone.voximplant.com](https://phone.voximplant.com/), заполните форму и нажмите Sign in. Username и password относятся к пользователю, созданному на шаге 1:
После успешной авторизации нажмите Call и начните говорить. Облако Speech-to-Text будет преобразовывать вашу речь в текст в режиме реального времени, и вы сможете увидеть этот текст в окне терминала.
Вы справились, поздравляем! Надеемся, что статья пришлась вам по нраву, и желаем больше интеграций и новых челленджей.
 | https://habr.com/ru/post/476902/ | null | ru | null |
# SaltStack: Предварительная генерация паролей для использования в сервисах
##### **О чем статья?**
Короткая статейка о том, как сгенерировать пароли необходимые для разнообразных сервисов автоматически устанавливаемых с помощью SaltStack.
#### Трудности генерации паролей.
Очень часто приходится автоматически устанавливать сервисы или приложения, которые требуют указания паролей для доступов к каким-то своим частям (например, к web интерфейсу или к управлению своим API). Не менее часто приходится конфигурировать пользователей баз данных, которые будут затем использоваться в сервисах использующих эти базы и т. д.
Типичная проблема, — генерация паролей для всех подобных случаев. Есть несколько решений этой проблемы:
##### 1. Прописать пароли вручную в pillar файл
**pillar/passwords.sls**
```
service1:
web-access-password: '9KTE2aN11GYOJmZGOoqV'
db-access-password: '2pGbSlSFkHPY22TwqUus'
```
Ну и потом в любом другом пилларе или в стейте использовать указанные пароли для генерации доступов.
Все вроде бы нормально и понятно, — но есть одно **но** — если вы будете распространять стейт использующий указанный пиллар, то пароли будут сохраняться в том же неизменном виде. Мало того, — даже все однотипные серверы, для которых будут применен этот стейт будут иметь одинаковый пароль. Естественно нет смысла объяснять чем это может грозить с точки зрения информационной безопасности.
##### 2. Сгенерировать пароли средствами SaltStack.
Есть одна интересная ф-ция в SaltStack в модуле grains [get\_or\_set\_hash](http://docs.saltstack.com/en/latest/ref/modules/all/salt.modules.grains.html#salt.modules.grains.get_or_set_hash), которая может сгенерировать пароль для последующего использования определенного grain. Пароли получаются достаточно комплексными (из-за дефолтного набора символов, которые можно переопределить при вызове), использовать их в стейтах легко (просто считать соответствующий grain с миниона). Единственное, о чем стоит помнить, — генерация пароля происходит только при первом вызове этой ф-ции (и сам пароль помещается в /etc/salt/grains файл), все последующие — будут просто читать этот грейн из файла как если бы вызывался **salt['grains.get']('stored-password-grain-name')**.
Один из самых существенных недостатков этого способа — отсутствие возможности читать сгенерированные таким образом пароли в pillar файлах, что часто бывает полезно при использовании разнообразных формул ([SaltStack Formulas](https://github.com/saltstack-formulas)).
##### 3. Пред. генерация паролей в pillar файле.
Еще один способ, который я использую достаточно часто — предварительное генерирование паролей с помощью Jinja2.
В общем случае, для пред. генерации используется minion установленный на той же машине что и Salt Master. Если не хочется подключать такой minion к самому мастеру, можно воспользоваться [masterless](http://docs.saltstack.com/en/latest/topics/tutorials/quickstart.html) конфигурацией, но я предпочитаю использовать минион подключенным к мастеру, обозначив его grains:roles:local-minion и создав отдельную запись в конфигурации мастера:
**master/top.sls**
```
base:
'roles:local-minion':
- match: grain
- local-minion-state
```
Суть способа пред. генерации паролей заключается в том, чтобы создать jinja шаблон pillar файла с паролем(-лями) примерно такого вида:
**master/files/some-srv-password.sls.jinja2**
```
some-srv:
password: '{{salt['random.get_str'](30)}}'
```
тут используется ф-ция get\_str модуля [random](http://docs.saltstack.com/en/latest/ref/modules/all/salt.modules.mod_random.html).
Следующим шагом будет описание стейта для локального миниона, который генерирует pillar файл с паролями.
**master/local-minion-state.sls**
```
passwords-file:
file.managed:
- name: /srv/salt/pillar/some-srv-password.sls # или другое место, где pillar файлы могут быть считаны мастером
- source: salt://files/some-srv-password.sls.jinja2
- template: jinja
```
После этого, перед применением стейтов зависящих от наличия пред. генерированных паролей, запускаем описанный стейт:
```
~# salt-call --local state.sls local-minion-state # masterless
or
~# salt -C 'G@roles:local-minion' state.sls local-minion-state
```
После исполнения стейта, получим pillar файл содержащий сгенерированный пароль. Для его использования выполним include в другом pillar файле:
**pillar/some-srv.sls**
```
include:
- some-srv-password
some-srv:
username: Fred
. . .
```
В итоге, при запросе **salt 'minion-with-some-srv-pillar-connected' pillar.items** получим примерно такое:
```
pillar:
. . .
some-srv:
. . .
username:
Fred
password:
AoEK8u4Uvo_r9MKtooSUxZV1Y_DLoy
```
затем доступ к данным пароля можно получить простым вызовом **salt['pillar.get']('some-srv:password')**.
#### Заключение.
Из-за достаточно большой гибкости системы SaltStack решение этой задачи скорее всего не ограничивается только лишь 3-мя способами описанными в статье, — вполне возможно, что Вы придумаете не менее продуктивный и удобный способ.
В любом случае — надеюсь описанное в статье пригодится начинающим и не только пользователям SaltStack. Удачи! | https://habr.com/ru/post/254403/ | null | ru | null |
# Как правильно использовать Zend_Paginator
*Мой друг написал в песочнице статью, которая оказалась для меня (и не только) полезной, но через 7 дней была удалена. С его разрешения привожу её ниже. Если кому она тоже будет полезной, то он просит выслать ему инвайт на alxsad@gmail.com .*
Привет всем любителям Zend Framework. Хочу расказать как правильно использовать компонент Zend\_Paginator. Я очень часто видел, как плохо с ним работают некоторые программисты. Давайте посмотрим на код, представленный ниже:
> `$pages = new Model\_Pages();
>
> $paginator = Zend\_Paginator::factory($pages->getRows());
>
> $paginator->setItemCountPerPage(1);
>
> $paginator->setPageRange(1);
>
> $paginator->setCurrentPageNumber($this->getRequest()->getParam('page', 1));
>
> Zend\_Paginator::setDefaultScrollingStyle('Sliding');
>
> $this->view->pages = $paginator;
>
> $paginator->setView($this->view);
>
> Zend\_View\_Helper\_PaginationControl::setDefaultViewPartial('paginator.phtml');
>
> $this->view->paginator = $paginator;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Данный код я встречал на очень многих блогах, и даже, если не ошибаюсь, в самом мануале по Zend Framework. Давайте теперь посмотрим на запрос, который у нас получиться в результате:
Видите? Проблема заключается в том, что люди сразу забирают ВСЕ записи из базы данных, а потом уже из них выбирают нужные. Это огромная ошибка. Поэтому читаем как это делается
правильно.
Мы добавляем в модель таблицы данный метод:
> `public function getPaginatorRows ($pageNumber = 1)
>
> {
>
> $paginator = new Zend\_Paginator(new Zend\_Paginator\_Adapter\_DbSelect($this->select()));
>
> $paginator->setCurrentPageNumber($pageNumber);
>
> $paginator->setItemCountPerPage(1);
>
> $paginator->setPageRange(1);
>
> return $paginator;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
а потом в контроллере вызываем его:
> `$pages = new Model\_Pages();
>
> $this->view->pages = $pages->getPaginatorRows((int) $this->getRequest()->getParam('page', 1));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вуаля!
 | https://habr.com/ru/post/72399/ | null | ru | null |
# PC park observer — система учёта комплектующих компьютеров парка, базирующегося на MS Windows
#### Для чего эта система
Данная система предназначена для учёта комплектующих в компьютерном парке, базирующемся на Windows. Я выложил систему под GNU/GPL v. 3 лицензией, так что денег не прошу, можете использовать как угодно... Все пожелания и т.п. обсуждаются отдельно...
#### Особенности и возможности
Система работает под управлением ОС GNU Linux (на данный момент успешно обкатана на ubuntu 20.04). Система собирает информацию и создаёт оповещения в случае изменений в необходимых хостах (в частности информацию об:
* мак адрес сетевого адаптера
* ip адрес
* имя хоста
* информацию о мат. плате (по возможности и её серийный номер)
* информацию о процессоре (по возможности и её серийный номер)
* информацию об оперативной памяти (по возможности серийный номер, тип памяти - ECC или не ECC, объём)
* видеоадаптер (с указанием PNP Device id)
* жёсткие диски (можно опционально включить проверку тех, что подключены по USB или iSCSI) - серийный номер, модель, объём).
Система позволяет производить анализ изменений, а также выгрузку данных в различные форматы и т.п.
---
Доступ к системе регулируется на основе двух ролей - администраторов (могут менять системные настройки и менять перечень проверяемых сетей/хостов); менеджеров - могут только просматривать аналитику и данные по хостам.
#### Реальные кейсы применения
1. Воруют периодически железо - если настроить обходчик на довольно частый период, то можно вполне поймать вора (так уже было обкатано и к товарищам полиционерам система отправила свою пачку не честных на руку граждан). В этом случае одной данной системы мало, лучше ещё запастись системой видео наблюдения и/или СКУДом...
2. Надо держать актуализированную информацию о железе в парке конторы, т.к. бывает её запрашивает бухгалтерия.
3. Контролировать непонятные периодически возникающие на хостах флешки. На практике можно засечь, что кто-то периодически использует флешки со всякими странными метками в стиле kali linux :).
На текущий момент, в одной крупной сети система работает вне пределов проверяемой сети, так что админы, кои управляют данной сетью в сути не могут повлиять на данные, находящиеся в БД системы. Для такого достаточно виртуалку с данной системой расположить ~~у себя на балконе~~ на каком-нибудь хостинге и пробросить VPN до проверяемой сети. **При этом на клиентских машинах ничего устанавливать НЕ НУЖНО.** Единственными условиями успеха проверки выступают открытый 135 tcp порт на проверяемых машинках и ваше знание о паре логина/пароля для авторизации на них. **В реальном кейсе, на текущий момент обход и сбор информации с 370 хостов производится примерно за 2 минуты с тонко подкрученными настройками.**
#### Как всё пашет под капотом
1. Запускается nmap, в который передаются для проверки необходимые сети/хосты (к примеру 192.168.0.0/24 и заодно отдельно скажем проверить 192.168.22.2/32).
2. Nmap быстренько проверяет открытость портов по указанным диапазонам и формирует список "живых" хостов.
3. Далее по живым хостам начинается сбор информации о железе и прочем через протокол WMI.
4. Если не получилось в ходе забора информации с хоста получить данные (ну может отключили компик именно в это время), то он помечается как недоступный и съём инфы идёт дальше.
5. По мере получения инфы с хостов они сразу заносятся в БД и сопоставляются с ранее полученными данными по данному хосту. **Опорной точкой сравнения является MAC адрес сетевого адаптера хоста**.
6. По желанию в случае появления информации о новых, изменённых хостах может формироваться отправка сообщения о событии в телеграм (для этого нужно вам будет завести бота и выяснить id чата, куда кидать уведомления).
7. Также по желанию может быть сформирован сводный отчёт, который полетит на почту.
#### Минимальные системные требования
Вполне подойдёт виртуалка со скромными параметрами (скажем пара ядер на проце, хотя бы 1024 мгб ОЗУ и места на диске гигов так в 15).
#### Установка
Перед установкой на боевую машинку достаточно на ней сконфигурировать правильно сеть, после чего:
```
sudo -s
wget https://raw.githubusercontent.com/constantinekg/pcpo/main/doc/INSTALL.txt -O install.sh && chmod +x install.sh && ./install.sh
```
#### Первоначальная настройка
Администратор по умолчанию:
login: pcpoadmin
password: pcpoadmin1
Перед первым запуском необходимо войти в систему, открыв в браузере айпишник/доменное имя машинки, на которую была произведена установка. Далее перейти в раздел Настройки->Проверяемые сети/хосты и добавить необходимые диапазоны с указанием логина-пароля:
Далее идём в командную строку и выполняем первую проверку:
```
root@pcpo:~# /opt/pcpo/scanner/rerun.sh
```
По результату проверки можем зайти в аналитику и просмотреть полученную информацию:
Как только первая проверка завершится - можем идти в системные настройки и выставлять там параметры согласно нашим пожеланиям. На данном этапе можно настроить отсылку сообщений в телеграм, отчётов на почту, параметров проверки и т.п.
После того, как все настройки будут выставлены - мы можем запланировать проверку на периодическую основу. Для этого откроем crontab (crontab -e) и добавим примерно такое:
```
#exec main data fetching process
3 */1 * * * /opt/pcpo/scanner/rerun.sh
```
Такая строчка позволит нам начинать проверку каждую третью минуту каждого часа.
#### Ресурсы
[Проект на гитхабе](https://github.com/constantinekg/pcpo)
[Готовый образ машины в формате qcow2](https://cloud.mail.ru/public/1EkR/b3DGfh2de) | https://habr.com/ru/post/570190/ | null | ru | null |
# MongoDB Sharded Cluster на Centos 6.5
В этой статье мы рассмотрим только конфигурацию MongoDB, не затрагивая вопросы подключения репозитория монги и установки пакетов в систему.
Распределенный кластер MongoDB состоит из следующих компонентов:
**Шард**
Шард — это инстанс mongod, который хранит часть данных шардированной коллекции. Для использования в production, каждый шард должен быть набором реплик (replicaSet).
**Сервер конфигураций**
Так же экземпляр mongod, который хранит метаданные кластера. Метаданные указывают какие данные хранятся на каком шарде.
**Сервер маршрутизации**
Экземпляр mongos. Его задача — маршрутизация запросов от приложений к шардам.
Ниже приведена схема работы шардированного кластера MongoDB
Удобнее всего необходимые роли группировать следующим образом:
* Сервер конфигурации + сервер маршрутизации
* Шард
Допустим, для создания этих ролей мы имеем 3 сервера:
* mongos01
* mongos02
* mongos03
##### Настройка сервера конфигураций
Для того, что бы mongod работал как сервер конфигураций, приводим */etc/mongod.conf* к следующему виду:
```
logpath=/var/log/mongodb/mongod.log
logappend=true
fork=true
dbpath=/opt/mongocfg
pidfilepath=/var/run/mongodb/mongod.pid
bind_ip=,
configsvr=false
```
После чего запускаем сервис
> # service mongod start
>
>
##### Настройка сервера маршрутизации
Прежде чем переходить к настройке сервера маршрутизации, необходимо убедиться что в системе установлен пакет mongodb-org-mongos
> # rpm -qa | grep mongos
>
> mongodb-org-mongos-2.6.2-1.x86\_64
>
>
Для начала, создадим файл конфигурации для сервиса mongos */etc/mongos.conf* и приведем его к следующему виду:
```
configdb=mongos01:27019,mongos02:27019,mongos03:27019 # Mongo config servers addresses
port = 27017
logpath = /var/log/mongodb/mongos.log
logappend = true
fork = true
bind_ip=,
verbose = false
```
Mongo не включили в свой пакет init script для mongos, посему создадим его
```
cat > /etc/init.d/mongos << TheEnd
#!/bin/bash
# mongos - Startup script for mongos
# chkconfig: 35 85 15
# description: Mongo Router Process for sharding
# processname: mongos
# config: /etc/mongos.conf
# pidfile: /var/run/mongos.pid
. /etc/rc.d/init.d/functions
# mongos will read mongos.conf for configuration settings
# Add variable to support multiple instances of mongos
# The instance name is by default the name of this init script
# In this way another instance can be created by just copying this init script
# and creating a config file with the same name and a .conf extension
# For Example:
# /etc/init.d/mongos2
# /etc/mongos2.conf
# Optionally also create a sysconfig file to override env variables below
# /etc/sysconfig/mongos2
INSTANCE=`basename $0`
# By default OPTIONS just points to the /etc/mongod.conf config file
# This can be overriden in /etc/sysconfig/mongod
OPTIONS=" -f /etc/${INSTANCE}.conf"
PID_PATH=/var/run/mongo
PID_FILE=${PID_PATH}/${INSTANCE}.pid
MONGO_BIN=/usr/bin/mongos
MONGO_USER=mongod
MONGO_GROUP=mongod
MONGO_ULIMIT=12000
MONGO_LOCK_FILE=/var/lock/subsys/${INSTANCE}
# Source sysconfig options so that above values can be overriden
SYSCONFIG="/etc/sysconfig/${INSTANCE}"
if [ -f "$SYSCONFIG" ]; then
. "$SYSCONFIG" || true
fi
# Create mongo pids path if it does not exist
if [ ! -d "${PID_PATH}" ]; then
mkdir -p "${PID_PATH}"
chown "${MONGO_USER}:${MONGO_GROUP}" "${PID_PATH}"
fi
start()
{
echo -n $"Starting ${INSTANCE}: "
daemon --user "$MONGO_USER" --pidfile $PID_FILE $MONGO_BIN $OPTIONS --pidfilepath=$PID_FILE
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch $MONGO_LOCK_FILE
return $RETVAL
}
stop()
{
echo -n $"Stopping ${INSTANCE}: "
killproc -p $PID_FILE -t30 -TERM $MONGO_BIN
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f $MONGO_LOCK_FILE
[ $RETVAL -eq 0 ] && rm -f $PID_FILE
return $RETVAL
}
restart () {
stop
start
}
ulimit -n $MONGO_ULIMIT
RETVAL=0
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload|force-reload)
restart
;;
condrestart)
[ -f $MONGO_LOCK_FILE ] && restart || :
;;
status)
status -p $PID_FILE $MONGO_BIN
RETVAL=$?
;;
*)
echo "Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"
RETVAL=1
esac
exit $RETVAL
TheEnd
```
Сделаем его исполняемым
> chmod +x /etc/init.d/mongos
Теперь можно запускать
service mongos start
И не забыть
```
# chkconfig mongod on
# chkconfig mongos on
```
Теперь нужно повторить эти действия на остальных серверах.
##### Настройка шардов
Первое что необходимо помнить при настройке шардов для production среды — каждый шард это replica set.
Более подробно про репликацию в MongoDB можно прочесть в [официальной документации](http://docs.mongodb.org/manual/core/replication-introduction/)
Мы же не будем на этом подробно останавливаться, а приступим к настройке.
У нас будет 4 сервера:
* Master для первого шарда (mongo01-rs01)
* Slave для первого шарда (mongo02-rs01)
* Master для второго шарда (mongo01-rs02)
* Slave для второго шарда (mongo02-rs02)
Допустим, на всех четырех серверах уже установлена система и установлен mongodb
В */etc/mongodb.conf* на mongo01-rs01 и mongo02-rs01 нужно задать имя для набора реплик, которое будет использовать этот шард
```
replSet=rs01
```
Сохраняем и запускаем mongod.
Далее заходим в консоль mongo на сервере который планируем сделать Master
> # mongo
И инициализируем набор реплик
> > rs.initiate()
Что бы убедиться что набор реплик инициализирован посмотрим его конфиг
> rs01:PRIMARY> rs.conf()
Вывод должен показать что-то подобное:
```
{
"_id" : "rs01",
"version" : 7,
"members" : [
{
"_id" : 0,
"host" : "mongo01-rs01:27017"
}
]
}
```
Далее добавляем наш второй сервер в этот набор
> rs01:PRIMARY> rs.add(«mongo02-rs01»)
И проверяем конфиг
> rs01:PRIMARY> rs.conf()
```
{
"_id" : "rs01",
"version" : 7,
"members" : [
{
"_id" : 0,
"host" : "mongo01-rs01:27017"
},
{
"_id" : 1,
"host" : "mongo02-rs01:27017",
}
]
}
```
Для повышения отказоустойчивости MongoDB рекомендуется количество машин в наборе делать не четным.
Так как мы не хотим создавать еще одну копию данных, мы можем создать *Арбитра*
**Арбитр** — это экземпляр mongod, который является членом набора реплик, но не хранит никаких данных. Он участвует в выборе нового мастера.
Про то как устроены выборы, очень подробно написано в [официальной документации](http://docs.mongodb.org/manual/core/replica-set-elections/#replica-set-elections)
Для того, чтобы не выделять под него отдельную машину — воспользуемся одной из ранее созданных — mongos01
Как мы помним, там по *service mongod start* запускается экземпляр mongod который является сервером конфигураций.
Что бы не запускать арбитра руками мы должны сделать для него init script
```
cat > /etc/init.d/mongo-rs01-arb << TheEnd
#!/bin/bash
# mongod - Startup script for mongod
# chkconfig: 35 85 15
# description: Mongo is a scalable, document-oriented database.
# processname: mongod
# config: /etc/mongod.conf
# pidfile: /var/run/mongodb/mongod.pid
. /etc/rc.d/init.d/functions
# things from mongod.conf get there by mongod reading it
# NOTE: if you change any OPTIONS here, you get what you pay for:
# this script assumes all options are in the config file.
CONFIGFILE="/etc/mongod-rs01-arb.conf"
OPTIONS=" -f $CONFIGFILE"
SYSCONFIG="/etc/sysconfig/mongod-rs01-arb"
# FIXME: 1.9.x has a --shutdown flag that parses the config file and
# shuts down the correct running pid, but that's unavailable in 1.8
# for now. This can go away when this script stops supporting 1.8.
DBPATH=`awk -F= '/^dbpath[[:blank:]]*=[[:blank:]]*/{print $2}' "$CONFIGFILE"`
PIDFILE=`awk -F= '/^pidfilepath[[:blank:]]*=[[:blank:]]*/{print $2}' "$CONFIGFILE"`
mongod=${MONGOD-/usr/bin/mongod}
MONGO_USER=mongod
MONGO_GROUP=mongod
if [ -f "$SYSCONFIG" ]; then
. "$SYSCONFIG"
fi
# Handle NUMA access to CPUs (SERVER-3574)
# This verifies the existence of numactl as well as testing that the command works
NUMACTL_ARGS="--interleave=all"
if which numactl >/dev/null 2>/dev/null && numactl $NUMACTL_ARGS ls / >/dev/null 2>/dev/null
then
NUMACTL="numactl $NUMACTL_ARGS"
else
NUMACTL=""
fi
start()
{
# Recommended ulimit values for mongod or mongos
# See http://docs.mongodb.org/manual/reference/ulimit/#recommended-settings
#
ulimit -f unlimited
ulimit -t unlimited
ulimit -v unlimited
ulimit -n 64000
ulimit -m unlimited
ulimit -u 32000
echo -n $"Starting mongod: "
daemon --user "$MONGO_USER" "$NUMACTL $mongod $OPTIONS >/dev/null 2>&1"
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/mongod-rs01-arb
}
stop()
{
echo -n $"Stopping mongod: "
killproc -p "$PIDFILE" -d 300 /usr/bin/mongod
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/mongod-rs01-arb
}
restart () {
stop
start
}
RETVAL=0
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload|force-reload)
restart
;;
condrestart)
[ -f /var/lock/subsys/mongod ] && restart || :
;;
status)
status $mongod
RETVAL=$?
;;
*)
echo "Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"
RETVAL=1
esac
exit $RETVAL
TheEnd
```
Делаем его исполняемым
> # chmod+x /etc/init.d/mongo-rs01-arb
Создадим для него BaseDir и файл конфигурации
> # mkdir /opt/mongo-rs01-arb; chown mongod:mongod /opt/mongo-rs01-arb
>
> # cp -av /etc/mongod.conf /etc/mongod-rs01-arb.conf
Далее в файле */etc/mongod-rs01-arb.conf* редактируем следующие строки
```
port=27020
dbpath=/opt/mongo-rs01-arb
pidfilepath=/var/run/mongodb/mongod-rs01-arb.pid
```
И удаляем/комментируем строку
```
configsvr=true
```
Сохраняем файл и запускаем сервис
> # service mongo-rs01-arb start
Далее возвращаемся на наш Master для rs01, и в консоли mongo добавляем арбитра в набор реплик
> > rs.addArb(«mongos01:27020»)
Проверяем конфиг
> rs01:PRIMARY> rs.conf()
```
{
"_id" : "rs01",
"version" : 7,
"members" : [
{
"_id" : 0,
"host" : "mongo01-rs01:27017"
},
{
"_id" : 1,
"host" : "mongo02-rs01:27017",
},
{
"_id" : 2,
"host" : "mongos01:27020",
"arbiterOnly" : true
}
]
}
```
Повторяем эту процедуру с оставшимися двумя серверами под второй набор реплик который будет вторым шардом в нашем кластере (mongo01-rs02 и mongo02-rs02)
И так, мы создали 2 набора реплик, которые теперь надо добавить в наш распределенный кластер.
Для этого идем на mongos01 и заходим в консоль mongo (Следует помнить, что, в данном случае, мы подключаемся к сервису mongos)
> > sh.addShard(«rs01//mongo01-rs01:27017,mongo02-rs01:27017»)
>
> > sh.addShard(«rs02/mongo01-rs02:27017,mongo02-rs02:27017»)
Проверяем:
> > sh.status()
Вывод должен содержать следующие строки:
```
shards:
{ "_id" : "rs01", "host" : "rs01/mongo01-rs01:27017,mongo02-rs01:27017" }
{ "_id" : "rs02", "host" : "rs02/mongo01-rs02:27017,mongo02-rs02:27017" }
```
Это означает что в наш кластер успешно добавлены 2 шарда
Теперь добавим в наш распределенный кластер базу которую будем шардировать.
В нашем случае это будет база содержащая файловую систему GridFS
> > use filestore
>
> > sh.enableSharding(«filestore»)
>
> > sh.shardCollection(«filestore.fs.chunks», { files\_id: 1, n: 1 })
Проверяем статус
> > sh.status()
Вывод должен быть примерно таким:
```
shards:
{ "_id" : "rs01", "host" : "rs01/mongo01-rs01:27017,mongo02-rs01:27017" }
{ "_id" : "rs02", "host" : "rs02/mongo01-rs02:27017,mongo02-rs02:27017"}
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : false, "primary" : "rs02" }
{ "_id" : "filestore", "partitioned" : true, "primary" : "rs01" }
filestore.fs.chunks
shard key: { "files_id" : 1, "n" : 1 }
chunks:
rs01 1363
rs02 103
too many chunks to print, use verbose if you want to force print
```
Вот и все, теперь можем использовать наш распределенный GridFS в приложении обращаясь к экземплярам mongos
PS: про ошибки и не точности просьба писать в личку, | https://habr.com/ru/post/227395/ | null | ru | null |
# Agent Workspace configuration guide в ServiceNow - краткий обзор по конфигурации для администратора
Что такое Agent Workspace и необходимые для пространства роли?
--------------------------------------------------------------
Прежде всего, насчёт актуальности информации по версии инстанса: на момент написания этой статьи для примера используется инстанс с версией апгрейда **Rome**.
В ServiceNow Agent Workspace представляет собой рабочее пространство, в котором можно кастомизировать и настроить практически всё под любые типы задач. Есть заранее подготовленные рабочие области следующих типажей:
1. IT Service Management
2. Customer Service Management
3. Request Management
4. HR Service Delivery
Вкратце об Agent Workspace можно сказать следующее: здесь пользователи могут быстро находить, просматривать, проверять и брать в работу любые кейсы, оставаясь при этом на одной вкладке браузера.
Для чего нужен Agent Workspace? Для того, чтобы повышать прозрачность в работе пользователей и иметь возможность увидеть проблемы и инциденты в реальном времени.
Чтобы активировать рабочую среду Agent Workspace, необходимо включить плагин в System Definition – Plugins от пользователя с ролью администратора инстанса.
Agent Workspace содержит в себе те же функции, что и интерфейс UI16, но в несколько другом расположении: тут точно так же можно сортировать столбцы, фильтровать записи по значению поля, редактировать списки, добавлять многоуровневые фильтры при поиске среди записей и т. д.
Для доступа к рабочей среде Agent Workspace необходима одна из следующих ролей (помимо главного администратора):
| | |
| --- | --- |
| Роль | Описание |
| **workspace\_admin** (содержит в себе: form\_admin, chat\_admin, template\_editor, ui\_action\_admin, personalize\_form, interaction\_admin, workspace\_list\_admin; ) | Предоставляет доступ к приложению и модулям для конфигурации и изменения рабочей среды Agent Workspace и её отображения для других пользователей. |
| **workspace\_list\_admin** (содержит в себе agent\_workspace\_user) | Позволяет создавать категории списков, создавать и назначать отфильтрованные списки на отображение в Agent Workspace – Lists. Данная роль повышается в elevated role. |
| **agent\_workspace\_user** (данная роль присутствует в ролях itil (ITSM) и sn\_esm\_agent(CSM) ) | Предоставляет пользователю доступ в Agent Workspace UI. |
---
Краткий обзор концепта и функционала Agent Workspace
----------------------------------------------------
Найти Agent Workspace в инстансе довольно просто, достаточно вбить **Agent Workspace** в поиск в фильтр-навигаторе либо по ссылке инстанса:
`https://<инстанс>.service-now.com/now/workspace/agent/home`
Расположение "Agent Workspace" в Filter NavigatorГлавная страница "Agent Workspace" при первом открытииВсе элементы в пределах пространства Agent Workspace можно полностью кастомизировать под свою необходимость.
В правом верхнем углу рабочего пространства находятся уведомления и глобальный поиск.
Глобальный поиск в пространстве "Agent Workspace"Сбоку слева располагаются основные кнопки: **home**, **lists**, **analytics center**, **inbox** – в зависимости от того, какие из них включены в настройках отображения.
Все рабочие записи находятся во второй вкладке – **lists** (cases, incidents, problem и т. д.), и что именно за списки будут отображены разным пользователям, точно так же можно настраивать, как и в интерфейсе UI16 –создавать новые списки либо изменять уже существующие.
Расположение "Списков" в Agent WorkspaceТакже имеется возможность создать запись прямо с вкладки Lists с помощью **Add Interaction**:
Создание "новой записи" через "Add Interaction"С апгрейда по версии Rome вкладка **Lists** выглядит следующим образом:
Разделение на элементы в "Agent Workspace"В самом хэдере каждой записи есть возможность добавлять тэги:
Возможность добавления тэгов для записи
---
Конфигурация Agent Workspace
----------------------------
Для текущего пользователя можно отдельно включить/отключить отображение некоторых элементов, не затрагивая отображение для всех остальных пользователей, через **Settings** в верхней кнопке user menu.
Отображение элементов для текущего пользователяЧтобы настроить отображение для остальных пользователей, необходимо воспользоваться **Configure Workspace** либо **Configure Page** (необходимая роль - workspace\_admin).
Настройка отображения для всех пользователейТак, к примеру, Configure Page – **Form Layout** подойдет для настройки отображения конкретных полей для секций на самой форме:
Настройка общего отображения через Form LayoutА Configure page – **Related Lists** откроет страницу для настройки отображаемых внутренних вкладок внизу формы, где Selected - выбранные для отображения вкладки секции Related Items Menu на форме.
Отображение вкладок Related Lists для формы записей в Agent WorkspaceОстальные возможности **Configure Page** открывают следующие таблицы в пространстве UI16, но с разными фильтрами:
1. **UI Actions** (sys\_ui\_action.list)
2. **Ribbon** (sys\_aw\_ribbon\_setting.list)
3. **Related Items** (sys\_declarative\_action\_assignment.list)
4. **Contextual Side Panel** (sys\_declarative\_action\_assignment.list)
**Configure Workspace** позволяет кастомизировать страницы, компоненты, логотип, хэдер и другие объекты в рабочем пространстве:
Пример тестовой кастомизации среды Agent Workspace для наглядностиС помощью **Open in UI Builder** можно перейти к настройке внешнего вида страниц Agent Workspace и видоизменить компоненты на них:
Редактирование элементов и страниц Agent Workspace в "Ui Builder"К примеру, теперь главная страница данного пространства Agent Workspace будет выглядеть так:
Пример кастомизированной главной страницы в Agent WorkspaceПри открытии Configure Workspace в самом низу в Related lists имеются следующие возможности:
1. Настроить отображение списков в Lists (**Workspace Lists**)
2. Удалить или редактировать тэги для страниц в Home (**Landing Pages** - полноценное редактирование через UI Builder)
3. Изменить таблицу для кнопки Add Interaction (**New Record Menu Items**)
4. Изменить отображение основных кнопок слева в пространстве Agent Workspace (**Workspace Modules**)
Возможности в "Configure Workspace"
Для настройки отображения списков в Lists необходимая минимальная роль - workspace\_list\_admin. В списках есть возможность создавать новые или изменять существующие категории (sys\_aw\_list\_category.list).
Категории списков в Agent WorkspaceЧтобы изменить или создать именно новые списки в Lists, понадобится таблица Workspace Lists (sys\_aw\_list.list).
Таблица для изменения или создания новых списков в Agent WorkspaceПри создании списка всегда важно учитывать поле order, т. к. от него зависит, в каком порядке он отобразится во вкладке Lists.
Пример создания нового списка для вкладки "Lists"Пример отображения нового списка в "Lists"
---
Итог и быстрый взгляд на плагины и компоненты
---------------------------------------------
В ServiceNow также имеются плагины и для других рабочих пространств, имеющие заранее подготовленные настройки конфигурации, для работы с ними их необходимо установить. Такими, например, являются:
* CMDB (**cmdb-workspace**)
* Customer Service Management (**snc.agent\_workspace.csm**)
* HR Services (**sn\_hr\_agent\_workspace**)
* IT Service Management (**snc.agent\_workspace.itsm**)
* Operational Intelligence (**oi-scoped-app**)
* Security Incident Response (**sn\_app\_secops\_ui**)
А также дополнительные плагины конкретно для рабочей среды Agent Workspace:
* Advanced Work Assignment [**com.glide.awa**]
* Agent Chat [**com.glide.interaction.awa**]
* Openframe [**com.sn\_openframe**]
Дополнительные плагины для Agent Workspace предоставляют возможность пользователю связаться с «агентом» поддержки инстанса с помощью прямого чата (Agent Chat), встроить возможность «почты» прямо в Agent Workspace и подключить много других полезных функций.
В среде Agent Workspace можно не только создать кастомизированную целевую страницу, но и создавать собственные компоненты в зависимости от нужд клиента - от встраивания интеграции с внешними программами прямо из рабочего пространства инстанса до просто немного видоизмененных компонентов вроде Agent Assist. Для этого в Service Now существуют Now-компоненты, включающие в себя контейнеры, выдвижные списки, компоненты для аналитики производительности или визуализацию отчетных данных и множество других элементов, которые можно найти по ссылке ниже:
<https://developer.servicenow.com/dev.do#!/reference/now-experience/components>
Страница для поиска информации по конкретным элементам для Agent Workspace и их видоизменениюНа странице с компонентами находится возможность просмотреть и интерактивно изменить их код под свои нужды, после чего использовать его для девелопинга видоизмененного компонента для ServiceNow в том же Visual Studio Code или с помощью Node.js (но это отдельная большая тема, в которую в данной статье сильно углубляться уже не станем). Для деплоинга своих компонентов останется только подключиться через Visual Studio Code к инстансу и произвести now-cli команду деплоя. Все необходимые инструкции по now-cli можно найти также здесь:
<https://developer.servicenow.com/dev.do#!/reference/now-experience/rome/cli/getting-started>
Страница с более подробным гайдом по написанию более сложных кастомных элементовБлагодаря Now-компонентам можно полностью контролировать визуализацию страницы в среде Agent Workspace.
Все эти компоненты можно добавить на страницу формы записи в Agent Workspace в любое место, где это вам необходимо (в моем случае мы однажды добавляли видоизмененный Agent Assist-компонент с интеграцией для MS Teams, чтобы пользователь мог найти экспертов по своему вопросу и увидеть, онлайн ли они, либо в какой период будут на связи. Самым сложным было именно разобраться с деплоингом в инстанс и подключением к нему безопасными методами по всем best practices, так как секьюрность данных клиента - всегда на первом месте).
Создание отдельных компонентов для Agent Workspace – достаточно обширная тема, но если коснуться её хотя бы вкратце, всегда надо помнить про безопасность кода (храните все константы, ссылки и любые конкретные данные в таблице sys\_properties на инстансе, в коде только ссылайтесь константами на место, где оно хранится). Всегда оставляйте комментарии в коде для коллег, которым однажды может понадобиться работать с вашим компонентом. Всегда уточняйте возможность действий с данным компонентом, прежде чем задеплоить его на инстанс, чтобы не нарушить работу других компонентов на инстансе, о которых вы можете не знать.
Подводя итог, из личного опыта скажу: работа с кастомизацией Agent Workspace сначала может показаться чем-то страшным и непонятным. Где и что менять? Можно ли обойтись уже имеющимися в ServiceNow решениями? Связаны ли с Workspace какие-то конкретные таблицы для изменения компонентов без хардкодинга? Однако, как и с любой другой практикой, главное - начать, пробовать делать что-то самостоятельно и углубляться в изучение. Чем больше пробуешь, тем больше знаешь и разбираешься в данном вопросе, и работа с AgentWorkspace - не исключение. | https://habr.com/ru/post/593687/ | null | ru | null |
# Дизассемблируем циклы, написанные на Си
Доброго времени суток.
Сегодня мы будем смотреть дизассемблированный код инструкций `if, for, while, switch`, которые написаны на языке Си.
1605795529033.pngИнcтрукция if
-------------
Данную инструкцию довольно просто отличить в дизассемблированном виде от других инструкций. Её отличительное свойство - одиночные инструкции условного перехода je, jne и другие команды jump.
1605790962062.png1605790989407.pngНапишем небольшую программу на языке Си и дизассемблируем её с помощью radare2. Разницы между IDA PRO и radare2 при дизассемблировании этих программ не было обнаружено, поэтому я воспользуюсь radare2. Вы можете использовать IDA PRO.
### IDA PRO
2020-11-17\_08-22.png2020-11-17\_08-23.png### radare2
1605792900362.png### Код на Си
```
#include
void main() {
int x = 1;
int y = 2;
if(x == y) {
printf("x = y\n");
}
else{
printf("x != y\n");
}
}
```
Компилируем при помощи gcc. Команда `gcc -m32 prog_if.c -o prog_if`. -m32 означает, что компилироваться код будет под архитектуру x86.
Чтобы посмотреть на код в radare2, напишем команду `r2 prog_if`. Далее прописываем `aaa` для анализа кода и переходим к функции main `s main`. Посмотрим на код с помощью команды `pdf`.
### Дизассемблированный вариант в radare2
1605792900362.pngПервым делом в программе происходит объявление переменных ( int x; int y ), а затем значение **1** перемещается в var\_*ch (это переменная x) и значение* ***2*** *в var*10h (это переменная y). Далее идёт сравнение (cmp) **1 и 2** (`cmp edx, dword [var_10h]`). Эти значения не равны. Значит jne ( jump if not equal) перейдёт по адресу 0x000011e1. Проще всего инструкцию if запомнить и определить в режиме графов (команда `VV` для для radare2 или клавиша пробел для IDA).
### Режим графов
1605792914861.pngНемного усложним задачу. Добавим вложенные инструкции. Попробуйте проанализировать этот код.
### Код на Си
```
#include
void main() {
int x = 0;
int y = 1;
int z = 2;
if(x == y) {
if(z == 0) {
printf("z = 0; x = y\n");
}
else{
printf("z = 0; x != y\n");
}
}
else {
if(z == 0) {
printf("z = zero and x != y.\n");
} else {
printf("z non-zero and x != y.\n");
}
}
}
```
### Дизассемблированный вариант в radare2
1605792935104.png### Режим графов
1605792950680.pngВ режиме графов это воспринимать намного проще.
Инструкция for
--------------
Циклы for всегда состоят из четырех этапов: инициализации, сравнения, выполнения инструкций и инкремента/декремента. По этим этапам мы будем отличать цикл for в ассемблерном коде от других.
### Код на Си
```
#include
void main() {
int x;
for(x = 0; x < 100; x++) {
printf("x = %d", x);
}
}
```
### Дизассемблированный вариант в radare2
1605792973718.png1 - инициализации переменной var\_*ch (x = 0)
2 - сравнение, а затем jle. ( пока x не будет меньше или равен 2, выполнять цикл.)
3 - выполнения инструкций (printf)
4 - инкремент переменной var\_*ch (++x)
### Режим графов
1605792987678.pngИнструкция while
----------------
Цикл while часто используется при ожидании, пока не будет выполнено какое-то условие, например получение команды или пакета. В ассемблере циклы while похожи на for, но их легче понять. В ассемблере это выражение похоже на цикл for, но инкремента может и не быть.
### Код на Си
```
#include
int func\_1(int x);
int change\_status();
int main() {
int status = 0;
while(status == 0) {
printf("int e = %d", func\_1(5) );
status = change\_status();
}
return 0;
}
int change\_status() {
return 1;
}
int func\_1(int x) {
int c;
int e;
int l;
c = 1 + 2;
e = x / 5;
l = 4 - 2;
return e;
}
```
### Дизассемблированный вариант в radare2
1605793002542.png1 - инициализации переменной var\_*4h (status = 0)
2 - сравнение, а затем je. ( пока x равен 0, выполнять цикл.)
3 - выполнения инструкций (func*1, printf, change\_status)
### Режим графов
1605793019409.pngИнструкция switch
-----------------
Конструкция switch обычно компилируется двумя способами: по примеру условного выражения или как таблица переходов.
Компиляция по примеру условного выражения
-----------------------------------------
### Код на Си
```
#include
int main() {
int i = 3;
switch(i) {
case 1:
printf("CASE\_1 i = %d", i+4);
break;
case 2:
printf("CASE\_2 i = %d", i+9);
break;
case 3:
printf("CASE\_3 i = %d", i+14);
break;
}
return 0;
}
```
### Дизассемблированный вариант в radare2
1605793045836.png1 - инициализации переменной var\_4h (i = 3)
2 - выполнения инструкций (add, printf)
Чтобы понять какой "case" выбран, происходит сравнение (cmp, а затем je, jne) переменной i с значением case.
### Режим графов
1605793347813.pngscreen13.pngscreen\_13\_2.pngГлядя на этот код, сложно (если вообще возможно) сказать, что представлял собой оригинальный исходный текст — конструкцию switch или последовательность выражений if . В обоих случаях код выглядит одинаково, поскольку оба выражения используют множество инструкций cmp и je или jne.
Таблица переходов
-----------------
Следующий пример ассемблерного кода часто можно встретить в больших смежных выражениях switch. Мы добавим case 4 и инструкцию по умолчанию.
### Код на Си
```
#include
int main() {
int i = 3;
switch(i) {
case 1:
printf("CASE\_1 i = %d", i+4);
break;
case 2:
printf("CASE\_2 i = %d", i+9);
break;
case 3:
printf("CASE\_3 i = %d", i+14);
break;
case 4:
printf("CASE\_3 i = %d", i+19);
break;
default:
break;
}
return 0;
}
```
### Дизассемблированный вариант в radare2
1605793648917.png1605793656018.png1 - инициализации переменной var\_4h (i = 3)
2 - выполнения инструкций (add, printf)
Вот этот дизасcемблированный код довольно сложно быстро отличить от if и вообще понять что и как тут. В режиме графов всё будет более понятно.
### Режим графов
1605793750977.png1605793673414.png1605793684884.png1605793691266.png**Режим графов - ваш друг в дизасcемблировании :)**
На этом всё. **Рекомендую попробовать самому написать программы на Си, скомпилировать и изучить дизасcемблированный код. Практика и ещё раз практика!**
Спасибо за внимание. Не болейте. | https://habr.com/ru/post/528978/ | null | ru | null |
# Утрата слабой связанности
Перевод статьи [LOSING LOOSE COUPLING](http://kranglefant.tumblr.com/post/32472145738/losing-loose-coupling)
 Когда меня просят присутствовать на собеседованиях, я обычно задаю один вопрос кандидату: «Что такое хороший код?». Тревожит, что часто можно услышать от недавних выпускников: «Наличие хороших комментариев». Это неправильный ответ. Кто учит их этому? Пугающе. Но я отвлекся… Не думаю, что есть правильный ответ на мой вопрос, однако я бы принял что-нибудь вроде «сильное сцепление (high cohesion) и слабая связанность (loose coupling)». По крайней мере это что-то говорит о коде. Но если это собеседование Java разработчика, я не дам бедняге уйти без нескольких дополнительных вопросов. Потому что Java разработчики полностью обезумели. Они одержимы желанием порубить код на супер-пупер мелкие кусочки. Мы рубим и рубим до тех пор, пока практически ничего не останется. Как только маленькие дорогуши разделены мы начинаем беспокоиться о том, чтобы они не трогали друг друга. Ох, малышки! Мы должны защитить их друг от друга любой ценой. Каждый маленький кусок кода получает свой собственный интерфейс, чтобы он не мог замарать свои руки дотянувшись до других частей напрямую. Мы связываем их магическими фреймворками. Которые используют абстрактные прокси, создающие фабрики и так далее.
Представьте велосипед, сделанный по таким принципам. Рама порублена на кусочки, длиной 1 сантиметр, соединенных по типу позвоночника. Будет ли она более гибкой? Определенно — да. Будет ли она практичной? Конечно, нет. Она будет дороже в производстве в сотни раз. Она также будет ломаться в сотни раз чаще. Такой велосипед приведет к большему количеству несчастных случаев, и не в последнюю очередь, будет странно выглядеть и на нем будет трудно ездить. Наша спина должна быть гибкой, поэтому позвонки имеют смысл. Велосипеды — нет.
Мы не делаем велосипеды из одного куска металла или углепластика. Мы можем поменять колеса, мы можем поменять руль, но мы не сходим с ума по этому поводу. Некоторые части маленькие, некоторые большие и это не плохо.
Еще одна вещь, которую мы делаем при разработке велосипеда — это разработка велосипеда, а не обобщенного (generic) «устройства транспортировки». Мы не пудрим мозг нашим клиентам, о том, что однажды они смогут пересечь на нем Атлантический океан. Если они захотят сделать это, то уж точно не на нашем велосипеде. Если наши клиенты хотят взлететь на крышу небоскреба, мы им мало чем поможем. Это нормально. Мы хотим сделать лучший в мире ВЕЛОСИПЕД. Велосипед, который может быть переконфигурирован в любое транспортное средство и все еще будет хорошо работать может быть опцией для Бэтмена, но, к сожалению, многие из нас не обладают такими бюджетами. Мы хотим, чтобы наши системы были крутыми, соответствовали своему назначению, и мы хотим знать, что мы строим. Гибкость и конфигурируемость для людей, которые не знают, чего хотят, или когда вы хотите, чтобы сторонние поставщики разрабатывали части системы. Производители велосипедных рам точно не ограничивают свои велосипеды только одним типом сиденья, одним типом руля или одним типом колес. В терминах программирования они соединяются с интерфейсом `Руль`, который может быть реализован любым количеством конкретных моделей рулей. Но рама — это их собственный продукт, который не рубится на маленькие заменяемые фрагменты. Если они захотят делать различные рамы — догадайтесь, что? Они сделают разные модели. Модели используют много общих черт, но они все-таки полностью разные.
В программировании мы преследуем возможность заменять части нашей системы любыми другими реализациями. Если мы поменяем что-то одно, и это приведет к тому, что что-то другое перестанет работать, то мы видим — это плохой дизайн. Но что произойдет, если мы поставим колеса от монстр-трака на наш велосипед? Велосипед будет работать не очень хорошо, не так ли? Но означает и это, что велосипед плохо спроектирован? В реальном мире мы миримся с тем, что вещи связаны друг с другом («захардкожены», если угодно) мы даже предпочитаем такие вещи. Мы понимаем, для чего эта вещь подходит, а для чего — нет. Велосипеду нужны колеса, которые подходят к его раме. Мы не можем просто использовать интерфейс `Колесо` мы должны быть достаточно точны. Конструкция велосипеда, к которой можно присоединить любые колеса будет достаточно сложной. Оно не стоит того.
Если мы захотим, чтобы у нашего велосипеда были колеса от монстр-трака, необходимо будет изменить наш дизайн и сделать что-то, чтобы они подходили. И вы знаете что — мы можем это сделать в программировании. Я пришел к этой удивительной технике, не знаю, можно ли сделать то же самое в IntelliJ, но по крайней мере в Eclipse (которым я пользуюсь) вы можете выбрать код, который нуждается в изменении: удерживая клавишу SHIFT нажимая на кнопки курсора до тех пор, пока часть кода, которую надо изменить не будет подсвечена; отпустить клавишу SHIFT и нажать DELETE. И код исчезнет! И тогда вы можете написать что-нибудь другое. Это действительно работает! Я пробовал. В коде Java тоже, не только в xml или properties файлах! Это поразительно!
Когда-нибудь замечали, как большие корпоративные проекты стоят целое состояние, занимают вечность в разработке и потом эффектно проваливаются при попытке получить результат? Существует много причин для этого. Но я убежден одно из них — это гибкость. Гибкость тесака и вакуумного пакета, индивидуально упакованные в мини кусочки обобщенного (generic) кода. Вместо создания (возможно нескольких) систем, которые хороши в специфичных известных случаях мы настаиваем на создании ЕДИНОЙ (супер конфигурируемой) СИСТЕМЫ КОТОРАЯ ВСЕМ УПРАВЛЯЕТ. Программа, которая будет работать для любого, везде, не важно какие у них потребности.
Но что же делать, если однажды нам надо будет изменить базу данных? Что если нам понадобятся эти данные в другом месте? Что если формат этого сообщения изменится? Мы можем это поменять. Не частота ли релизов наших систем стоит на первом месте? Что если мы их изменим? Если наши системы хорошо протестированы и хорошо спроектированы, изменение — это не проблема.
Я за слабую связанность, но сделайте одолжение: убедитесь, что ваше решение связано с вашей проблемой. | https://habr.com/ru/post/206684/ | null | ru | null |
# «Идеальный» кластер. Часть 2.1: Виртуальный кластер на hetzner
**Хочу отметить, что эта инструкция родилась в процессе проведения экспертизы различных систем виртуализации в стенах компании [Acronis](http://habrahabr.ru/company/acronis/).
Proxmox показал себя с хорошей стороны, возможно наш опыт окажется полезным для решения Ваших задач.**
Арендуя очередной сервер в дата-центре, каждый задумывается о рациональности его использования.
Ведь ни для кого не секрет, что хорошо настроенный сервер не должен быть слишком нагружен и в нем должно быть достаточно ресурсов для выполнения другой работы. Кроме вышесказанного, важна отказоустойчивость и поэтому держать несколько копий одного и того же сервера в качестве hot swap, кажется отличной идеей.
Для решения этих задач и нужна виртуализация.
Сейчас я расскажу, как можно быстро сделать из одного сервера целый кластер серверов на базе linux и windows.
В дальнейших статьях я попытаюсь объяснить, как поднять безопасный web-кластер и использовать все прелести современных технологий виртуализации.
В этой инструкции речь пойдет о бесплатной системе виртуализации Proxmox, она находится в свободном доступе, но за поддержку требует плату. Мы попробуем обойтись без поддержки и коммерческого репозитория Proxmox. Вот что говорит о об этом продукте википедия
> **Proxmox Virtual Environment (Proxmox VE)** — система виртуализации с открытым исходным кодом, основанная на Debian GNU/Linux. Разрабатывается австрийской фирмой Proxmox Server Solutions GmbH, спонсируемой Internet Foundation Austria.
>
> В качестве гипервизоров использует KVM и OpenVZ. Соответственно, способна выполнять любые поддерживаемые KVM ОС (Linux, \*BSD, Windows и другие) с минимальными потерями производительности и Linux без потерь.
>
> Управление виртуальными машинами и администрирование самого сервера производятся через веб-интерфейс либо через стандартный интерфейс командной строки Linux.
>
> Для создаваемых виртуальных машин доступно множество опций: используемый гипервизор, тип хранилища (файл образа или LVM), тип эмулируемой дисковой подсистемы (IDE, SCSI или VirtIO), тип эмулируемой сетевой карты, количество доступных процессоров и другие.
>
>
>
> **Ключевые возможности**
>
>
>
> * Простое управление через веб-интерфейс;
> * Мониторинг нагрузки в реальном времени;
> * Библиотека установочных образов (в локальном или удаленном хранилище);
> * Подключение к «физической» консоли гостевых систем непосредственно из браузера (по VNC);
> * Объединение серверов в кластер с возможностью живой миграции виртуальных машин (без остановки гостевой системы);
> * Быстрое развертывание гостевых систем из шаблонов (доступно только для OpenVZ);
> * Автоматическое резервное копирование виртуальных машин.
>
>
>
>
Первым делом нужно заказать сервер с debian 7 64 на борту, чем больше памяти тем лучше! побеспокойтесь о сохранности своих данных, RAID 1 совсем не будет лишним, хотя сам по себе он несет ряд рисков. Мы оптимисты, берем с RAID1.
Как только у нас есть root доступ к нашему новому серверу, приступаем к работе:
**# До установки самого proxmox нужно определиться с hostname и указать его**
```
nano /etc/hosts
```
```
127.0.0.1 localhost
x.x.x.x test.xxxx.info test
#
# IPv6
::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts
x:x:x:4105::2 test.xxxx.info
```
```
nano /etc/hostname
```
```
test
```
**# Меняем временную зону**
```
echo "Europe/Moscow" > /etc/timezone
dpkg-reconfigure -f noninteractive tzdata
```
**# Создаем папку для репозиториев**
```
mkdir -p /etc/apt/sources.list.d/
```
**# Скачиваем репозитории**
```
cd /etc/apt/sources.list.d/
wget http://sycraft.info/share/debian7/sources.list.d/debian7.list
wget http://sycraft.info/share/debian7/sources.list.d/dotdeb7.list
wget http://sycraft.info/share/debian7/sources.list.d/neurodebian.sources7.list
wget http://sycraft.info/share/debian7/sources.list.d/proxmox7.list
```
**# Устанавливаем ключи**
```
cd /root/
wget http://www.dotdeb.org/dotdeb.gpg
cat dotdeb.gpg | apt-key add -
apt-key adv --keyserver keyserver.ubuntu.com --recv-keys A040830F7FAC5991
apt-key adv --recv-keys --keyserver pgp.mit.edu 2649A5A9
wget -O- "http://download.proxmox.com/debian/key.asc" | apt-key add -
rm *.gpg
```
**# Обновляем систему**
```
apt-get update && apt-get upgrade -f -y
```
**# Ставим необходимый минимум**
```
apt-get install ntp screen mc git ntpdate sudo zip unzip pigz locales tzdata nano aptitude htop iotop sysstat rkhunter chkrootkit nscd lsof strace subversion multitail -y -f
```
**# Устанавливаем ядро от proxmox**
```
apt-get install pve-firmware pve-kernel-2.6.32-26-pve -y -f
apt-get install pve-headers-2.6.32-26-pve -y -f
```
**# Зачистка системы от старых ядер**
```
apt-get remove linux-image-amd64 linux-image-3.2.0-4-amd64 -y -f
```
**# Генерация grub**
```
update-grub
```
**# Перезагрузка**
```
reboot
```
**# Нам повезло, наш сервер загрузился и теперь можно ставить сам proxmox**
```
apt-get install proxmox-ve-2.6.32 ntp ssh lvm2 postfix ksm-control-daemon vzprocps open-iscsi bootlogd -y
```
**# Удаляем репозиторий для платного proxmox**
```
rm -fr /etc/apt/sources.list.d/pve-enterprise.list
```
**# Добавляем модули iptables на все случаи жизни**
```
nano /etc/vz/vz.conf
```
```
IPTABLES="ipt_owner ipt_REDIRECT ipt_recent ip_tables iptable_filter iptable_mangle ipt_limit ipt_multiport ipt_tos ipt_TOS ipt_REJECT ipt_TCPMSS ipt_tcpmss ipt_ttl ipt_LOG ipt_length ip_conntrack ip_conntrack_ftp ipt_state iptable_nat ip_nat_ftp"
```
**# Добавляем модули при загрузке ядра (лишний шаг, но на всякий случай)**
```
nano /etc/modules
```
```
ipt_MASQUERADE
ipt_helper
ipt_REDIRECT
ipt_state
ipt_TCPMSS
ipt_LOG
ipt_TOS
tun
iptable_nat
ipt_length
ipt_tcpmss
iptable_mangle
ipt_limit
ipt_tos
iptable_filter
ipt_helper
ipt_tos
ipt_ttl
ipt_REJECT
loop
```
Дальше пару слов о предполагаемой архитектуре:
* Мы заказываем вместе с сервером **2** внешних (публичных) IP адреса, на первом находится служебный порт web-панели proxmox, ssh, mysql и другие служебные порты о которых никто лишний не должен знать
* Второй адрес обслуживает порты, которые должны быть доступны всем. Например 80 и 443 и все. Кроме того, этот адрес поднят на пустой, лишенной лишних сервисов виртуальной машине. Остальное будет разруливать пробросами портов.
**# Сохраняем текущие правила iptables**
```
iptables-save > /etc/iptables.up.rules
```
**# Дописываем правила в раздел \*nat для нашего внешнего служебного адреса**
```
nano /etc/iptables.up.rules
```
```
*nat
:PREROUTING ACCEPT [2164:136969]
:POSTROUTING ACCEPT [58:3659]
:OUTPUT ACCEPT [0:0]
-A PREROUTING -d x.x.16.182/32 -p tcp -m tcp --dport 22 -j DNAT --to-destination 192.168.8.2:22
-A POSTROUTING -o vmbr0 -j MASQUERADE
-A POSTROUTING -d x.x.16.182 -p tcp -s 192.168.8.0/24 --dport 22 -j SNAT --to-source x.x.16.182
COMMIT
```
**# Проверяем правила, ошибок быть не должно**
```
iptables-restore < /etc/iptables.up.rules
```
**Очень важное правило POSTROUTING, Если вы захотите изнутри одной из виртуальных маших обратится по проброшенному порту внешнего адреса, без этого правила ничего не будет работать!**
**# Загружаем образы контейнеров openvz**
```
cd /var/lib/vz/template/cache/
wget http://download.openvz.org/template/precreated/debian-7.0-x86_64.tar.gz
wget http://download.openvz.org/template/precreated/centos-6-x86_64.tar.gz
wget http://download.openvz.org/template/precreated/ubuntu-13.10-x86_64.tar.gz
```
**# Драйвера на случай если нам понадобиться windows**
```
cd /var/lib/vz/template/iso/
wget http://alt.fedoraproject.org/pub/alt/virtio-win/latest/images/virtio-win-0.1-74.iso
```
**# Далее переходим по внешнему адресу нашего сервера [x.x.16.182](https://x.x.16.182):8006/**
После авториации видим сообщение об использовании бесплатной версии, она нам и нужна. Просто привыкаем нажимать ОК или покупаем подписку
#### Настройка сети для Hetznet
# Приступаем к перенастройке сети, настройка сетевых мостов может показаться странной, но в Hetzner есть ограничение количество MAC адресов на порту коммутатора, те все внешние адреса у нас будет обеспечивать 1 MAC
Это настройка одинаково хорошо работает и в ДЦ без таких ограничений, просто универсальный вариант
Так же тут есть приватная сеть 192.168.8.0/16 — ее используем для внутренней сети между нашими виртуальными машинами
# Далее, перезагружаем наш сервер и смотрим наши настройки сети
```
cat /etc/network/interfaces
```
```
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address x.x.16.182
netmask 255.255.255.224
pointopoint x.x.16.129
gateway x.x.16.129
dns-nameservers 8.8.8.8
auto vmbr0
iface vmbr0 inet static
address x.x.16.182
netmask 255.255.255.224
bridge_ports none
bridge_stp off
bridge_fd 0
pre-up iptables-restore < /etc/iptables.up.rules
up ip route add x.x.150/32 dev vmbr0
#
auto vmbr1
iface vmbr1 inet static
address 192.168.8.100
netmask 255.255.0.0
bridge_ports none
bridge_stp off
bridge_fd 0
```
**# Пишем шлюз внешнего служебного IP в pointopoint и gateway, в vmbr0 указываются теже самые адреса но без gateway, ко второму адресу на котором будут публичные порты должен быть прописан маршрут up ip route add и правила фаервола pre-up iptables-restore**
#### Для общего развития, вот пример настройки сети для ДЦ без ограничений на количество адресов MAC
```
nano /etc/network/interfaces
# network interface settings
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
auto vmbr0
iface vmbr0 inet static
address x.x.16.182
netmask 255.255.255.0
gateway x.x.16.1
dns-nameservers 8.8.8.8
bridge_ports eth0
bridge_stp off
bridge_fd 0
pre-up iptables-restore < /etc/iptables.up.rules
auto vmbr1
iface vmbr1 inet static
address 192.168.8.100
netmask 255.255.0.0
bridge_ports none
bridge_stp off
bridge_fd 0
```
**# Вот пример того как мы можем устанавливать нашу Windows (если это нужно)**
**В настройках видеокарты я указываю SPICE а вот и клиент для него [www.spice-space.org/download.html](http://www.spice-space.org/download.html)
Сеть и диск — virtio, для установки драйверов сразу же делаю второй cd-rom для скачанной virtio iso**
Ну и последнее в этой статье — настройка gw. виртуальной машины, которая будет пробрасывать нам публичные порты. На этой виртуальной машине не будет SSH или других слушающих сеть служб — она узел фаервол
Вы создаете CT с образом debian c сетью Network Device
В самом контейнере это будет выглядеть так:
```
nano /etc/network/interfaces
```
```
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address x.x.x.150
netmask 255.255.255.255
pointopoint x.x.16.182
gateway x.x.16.182
pre-up iptables-restore < /etc/iptables.up.rules
auto eth1
iface eth1 inet static
address 192.168.8.1
netmask 255.255.0.0
```
**# Обратите внимание на маску, gateway и pointopoint для этого интерфейса — адрес нашей публичной служебной сети.**
**# Дописываем правила в раздел \*nat для нашего внешнего публичного адреса**
```
nano /etc/iptables.up.rules
```
```
*nat
:PREROUTING ACCEPT [2164:136969]
:POSTROUTING ACCEPT [58:3659]
:OUTPUT ACCEPT [0:0]
-A PREROUTING -d x.x.x.150/32 -p tcp -m tcp --dport 80 -j DNAT --to-destination 192.168.8.5:22
-A POSTROUTING -o eth0 -j MASQUERADE
-A POSTROUTING -d x.x.x.150 -p tcp -s 192.168.8.0/24 --dport 80 -j SNAT --to-source x.x.x.150
COMMIT
```
**# Разрешаем пробросс трафика при маскарадинге**
```
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
sysctl -p
```
**# В этом контейнере удалите все ненужное!**
```
apt-get purge -y -f openssh-server postfix ssh samba bind9 sendmail apache2*apt-get autoremove -y
```
**Если у вас возникнут трудности или потребуется специальный человек чтобы сделать сказку былью — всегда буду рад помочь! мои [контакты](http://habrahabr.ru/users/sycraft/) — welcome**
В продолжение темы моя статья [«Идеальный» www кластер. Часть 1. Frontend: NGINX + Keepalived (vrrp) на CentOS](http://habrahabr.ru/post/198934/)
Дальше будет, надеюсь, еще много и много статей по этой теме! Спасибо за внимание | https://habr.com/ru/post/204190/ | null | ru | null |
# Программирование «для души»
***Полно, голубь, не греши!
Убери свои гроши.
Я ведь это не для денег.
Я ведь это для души.
Леонид Филатов "[Сказка про Федота-стрельца, удалого молодца](http://lyakhov.kz/library/filatov/fedot.shtml#1)"
Just for Fun.
Linus Torvalds***
Не секрет, что люди получают удовольствие по-разному. Одним нравится смотреть телевизор, другие собирают квадрокоптеры. Я хочу поделиться своим рецептом. Вряд ли он будет полезен всем, но возможно кого-то заинтересует. Мне нравится писать программы (и думаю, что это не редкость, даже среди профессиональных программистов), но мне не очень нравится, когда этот процесс превращается в унылую рутину.
Чтобы быть интересным, программирование должно представлять собой, своего рода «зарядку для ума». Хорошим примером такого (полезного) развлечения является, известный многим [ресурс](http://www.sql-ex.ru), посвященный совершенствованию навыков составления SQL-запросов. Но не SQL-ем единым жив программист! Недавно, я нашел отличный способ усовершенствовать свои навыки владения [Фортом](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D1%82_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)). [Axiom](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452) позволяет напрограммироваться на Форте вволю!
Мой рецепт получения Fun-а, при помощи Axiom, прост:
1. Выбираем [любую](http://www.iggamecenter.com/info/en/rules.html) игру, с правилами позаковыристее, из числа ещё не реализованных ZoG-сообществом
2. Пытаемся её воплотить в жизнь, используя Axiom
3. Получаем **удовольствие**, в процессе решения возникающих при этом задач
4. В случае, если в полученное приложение интересно играть, выработанный Fun автоматически удваивается!
С выполнением первого пункта этого плана мне, обычно, помогает Internet. В этот раз, объектом для своих бесчеловечных экспериментов я выбрал [Splut!](http://www.toco.be/splut/). Вот его [описание](http://www.iggamecenter.com/info/en/splut.html) на IG Game Center. Не вдаваясь в пересказ правил, постараюсь объяснить, чем меня привлекла эта игра:
* В неё играют более двух игроков (что является, в определённой степени, вызовом, для алгоритмов AI)
* Ход игрока включает в себя последовательное перемещение нескольких (от 1 до 3) фигур
* Ходы, ведущие к выигрышу, не прямолинейны (нельзя просто взять и съесть фигуру, требуется выполнить последовательность ходов, объединенных одной целью)
* Правила этой игры весьма продуманны и очень оригинальны
**Ремарка**Вот что пишет автор, по поводу прав на свою игру:
> The SPLUT game idea and design are copyrighted. You cannot use any of the ideas or contents of this publication for commercial purposes without written authorization of the designer Tommy De Coninck.
Поскольку я не собираюсь использовать идею или дизайн игры в коммерческих целях, с этим пунктом всё в порядке.
#### Магия с разоблачением
Приступим к выработке Fun-а. Начнем с простого — с ходов Тролля. Обычный ход фигуры никаких сложностей не представляет. Его реализация очевидна и хорошо подходит для объяснения концепций Axiom:
**Тихий ход**
```
: one-step ( 'dir -- )
EXECUTE verify \ Шаг вперёд
empty? verify \ Пусто?
from \ Из исходной точки
here \ Сюда
move \ Ходим
add-move \ Ход завершён
;
```
Сразу хочу посоветовать, обращать внимание на комментарии (в круглых скобках). Они помогут не запутаться в том, что происходит на стеке (это действительно важно в Форте). Также стоит обращать внимание на пробелы. Пробел, **не** поставленный, в неудачном месте, может заставить вас потратить немало времени.
По самому коду, думаю, всё понятно. Мы выполняем переход в направлении (взятом со стека), командой **EXECUTE**, после чего проверяем булевский результат перехода (если не **TRUE**, завершаем расчет хода). Затем, выполняем проверку того, что целевая клетка пуста, после чего, перемещаем фигуру. Команда **move**, выполняющая перемещение, берёт со стека два значения — точку начала хода (**from**) и позицию, в которой мы находимся, после перемещения (**here**). Команда **add-move** завершает формирование хода.
Чуть более сложен ход, с перемещением камня:
**Перетаскивание камня**
```
: drag ( 'dir 'opposite -- )
EXECUTE verify \ Шаг назад
is-stone? verify \ Это камень?
piece-type \ Кручу верчу
SWAP here SWAP \ Запутать хочу
DUP EXECUTE DROP EXECUTE verify \ Два раза шагаем вперёд
empty? verify \ Пусто?
from \ Из исходной точки
here \ Сюда
move \ Перемещаем фигуру
capture-at \ Удаляем Камень с позиции, запомненной ранее
from create-piece-type-at \ И создаём его там, откуда начинали ход
add-move \ Это всё!
;
: drag-to-north ( -- ) ['] north ['] south drag ;
: drag-to-south ( -- ) ['] south ['] north drag ;
: drag-to-east ( -- ) ['] east ['] west drag ;
: drag-to-west ( -- ) ['] west ['] east drag ;
```
Здесь мы кладём на стек сразу два направления — направление перемещения и противоположное ему. Сам код выглядит сложнее, из-за манипуляций со стеком, но к этому можно привыкнуть. Очень важно, что все «побочные» действия по захвату или созданию фигур должны выполняться **после** перемещения основной фигуры. Также важно помнить, что и в каком порядке лежит на стеке после каждой команды. Подробное описание самих команд всегда можно посмотреть в руководстве по Axiom.
На одном моменте, впрочем, стоит остановиться особо. Проверка того, что фигура в текущей клетке является Камнем, выполняется предикатом **is-stone?**. Разумеется, это не встроенная функция Axiom, а наша. Вот как выглядит её реализация:
**Камень?**
```
DEFER SSTONE
DEFER NSTONE
DEFER WSTONE
DEFER ESTONE
: is-stone? ( -- ? )
piece-type SSTONE =
piece-type NSTONE = OR
piece-type WSTONE = OR
piece-type ESTONE = OR
;
...
{pieces
{piece} lock {moves} pass-moves
{piece} sstone {drops} stone-drops
{piece} nstone {drops} stone-drops
{piece} wstone {drops} stone-drops
{piece} estone {drops} stone-drops
{piece} wizard {moves} wizard-moves
{piece} dwarf {moves} dwarf-moves
{piece} troll {moves} troll-moves
pieces}
' sstone IS SSTONE
' nstone IS NSTONE
' wstone IS WSTONE
' estone IS ESTONE
```
Помните, в прошлой [статье](http://habrahabr.ru/post/226235/), я сетовал на то, что не удаётся использовать имена объектов (в данном случае фигур) до их определения? **DEFER** позволяет справится с этой проблемой. Плохо только то, что этот важный паттерн не описан в документации на Axiom.
Но почему у нас четыре типа камня? Разве нельзя было обойтись одним? Увы, правила Splut! составлены таким образом, что мы не можем обойтись без «индивидуальности» камней. Я покажу позже, для чего это нужно.
Теперь Тролль может двигаться и (опционально) таскать за собой Камень, но похоже мы что-то забыли. Дело в том, что единственный способ естественной убыли фигур в Splut! связан с тем, что Тролли будут кидаться в них камнями! Добавим недостающий функционал, собрав код воедино:
**Ходы Троллей**
```
DEFER CONTINUE-TYPE
: one-step ( 'dir -- )
check-continue? IF
EXECUTE verify
empty? verify
from
here
move
add-move
ELSE
DROP
ENDIF
;
: step-to-north ( -- ) ['] north one-step ;
: step-to-south ( -- ) ['] south one-step ;
: step-to-east ( -- ) ['] east one-step ;
: step-to-west ( -- ) ['] west one-step ;
: drag ( 'dir 'opposite -- )
check-continue? IF
EXECUTE verify
is-stone? verify
piece-type
SWAP here SWAP
DUP EXECUTE DROP EXECUTE verify
empty? verify
from
here
move
capture-at
DUP lock-stone
from create-piece-type-at
add-move
ELSE
DROP DROP
ENDIF
;
: drag-to-north ( -- ) ['] north ['] south drag ;
: drag-to-south ( -- ) ['] south ['] north drag ;
: drag-to-east ( -- ) ['] east ['] west drag ;
: drag-to-west ( -- ) ['] west ['] east drag ;
: take-stone ( 'dir -- )
check-continue? IF
EXECUTE verify
is-stone? verify
CONTINUE-TYPE partial-move-type
from
here
move
add-move
ELSE
DROP
ENDIF
;
: take-to-north ( -- ) ['] north take-stone ;
: take-to-south ( -- ) ['] south take-stone ;
: take-to-east ( -- ) ['] east take-stone ;
: take-to-west ( -- ) ['] west take-stone ;
: drop-stone ( 'opposite 'dir -- )
check-edge? check-wizard? OR
on-board? AND IF
check-troll? piece-is-not-present? AND IF
player piece-type
drop
WIZARD = IF
drop-team
ELSE
DROP
ENDIF
lock-continue
current-piece-type lock-stone
add-move
ENDIF
ENDIF
;
: drop-to-north ( -- ) ['] north ['] south drop-stone ;
: drop-to-south ( -- ) ['] south ['] north drop-stone ;
: drop-to-east ( -- ) ['] east ['] west drop-stone ;
: drop-to-west ( -- ) ['] west ['] east drop-stone ;
{moves troll-moves
{move} step-to-north {move-type} normal-type
{move} step-to-south {move-type} normal-type
{move} step-to-east {move-type} normal-type
{move} step-to-west {move-type} normal-type
{move} drag-to-north {move-type} normal-type
{move} drag-to-south {move-type} normal-type
{move} drag-to-east {move-type} normal-type
{move} drag-to-west {move-type} normal-type
{move} take-to-north {move-type} normal-type
{move} take-to-south {move-type} normal-type
{move} take-to-east {move-type} normal-type
{move} take-to-west {move-type} normal-type
moves}
{moves stone-drops
{move} drop-to-north {move-type} continue-type
{move} drop-to-south {move-type} continue-type
{move} drop-to-east {move-type} continue-type
{move} drop-to-west {move-type} continue-type
moves}
' continue-type IS CONTINUE-TYPE
```
Я не буду описывать вспомогательные функции. Их реализацию можно посмотреть [здесь](https://github.com/GlukKazan/ZoG/blob/master/Axiom/splut/Splut.4th). Остановлюсь лишь на бросках. Тролль может взять камень ходом **take-stone** (реализация этой функции тривиальна), после чего команда **partial-move-type** включает продолжение хода, с заданным типом (**continue-type**). Под этим типом зарегистрирован единственный тип хода — бросок (**drop**) Камня на доску.
Бросать можно не абы как, а в строго определённые места! По правилам, камень летит от Тролля по прямой (вертикали или горизонтали), пролетая над головой Гномов, до препятствия (Мага, края доски или другого Тролля). Мага пришибает сразу, в других случаях, падает на доску. Если в этом месте оказался Гном — ему просто не повезло. Это сложное в реализации правило и будет удобнее воплотить его в жизнь, начав с другого конца. Будем искать поля, граничащие с препятствием и двигаться от них, в противоположном направлении, по пустым клеткам или клеткам занятыми Гномами. Если по дороге встретим своего Тролля, значит в то место, с которого мы начали движение, можно бросать камень.
Кроме того, в коде реализованы сопутствующие правила. Например то, что при убийстве Мага, с поля удаляется вся его команда, а также то, что после броска камня, ход сразу же переходит к другому игроку. Я не буду останавливаться на этом подробно.
Головоломкой несколько иного рода является специальный ход Гнома. Гном, своим ходом, может подвинуть любое количество фигур (в том числе Камней), расположенных перед ним в ряд. Для того чтобы хранить все эти фигуры, нам явно понадобится стек. Для всего остального можно использовать переменные:
**Ход Гнома**
```
VARIABLE forward
VARIABLE backward
VARIABLE step-count
VARIABLE here-pos
: push-step ( 'opposite 'dir -- )
check-continue? IF
0 step-count ! forward ! backward !
forward @ EXECUTE verify not-empty? verify
step-count ++
player piece-type
here here-pos !
BEGIN
forward @ EXECUTE IF
empty? IF
TRUE
ELSE
step-count ++
player piece-type
FALSE
ENDIF
ELSE
BEGIN
step-count @ 0> IF
step-count --
DROP DROP
FALSE
ELSE
TRUE
ENDIF
UNTIL
TRUE
ENDIF
UNTIL
step-count @ 0> verify
from here-pos @ move
BEGIN
step-count @ 0> IF
step-count --
DUP is-stone-type? IF
DUP lock-stone
ENDIF
create-player-piece-type
backward @ EXECUTE DROP
FALSE
ELSE
TRUE
ENDIF
UNTIL
add-move
ELSE
DROP DROP
ENDIF
;
```
Да, разобраться в этом сложнее, чем в предыдущем коде, но суть выполняемого действия проста. Мы двигаемся в одном направлении, складывая фигуры в стек, до пустой клетки, а потом возвращаемся, воссоздавая их на доске, сдвинутыми на один шаг (поскольку на одной клетке не может находиться более одной фигуры, об удалении фигур можно не заботиться — ZoG удалит их самостоятельно). Попробуйте понять, как работает этот код, это неплохая «гимнастика для ума».
Конечно, Маги не были бы Магами, если бы не доставили нам максимум неприятностей. Маги могут левитировать камни. Любые, но… при определенных условиях. Например нельзя левитировать камень, который перемещался (любым образом) на предыдущем ходу. Здесь сразу возникает вопрос: что считать предыдущим ходом? К сожалению, правила не расшифровывают этот момент. В своём коде я реализовал очистку признаков перемещения камней (именно здесь нужна индивидуальность, у каждого камня свой флаг) сразу перед передачей хода первому игроку. Конечно, это даёт ему серьезное преимущество (он может двигать любые Камни, а следующие игроки только те, которые не двигал он), но другие возможные реализации этого правила также не безупречны.
**Левитируем Камни**
```
: fly-stone ( 'dir -- )
check-continue? IF
DUP EXECUTE empty? AND IF
a5 to
BEGIN
is-stone? not-locked? AND IF
here here-pos !
DUP piece-type SWAP
EXECUTE SWAP
can-fly? AND IF
from to
DUP EXECUTE DROP
from
here
move
here-pos @ to
DUP piece-type SWAP capture
EXECUTE DROP
DUP lock-stone
DUP begin-fly
create-piece-type
add-move
ENDIF
here-pos @ to
ENDIF
DUP next NOT
UNTIL
ENDIF
DROP
ELSE
DROP
ENDIF
;
```
Здесь легко допустить ошибку, посчитав, что мы реализовали всё необходимое. Но реализованы не все возможности! Может ли Маг двигаться на клетку, занятую Камнем, если далее за Камнем расположена пустая клетка? Правила игры говорят, что да, а код считает иначе. На самом деле, Маг может еще и «толкать» Камни перед собой. Это просто разновидность левитации!
**Толкаем Камни перед собой**
```
: push-stone ( 'dir -- )
check-continue? IF
DUP EXECUTE is-stone? not-locked? AND AND IF
piece-type can-fly-lock? IF
here SWAP
piece-type SWAP
EXECUTE empty? AND IF
SWAP from SWAP move
DUP lock-stone
DUP begin-fly
create-piece-type
add-move
ELSE
DROP DROP DROP
ENDIF
ELSE
DROP
ENDIF
ENDIF
ELSE
DROP
ENDIF
;
```
Этот код проще, поскольку не приходится искать Камни по всему полю. Если мы хотим встать на поле, занятое Камнем, то единственный Камень, который можно левитировать — это он и есть.
#### А и Б сидели на трубе
Как я уже говорил выше, реализация AI, для игр с участием более двух игроков, связана с некоторыми сложностями. Проблемы начинаются уже при определении условия завершения игры. Например, в разработанной мной недавно реализации игры [Yonin Shogi](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2273) (вариант японских шахмат на 4 человек), было бы заманчиво определить условие поражения следующим образом:
```
(loss-condition (South North West East) (checkmated King))
```
Эта запись означает, что игра должна вестись до мата Королю любого из игроков. Увы, этот подход не работает! Я уже [писал](http://habrahabr.ru/post/221779/) о том, что команда **checkmated**, несёт в себе слишком много «магии». В частности, она определяет, что Король всегда должен уходить из под шаха (и никогда не вставать под шах). В целом, это работает… до тех пор пока в игре участвуют два игрока. Видео иллюстрирует проблему:
Как можно заметить, **checkmated** работает нормально лишь для одного из 4 игроков. Для остальных игроков, защита от шаха не считается обязательным ходом! Разумеется, на следующем ходу, такого короля **возможно** съедят, но этот факт лишь усугубляет ситуацию. Как ни крути, нормального мата в такой игре поставить не удастся.
В Splut! ситуация еще хуже. Игра должна вестись до тех пор, пока на доске не останется лишь одна команда. Но ZoG не позволяет изменять список очередности ходов во время игры! Это означает, что каждая выбывшая команда должна делать свой ход, когда до нее дойдет очередь (разумеется она будет пасовать, поскольку никакой другой возможности сделать ход нет). Кроме того, в Splut! каждая команда делает несколько ходов подряд (1-2 в начале игры и 3 в середине партии). В общем, для меня не стало сюрпризом то, что штатный AI Axiom не справился с этой игрой.
Он конечно работает, программа делает ходы (довольно глупые на мой взгляд), но, после выбывания одного из игроков начинаются проблемы. При расчёте каждого пропуска хода, программа начинает «думать» всё дольше и дольше, не укладываясь ни в какие из заданных временных рамок. Доопределение своей оценочной функции (**OnEvaluate**) никак не исправляет положение. В общем, я посчитал это достаточным поводом для того, чтобы попытаться реализовать собственный алгоритм AI, благо в Axiom такая возможность имеется (забегая вперёд, скажу, что получилось не очень здорово, но попробовать то стоило).
За основу я взял следующий, известный многим, алгоритм из книги Евгения Корнилова «Программирование Шахмат и других логических игр»:
**Alpha-Beta отсечение с амортизацией отказов**
```
int AlphaBeta(int color, int Depth, int alpha, int beta)
{
if (Depth == 0) return Evaluate(color);
int score = -INFINITY;
PMove move = GenerateAllMoves(color);
while (move)
{
MakeMove(move);
int tmp = -AlphaBeta(color==WHITE?BLACK:WHITE, Depth - 1, -beta, -alpha);
UnMakeMove(move);
if (tmp > score) score = tmp;
if (score > alpha) alpha = score;
if (alpha >= beta) return alpha;
move = move -> next;
}
return score;
}
```
Как легко заметить, в исходном виде, этот алгоритм нам совершенно не подходит. У нас больше двух игроков, да и с чередованием ходов все гораздо сложнее. Но этот алгоритм — хорошая отправная точка для разработки собственной версии.
Подумав немного, можно понять, что в самом худшем случае, три игрока, противостоящие тому, для которого мы рассчитываем ход, объединят свои усилия. Иными словами, для нас это **один** враждебный игрок (если они не объединятся — тем хуже для них). Другим важным моментом является вычисление оценочной функции. При расчете хода, оценочная функция должна всегда вычисляться «с точки зрения» одного и того-же игрока (того, для которого рассчитывается ход). Для враждебных игроков, оценка должна браться с обратным знаком (чем нам лучше — тем им хуже). Приняв во внимание эти соображения, можно переписать алгоритм следующим образом:
**Обобщенное Alpha-Beta отсечение**
```
VARIABLE Depth
MaxDepth [] CurrMove[]
MaxDepth [] CurrTurn[]
MaxDepth [] CurrScore[]
: Score ( alpha beta turn -- score )
Depth -- Depth @
0< IF
EvalCount ++
SWAP DROP SWAP DROP
Eval
SWAP turn-offset-to-player
current-player <> IF
NEGATE
ENDIF
ELSE
DUP turn-offset-to-player FALSE 0 $GenerateMoves
Depth @ CurrTurn[] !
$FirstMove Depth @ CurrMove[] !
-10000 Depth @ CurrScore[] !
BEGIN
$CloneBoard
Depth @ CurrMove[] @
.moveCFA EXECUTE
2DUP
Depth @ CurrTurn[] @ next-turn-offset
RECURSE
$DeallocateBoard
$Yield
DUP Depth @ CurrScore[] @ > IF
Depth @ CurrScore[] !
ELSE
DROP
ENDIF
Depth @ CurrTurn[] @ turn-offset-to-player
current-player <> IF
NEGATE SWAP NEGATE
ENDIF
OVER Depth @ CurrScore[] @ < IF
SWAP DROP
Depth @ CurrScore[] @
SWAP
ENDIF
2DUP >= IF
OVER Depth @ CurrScore[] !
TRUE
ELSE
Depth @ CurrTurn[] @ turn-offset-to-player
current-player <> IF
NEGATE SWAP NEGATE
ENDIF
Depth @ CurrMove[] @
$NextMove
DUP Depth @ CurrMove[] !
NOT
ENDIF
UNTIL
$DeallocateMoves
DROP DROP
Depth @ CurrScore[] @
Depth @ CurrTurn[] @ turn-offset-to-player
current-player <> IF
NEGATE
ENDIF
ENDIF
Depth ++
;
```
Здесь очень много «магии» Форта и Аксиомы, связанной с генерацией ходов и позиций, но, при некотором напряжении, исходный алгоритм вполне просматривается. Для разгрузки стека пришлось эмулировать несколько стеков с переменными, используемыми в рекурсивных вызовах. На самом стеке, в процессе вычисления, лежат всего два значения **alpha** и **beta**. В рекурсивные вызовы (**RECURSE**) они всегда передаются в одном и том же порядке, но если расчет выполняется для враждебного игрока, мы меняем их знак, после чего, меняем эти значения местами. Также мы изменяем знак оценки, полученной при оценке позиции враждебным игроком.
Вызывается эта функция из уже знакомой нам, по прошлой статье, реализации Custom Engine:
**Custom Engine**
```
3 CONSTANT MaxDepth
VARIABLE BestScore
VARIABLE Nodes
: Custom-Engine ( -- )
-10000 BestScore !
0 Nodes !
$FirstMove
BEGIN
$CloneBoard
DUP $MoveString
CurrentMove!
DUP .moveCFA EXECUTE
MaxDepth Depth !
0 EvalCount !
BestScore @ 10000 turn-offset next-turn-offset Score
0 5 $RAND-WITHIN +
BestScore @ OVER <
IF
DUP BestScore !
Score!
0 Depth!
DUP $MoveString BestMove!
ELSE
DROP
ENDIF
$DeallocateBoard
Nodes ++
Nodes @ Nodes!
$Yield
$NextMove
DUP NOT
UNTIL
DROP
;
```
Можно заметить, что в этом коде мы прибавляем к значению оценки случайное число от 1 до 5. Это делается для того, чтобы программа не ходила всегда одинаково в тех случаях, когда оценки ходов различаются незначительно.
Как обычно, главная сложность заключается в построении оценочной функции. Я не буду загружать статью листингом текущего ее варианта (желающие всегда могут посмотреть код на [GitHub](https://github.com/GlukKazan/ZoG/blob/master/Axiom/splut/Engine.4th)), скажу только, что в ней, в настоящее время, учитываются следующие моменты:
* Количество вражеских Магов (наша основная цель — уменьшение этого значения)
* Количество дружественных Магов (если эта величина изменится с 1 на 0, игра для нас закончится)
* Количество вражеских Гномов (всегда приятно связать противнику руки)
* Количество дружественных Гномов (не то чтобы мы без него не обошлись, но своя фигура все-таки)
* Штраф за нахождение дружественного Мага на одной линии с Камнем (это действительно опасно)
* Бонусы за нахождение вражеских Магов на одних линиях с Камнями (по той же причине)
* Суммарное количество шагов от Троллей до Камней (стараемся уменьшить для своих и увеличить для чужих)
Это конечно не идеальный вариант. Весовые значения стоит подобрать более оптимально, да и сам факт, к примеру, нахождения Мага на одной линии с Камнем, сам по себе, ни о чем не говорит. Линия броска может быть перекрыта, например Троллем, да и до камня надо еще добраться, чтобы его кинуть. Так или иначе, мы написали код и можем посмотреть, как он работает:
Как и ожидалось, AI не блещет интеллектом (и работает жутко медленно), но хотя бы пытается «сойти за умного». По крайней мере, в это уже можно играть.
#### Подсчитали — прослезились
Конечно, чтобы оценить качество AI, можно сыграть с ним много раз и построить «экспертную оценку», но это не наш метод. В комплекте с Axiom поставляется замечательная утилита AutoPlay, позволяющая автоматизировать этот процесс. К сожалению, она пока не умеет работать с играми, рассчитанными более чем на 2 игроков, но это не проблема. Специально для неё, создадим конфигурацию с двумя игроками (камней оставим 4 штуки):
**Duel**
```
LOAD Splut.4th ( Load the base Splut game )
{players
{player} South {search-engine} Custom-Engine
{neutral} West
{player} North {search-engine} Custom-Engine
{neutral} East
{player} ?Cleaner {random}
players}
{turn-order
{turn} South
{turn} North
{turn} North
{repeat}
{turn} ?Cleaner {of-type} clear-type
{turn} South
{turn} South
{turn} South
{turn} North
{turn} North
{turn} North
turn-order}
{board-setup
{setup} South sstone e1
{setup} South wizard d2
{setup} South dwarf e2
{setup} South troll f2
{setup} South lock f1
{setup} West wstone a5
{setup} North nstone e9
{setup} North wizard f8
{setup} North dwarf e8
{setup} North troll d8
{setup} North lock h1
{setup} East estone i5
board-setup}
```
Также, нам понадобится конфигурация, в которой игроки делают случайные ходы:
**Random**
```
LOAD Splut.4th ( Load the base Splut game )
{players
{player} South {random}
{neutral} West
{player} North {random}
{neutral} East
{player} ?Cleaner {random}
players}
{turn-order
{turn} South
{turn} North
{turn} North
{repeat}
{turn} ?Cleaner {of-type} clear-type
{turn} South
{turn} South
{turn} South
{turn} North
{turn} North
{turn} North
turn-order}
{board-setup
{setup} South sstone e1
{setup} South wizard d2
{setup} South dwarf e2
{setup} South troll f2
{setup} South lock f1
{setup} West wstone a5
{setup} North nstone e9
{setup} North wizard f8
{setup} North dwarf e8
{setup} North troll d8
{setup} North lock h1
{setup} East estone i5
board-setup}
```
Результаты получились, на удивление, неплохими (хотя для расчета 100 партий потребовалась целая ночь):
```
Final results:
Player 1 "Random", wins = 13.
Player 2 "Duel", wins = 87.
Draws = 0
100 game(s) played
```
Почему программа работает так долго? Посмотрим, сколько раз, при вычислении хода, вызывается оценочная функция (данные расчета на 5 ходов в глубину):
Да, 8000 вызовов оценочной функции это безусловно много, но почему здесь три ряда? Попробую объяснить. Вот как мы считаем количество вызовов Eval:
**Сбор статистики**
```
$gameLog ON
VARIABLE EvalCount
: Score ( alpha beta turn -- score )
Depth -- Depth @
0< IF
EvalCount ++
...
ELSE
...
;
: Custom-Engine ( -- )
...
BEGIN
...
0 EvalCount !
BestScore @ 10000 turn-offset next-turn-offset Score
0 5 $RAND-WITHIN +
EvalCount @ . CR
...
UNTIL
DROP
CR
;
```
На выходе, получается следующая последовательность:
**Результат**992
655
147
3749
22
1
22
22
22
22
1
1
336
132
50
382
42
213
35
392
21
62
40
49
1465
189
1
1
1
1
1
1
1
52
91
122
75
50
1509
2074
637
492
249
800
415
877
963
5608
90
4
4
4
4
4
4
4
4
Каждая группа чисел (отделенная пустой строкой) содержит результаты просмотра всех возможных ходов игрока из текущей позиции. В графике, представленном выше, первый ряд показывает минимальное значение в группе, второй — среднее, третий — максимальное. Разница между максимальным и минимальным значением определяется эффективностью альфа-бета отсечения. Среднее значение — определяет производительность, на которую мы можем рассчитывать, при заданной глубине перебора.
Можно заметить, что числа в группах, в основном, убывают, но иногда случаются нарушающие монотонное убывание «всплески». Попробуем подсчитать их количество:
Слишком много! В некоторых группах более 16 нарушений монотонного убывания. Если бы было возможно просматривать ходы в более оптимальной последовательности, наверняка удалось бы улучшить показатели производительности (и возможно добиться большей глубины перебора). К сожалению, следующие два пункта мешают мне это сделать:
1. У меня отсутствуют эвристики, позволяющие произвести предварительную оценку «качества» ходов в игре Splut!
2. Даже если бы такие эвристики были, предварительная оценка и сортировка списка ходов в Axiom связана с определенными техническими сложностями (и издержками производительности)
Другим методом увеличения глубины перебора мог бы послужить «углубленный» перебор «форсированных» ходов. Также, было бы неплохо отсекать повторяющиеся позиции (с этим мог бы сильно помочь [Zobrist hashing](https://en.wikipedia.org/wiki/Zobrist_hashing)).
Посмотрим, как изменяется количество просматриваемых позиций, при увеличении глубины перебора:
Поскольку среднее время ожидания завершения ходов всех противников (при глубине просмотра 5 ходов) составляет около 1 минуты, очевидно, что это максимальная глубина перебора, на которую можно рассчитывать, при текущей реализации алгоритма (любое ее увеличение сделает игру человека с программой совершенно не комфортной).
Но давайте подумаем, что такое 5 ходов в игре **Splut**? Этого недостаточно даже для того, чтобы рассчитать возможные ходы всех игроков! Даже в режиме Duel. Это все равно что рассчитывать игру в Шахматы всего на 1 ход вперед! Сложно ожидать особого интеллекта от такой программы.
Конечно в Splut! гораздо меньше фигур чем в Шахматах, но и ходы более сложные! Чтобы победить, программа должна уметь строить долгосрочные планы, на много ходов вперед. Пока я не знаю, как этого добиться, используя Axiom, но вероятно как то можно.
Я работаю над этим.
**P.S.**Я хочу выразить признательность разработчику Axiom. **Greg Schmidt** — настоящий энтузиаст компьютерной разработки настольных игр. Он поддерживает код Axiom уже почти 10 лет, постоянно улучшая его и добавляя что то новое. С того момента, как я выложил Axiom-реализацию игры Ур в ZoG, он ведёт со мной оживленную переписку, помогая и объясняя тонкости работы Axiom. Буквально вчера, с его помощью, мне удалось обнаружить и исправить весьма неприятную ошибку в реализации Ур-а. Я очень благодарен ему за поддержку!
**P.P.S.**При оформлении статьи, использован фрагмент работы известного российского художника-комиксиста **Даниила Кузьмичева**. | https://habr.com/ru/post/227835/ | null | ru | null |
# Пошаговая установка Node.js на Windows без виртуалок
Эта статья предназначена для тех, кого бесят мильён левых служб и драйверов, которые ставят любые виртуалки. Тем, кто будут ставить доп. пакеты Node.js
Все остальные могут скачать скомпилированный Node.js [node-js.prcn.co.cc](http://node-js.prcn.co.cc/)
Или же установить Node.js из-под виртуалки [nodejs.ru/25](http://nodejs.ru/25)
Прошу под кат
Совсем без виртуалок, конечно, не обойдется попутно нам придется поставить Cygwin. Который лишен левых windows-служб, что меня неимоверно порадовало.
Качаем Cygwin setup.exe — 670 Кб [cygwin.com/setup.exe](http://cygwin.com/setup.exe)
#### Установка Cygwin
Запускаем, предложит выбрать путь установки, лучше ставить в c:\cygwin\
Далее предложит выбрать путь куда будут заливаться пакеты, мой выбор пал на c:\cygwin\p\
Далее предложит выбрать зеркало, откуда будет качать пакеты — я выбрал [ftp.linux.kiev.ua](ftp://ftp.linux.kiev.ua) — скорость отдачи очень радует
Теперь нам нужно установить необходимые для установки и работы Node.js пакеты
Dev — ставим все или только пакеты ниже
— gcc g++ C++ compiler
— gcc mingw-g++
— gcc4-4++ G++ subpackage
— git
— make
— openssl
— pkg-config
— zlib-devel
Python – ставим все
Web
— wget
Окно выбора пакетов примерно такое:
Установщик соберет зависимости и установит все минут за 5 при отдаче в 8 Мбит/сек
#### Патчим rebaseall
Открываем файл C:\сygwin\bin\rebaseall не виндузовым блокнотом
Если имя пользователя не латинское (прим. Администратор), то находим
`TmpDir="${TMP:-${TEMP:-/tmp}}"`
Заменяем на
`TmpDir="/tmp"`
Если работаем под 7й виндой, то находим
`sed -e '/cygwin1\.dll$/d' -e '/cyglsa.*\.dll$/d' -e 's/^/\//' >"$TmpFile"`
Заменяем на
`sed -e '/cygwin1\.dll$/d' -e '/cyglsa.*\.dll$/d' -e 's/^/\//' -e '/\/sys-root\/mingw\/bin/d' >"$TmpFile"`
Больше ничего патчить не нужно
#### Патчим библиотеки
Закрываем Cygwin если открыли
Запускаем командную строку windows
в ней вбиваем C:\сygwin\bin\ash.exe
Вбиваем руками ./rebaseall –v
В результате мы увидим что-то такое:
`/usr/lib/dde1.2/tcldde12.dll: new base = 69050000, new size = 20000
... пропущена тыщастрок ...
/usr/lib/reg1.1/tclreg11.dll: new base = 69030000, new size = 20000
/usr/bin/cygz.dll: new base = 69000000, new size = 30000`
Закрываем виндузовую командную строку
#### Запускаем Cygwin
Запускаем Cygwin при первом запуске он создаст каталог для текущего пользователя windows в своей среде
у меня c:\cygwin\home\Администратор\
#### Ставим Node.js
Качаем последнюю стабильную версию и устанавливаем
```
$ wget http://nodejs.org/dist/node-latest.tar.gz
$ tar xvf node-latest.tar.gz
$ cd node-v0.2.4/
$ ./configure
$ make
$ make install
```
Если ругается на openssl
```
./configure --without-ssl
```
Пробуем запустить Node.js
```
$ node --version
v0.2.4
```
#### Создаем тестовое приложение для Node.js
Создаем файл c:\cygwin\home\Администратор\www\server.js
```
var http = require('http');
http.createServer(function (request, response) {
response.writeHead(200, {'Content-Type': 'text/html'});
response.end('**Hello World from Cygwin**');
}).listen(8124);
console.log('Server running at http://127.0.0.1:8124/');
```
#### Запускаем наш сервер
```
$ node /home/Администратор/www/server.js
```
Тут может заругаться фаерволл windows — разрешаем все, что спросит
Открываем 127.0.0.1:8124
Если вы увидели **Hello World from Cygwin** значит у вас все получилось, поздравляю.
#### Прочие фиксы
Для того, чтобы Node.js мог работать с внешними DNS, нужно создать файл `/etc/resolv.conf` и прописать в него
`nameserver 8.8.8.8
nameserver 8.8.4.4`
Это адреса Google Public DNS
По мотивам
[codebetter.com/blogs/matthew.podwysocki/archive/2010/09/07/getting-started-with-node-js-on-windows.aspx](http://codebetter.com/blogs/matthew.podwysocki/archive/2010/09/07/getting-started-with-node-js-on-windows.aspx)
[blog.brev.name/2010/09/nodejs-on-windows-7-under-cygwin.html](http://blog.brev.name/2010/09/nodejs-on-windows-7-under-cygwin.html) | https://habr.com/ru/post/107232/ | null | ru | null |
# Базовая анимация с iTween
Вы когда-нибудь занимались созданием анимации в своей игре? Задавать подобный вопрос, наверное, глупо, практически в каждой игре есть какая-никакая, но анимация и вам приходилось иметь с ней дело. Напомню, что занятие это более чем утомительное, чаще всего приходиться придумывать свои наработки, чтобы хоть как-то облегчить себе жизнь. Но зачем заниматься лишней работой, делать это плохо, когда это уже сделано, и сделано хорошо!? Давайте познакомимся с инструментом под названием **iTween**.
Получить его можно на официальном сайте: <http://itween.pixelplacement.com>
iTween это класс, который предоставляет различные методы. С их помощью можно не только анимировать объекты сцены, но и менять их цвет, размер, положение, направление.
Давайте попробуем смоделировать небольшой полигон для наших испытаний.
Первым делом подключим iTween-package из **Asset store**: <https://www.assetstore.unity3d.com> В Unity мы должны увидеть подобное:
Создадим новую сцену с таким содержанием:
Куб — это тот объект, который мы и будем анимировать. Теперь переходим на iTween. Создаем новый компонент-скрипт типа **C#** у нашего объекта. Заполним метод Start:
```
void Start()
{
iTween.RotateFrom(gameObject, iTween.Hash("y", 90.0f, "time", 2.0f, "easetype", iTween.EaseType.easeInExpo));
iTween.MoveFrom(gameObject, iTween.Hash("y", 3.5f, "time", 2.0f, "easetype", iTween.EaseType.easeInExpo));
iTween.ShakePosition(Camera.main.gameObject, iTween.Hash("y", 0.3f, "time", 0.8f, "delay", 2.0f));
iTween.ColorTo(gameObject, iTween.Hash("r", 1.0f, "g", 0.5f, "b", 0.4f, "delay", 1.5f, "time", 0.3f));
iTween.ScaleTo(gameObject, iTween.Hash("y", 1.75f, "delay", 2.8f, "time", 2.0f));
iTween.RotateBy(gameObject, iTween.Hash("x", 0.5f, "delay", 4.4f));
iTween.MoveTo(gameObject, iTween.Hash("y", 1.5f, "delay", 5.8f));
iTween.MoveTo(gameObject, iTween.Hash("y", 0.5f, "delay", 7.0f, "easetype", iTween.EaseType.easeInExpo));
iTween.ScaleTo(gameObject, iTween.Hash("y", 1.0f, "delay", 7.0f));
iTween.ShakePosition(Camera.main.gameObject, iTween.Hash("y", 0.3f, "time", 0.8f, "delay", 8.0f));
iTween.ColorTo(gameObject, iTween.Hash("r", 0.165f, "g", 0.498f, "b", 0.729f, "delay", 8.5f, "time", 0.5f));
iTween.CameraFadeAdd();
iTween.CameraFadeTo(iTween.Hash("amount", 1.0f, "time", 2.0f, "delay", 10.0f));
}
```
Запустим и посмотрим на результат. Довольно неплохо, не правда ли?
Давайте построчно разберём скрипт.
```
iTween.RotateFrom(gameObject, iTween.Hash("y", 90.0f, "time", 2.0f, "easetype", iTween.EaseType.easeInExpo));
```
Метод **RotateFrom** используется для того, чтобы вращать объект. В отличии от **RotateTo** и **RotateBy**, **RotateFrom** используется для того, чтобы инициализировать вращение указанным углом и вращать в исходное состояние. Метод, как и большинство остальных, имеет перегрузку. Можно использовать короткий или подробный вариант:
```
RotateFrom(GameObject target, Vector3 rotation, float time);
RotateFrom(GameObject target, Hashtable args);
```
Мы передаём **gameObject** — обьект, у которого находится текущий скрипт. Для того, чтобы не писать что-то вроде:
```
Hashtable args = new Hashtable();
args.Add(“y”, 90.0f);
args.Add(“time”, 2.0f);
args.Add(“easetype”, iTween.EaseType.easeInExpo);
```
Мы используем **iTween.Hash** — экспресс вариант **Hashtable**. В аргументах мы указали y=90.0f, это эквивалент (если x и z равны нулю, конечно)
```
Quaternion.Euler( new Vector3(0f, 90.0f, 0f) )
```
Тот поворот, с которого начнётся наше вращение.
```
time=2.0f
```
Время, которое должно быть затрачено на анимацию. Есть еще аналогичный аргумент под названием “**speed**”, в его случае указывается не время, а скорость, с которой будет проходить анимация. Последний аргумент, который мы указали это **easetype=iTween.EaseType.easeInExpo**. easetype это форма кривой, которая используется для интерполяции. Вот кривые в графическом представлении:
Попробуйте поэкспериментировать, если вам не понятно как это работает.
```
iTween.MoveFrom(gameObject, iTween.Hash("y", 3.5f, "time", 2.0f, "easetype", iTween.EaseType.easeInExpo));
```
**MoveFrom** аналогичен предыдущему, все должно быть понятно, просто вместо вращения используется перемещение.
```
iTween.ShakePosition(Camera.main.gameObject, iTween.Hash("y", 0.3f, "time", 0.8f, "delay", 2.0f));
```
**ShakePosition** в данном случае используется для того, чтобы имплементировать “тряску” камеры. Этот метод заставляет двигаться объект по уменьшающейся амплитуде, не использует интерполяцию, объект будет появляться в случайных точках, в отведенных ему рамках. Здесь есть новый аргумент под названием “**delay**”, это достаточно важная опция анимации, используется для того, чтобы указать время в секундах, которое должно пройти перед началом анимации.
```
iTween.ColorTo(gameObject, iTween.Hash("r", 1.0f, "g", 0.5f, "b", 0.4f, "delay", 1.5f, "time", 0.3f));
```
**ColorTo** плавно меняет цвет обьекта с течением времени.
```
iTween.ScaleTo(gameObject, iTween.Hash("y", 1.75f, "delay", 2.8f, "time", 2.0f));
```
**ScaleTo**, как видно из имени метода, изменяет размер объекта.
```
iTween.RotateBy(gameObject, iTween.Hash("x", 0.5f, "delay", 4.4f));
```
**RotateBy** напоминает **RotateFrom**, необходим в тех случаях, когда нужно развернуть объект более чем на 360 градусов (хотя, в данном случае можно было бы обойтись методом **RotateTo**). Допустим, мы указали *z=2.0f*, это будет означать, что объект должен развернуться два раза вокруг оси Z за определенный интервал времени.
```
iTween.MoveTo(gameObject, iTween.Hash("y", 1.5f, "delay", 5.8f));
iTween.MoveTo(gameObject, iTween.Hash("y", 0.5f, "delay", 7.0f, "easetype", iTween.EaseType.easeInExpo));
```
**MoveTo**, наверное, основной метод всего класса **iTween**. Он перемещает объект в указанные координаты за отведённое время. Интерполяция основана на всё том же easetype, который вам уже знаком.
Следующие новые методы:
```
iTween.CameraFadeAdd();
iTween.CameraFadeTo(iTween.Hash("amount", 1.0f, "time", 2.0f, "delay", 10.0f));
```
**CameraFadeAdd** создаёт новый объект, который используется для имитации затемнения. Глубина меняется от текущего значения к указанному в аргументах. Существуют следующие перегрузки:
```
CameraFadeAdd()
CameraFadeAdd(Texture2D texture)
CameraFadeAdd(Texture2D texture, int depth)
```
Если не указана **Texture2D**, будет использоваться чёрный цвет.
Из того, что я не описал, есть ещё важные моменты. Например, в аргументах можно указать метод, который будет вызываться при наступлении какого-то события. Допустим:
```
public class iTweenController : MonoBehaviour
{
int clbkN = 0;
GUIStyle style;
void Awake()
{
style = new GUIStyle();
style.fontSize = 60;
}
void Start()
{
iTween.MoveTo(gameObject, iTween.Hash("position", new Vector3(5.0f, 1.0f, 0.0f), "oncomplete", "myClbk",
"loopType", iTween.LoopType.loop, "speed", 2.0f));
}
void myClbk()
{
clbkN++;
}
void OnGUI()
{
GUI.Label(new Rect(10, 10, 0, 0), "Callback # "+clbkN, style);
}
}
```
Результат будет таким:
Отмечу, что использовались новые аргументы метода **MoveTo**:
```
position = new Vector3(5.0f, 1.0f, 0.0f)
```
Это короткая запись, релевантная *“x”, 5.0f, “y”, 1.0f, “z”, 0.0f*
```
oncomplete = "myClbk"
```
По завершению анимации (либо итерации цикла анимации) вызывается метод с указанным именем.
```
loopType = iTween.LoopType.loop
```
Вид анимации. В данном случае указан обычный цикл, анимация будет воспроизводится бесконечно, в начале каждой анимации объект будет перемещен в начальную позицию.
На этом, пожалуй, закончу. Всем спасибо за внимание. | https://habr.com/ru/post/220837/ | null | ru | null |
# Новогодние бенчмарки компьютеров Эльбрус
Новогодние бенчмарки компьютеров Эльбрус
========================================
Продолжение статьи [Большое тестирование процессоров различных архитектур](https://habr.com/ru/company/icl_services/blog/501588/). В этот раз я решил измерить производительность конкретных сред/языков программирования (C#, Java, JavaScript, Python, Lua) на компьютерах с процессорами Эльбрус и сравнить их с компьютерами (даже телефонами) на процессорах архитектурой ARM и X86-64.
Языки программирования:
* C#
* PHP
* JavaScript (Browser, не NodeJS)
* Java
* Python
* Lua
Список тестов
* Dhrystone (<http://www.roylongbottom.org.uk/#anchorSource>)
* Whetstone (<http://www.roylongbottom.org.uk/#anchorSource>)
* Scimark 2 (Original sources: <https://math.nist.gov/scimark2/download.html>)
* Linpack (Based on: <https://github.com/fommil/netlib-java/blob/master/perf/src/main/java/com/github/fommil/netlib/Linpack.java>)
* Generic:
+ Loops
+ Conditions
+ Arithmetics
+ Math
+ Array speed
+ String manipulation
+ Hash algorithms
Но сперва приведу результаты нативных бенчмарков на языке C, а также результаты других популярных бенчмарков.
Тестовые стенды и их процессоры
-------------------------------
А пока можете опробовать JavaScript версию бенчмарка: <http://laseroid.azurewebsites.net/js-bench/>
Стенды на процессорах x86 (i386) х86-64 (amd64):
* [Core i7-2600, 4 ядра 8 потоков, 3.4 ГГц](https://ark.intel.com/content/www/us/en/ark/products/52213/intel-core-i7-2600-processor-8m-cache-up-to-3-80-ghz.html)
* [AMD A6-3650, 4 ядра, 2.6 ГГц](https://www.cpu-world.com/CPUs/K10/AMD-A-Series%20A6-3650%20AD3650WNZ43GX%20%28AD3650WNGXBOX%29.html)
* [Atom Z8350, 4 ядра, 1440 МГц](https://ark.intel.com/content/www/us/en/ark/products/93361/intel-atom-x5-z8350-processor-2m-cache-up-to-1-92-ghz.html)
* [Core i3-m330, 2 ядра 4 потока, 2.13 ГГц](https://ark.intel.com/content/www/us/en/ark/products/47663/intel-core-i3-330m-processor-3m-cache-2-13-ghz.html)
* [Pentium 4 2800, 1 ядро, 2.8 ГГц](https://ark.intel.com/content/www/us/en/ark/products/27499/intel-pentium-4-processor-supporting-ht-technology-3-06-ghz-512k-cache-533-mhz-fsb.html)
* [Allwinner A64 (Orange Pi Win), 4 ядра Cortex A53, 1152 МГц](http://www.orangepi.org/OrangePiWinPlus/0)
* [Qualcomm 625 (Xiaomi Note 4X), 8 ядер, 2 ГГц](https://www.qualcomm.com/products/snapdragon-625-mobile-platform)
* [Эльбрус 8С 1300 МГц, 8 ядер](http://www.mcst.ru/elbrus-8c)
* [Эльбрус 8С x4 1300 МГц, 8 ядер (сервер 4 процессорный)](http://www.ineum.ru/elbrus_804_1u0)
* [Эльбрус 8СВ 1550 МГц](http://www.mcst.ru/elbrus-8sv)
* [Эльбрус 2С+ 500 МГц, 2 ядра](http://www.mcst.ru/elbrus_2c_plus)
* [Эльбрус 4C 750/800 Мгц, 4 ядра](http://www.mcst.ru/mikroprocessor-elbrus4s)
* [Эльбрус 1C+ 985/1000 МГц, 1 ядро](http://www.mcst.ru/elbrus-1c-plus)
Компилируемые бенчмарки на C/C++
--------------------------------
### Таблица с результатами с прошлой статьи
**Результаты нативных бенчмарков**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/NativeBenchmarks.png?raw=true)
Тут выходит так: компьютеры на Эльбрусах имеют сопоставимую производительность с Intel Core i7 2600, если бы он работал на частоте 1200 — 1300 МГц (Для Эльбрус-8С), кроме теста MP MFLOPS, который хорошо распараллеливается компилятором **LCC** и для Эльбрус 8СВ выдаёт 325 ГФлопс, где Core i7 2600 выдавал
85 ГФлопс (Это с SSE, без AVX).
### Задержки кеша. Тест TLB от Линуса Торвальдса
| Cpu | Elbrus 2C+ | Elbrus 4C | Elbrus 8C | Elbrus 8CB | Elbrus R1000 | Allwinner A64 | Amd A6 3650 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Freq (MHz) | 500 | 750 | 1300 | 1550 | 1000 | 1152 | 2600 |
| Cores | 2 | 4 | 8 | 8 | 4 | 4 | 4 |
| 4k | 14.02ns | 4.04ns | 2.51ns | 1.94ns | 45.01ns | 3.48ns | 1.16ns |
| 4k cycles | 7.0 | 3.0 | 3.0 | 3.0 | 5.0 | 4.0 | 3.0 |
| 8k | 14.02ns | 4.04ns | 2.51ns | 1.94ns | 5.01ns | 3.48ns | 1.16ns |
| 8k cycles | 7.0 | 3.0 | 3.0 | 3.0 | 5.0 | 4.0 | 3.0 |
| 16k | 14.02ns | 4.04ns | 2.51ns | 1.94ns | 5.01ns | 3.48ns | 1.16ns |
| 16k cycles | 7.0 | 3.0 | 3.0 | 3.0 | 5.0 | 4.0 | 3.0 |
| 32k | 14.03ns | 4.04ns | 2.51ns | 1.94ns | 5.16ns | 3.58ns | 1.16ns |
| 32k cycles | 7.0 | 3.0 | 3.0 | 3.0 | 5.2 | 4.1 | 3.0 |
| 64k | 14.04ns | 4.06ns | 2.51ns | 1.94ns | 23.45ns | 6.83ns | 1.16ns |
| 64k cycles | 7.0 | 3.0 | 3.0 | 3.0 | 23.4 | 7.9 | 3.0 |
| 128k | 18.04ns | 14.83ns | 9.19ns | 7.10ns | 23.75ns | 7.28ns | 4.00ns |
| 128k cycles | 9.0 | 11.1 | 11.0 | 11.0 | 23.7 | 8.4 | 10.4 |
| 256k | 24.97ns | 14.82ns | 9.19ns | 7.10ns | 23.98ns | 7.69ns | 4.00ns |
| 256k cycles | 12.5 | 11.1 | 11.0 | 11.0 | 24.0 | 48.9 | 10.4 |
| 512k | 22.26ns | 14.82ns | 9.28ns | 7.13ns | 24.12ns | 8.04ns | 4.00ns |
| 512k cycles | 11.1 | 11.1 | 11.1 | 11.1 | 24.1 | 9.3 | 10.4 |
| 1M | 67.80ns | 14.83ns | 27.57ns | 21.31ns | 24.07ns | 34.36n | 4.03ns |
| 1M cycles | 33.9 | 11.1 | 33.1 | 33.0 | 24.1 | 39.6 | 10.5 |
| 2M | 106.21ns | 22.49ns | 27.56ns | 21.31ns | 46.62ns | 37.05n | 12.14ns |
| 2M cycles | 53.1 | 16.9 | 33.1 | 33.0 | 46.6 | 42.7 | 31.6 |
| 4M | 107.51ns | 120.65ns | 27.56ns | 21.31ns | 119.53ns | 37.36n | 12.06ns |
| 4M cycles | 53.8 | 90.5 | 33.1 | 33.0 | 119.5 | 43.0 | 31.3 |
| 8M | 107.92ns | 121.18ns | 27.57ns | 21.31ns | 141.08ns | 37.37n | 12.21ns |
| 8M cycles | 54.0 | 90.9 | 33.1 | 33.0 | 141.1 | 43.0 | 31.7 |
| 16M | 107.86ns | 121.27ns | 47.72ns | 31.54ns | 143.90ns | 37.57n | 12.01ns |
| 16M cycles | 53.9 | 90.9 | 57.3 | 48.9 | 143.9 | 43.3 | 31.2 |
| 32M | 107.91ns | 119.22ns | 111.71ns | 117.28ns | 144.34ns | 37.09n | 12.02ns |
| 32M cycles | 54.0 | 89.4 | 134.1 | 181.8 | 144.3 | 42.7 | 31.3 |
| 64M | 107.91ns | 119.48ns | 149.90ns | 117.39ns | 144.36ns | 37.07n | 11.98ns |
| 64M cycles | 54.0 | 89.6 | 179.9 | 182.0 | 144.4 | 42.7 | 31.2 |
| 128M | 107.91ns | 121.75ns | 169.79ns | 117.51ns | 144.42ns | 37.57n | 12.02ns |
| 128M cycles | 54.0 | 91.3 | 203.7 | 182.1 | 144.4 | 43.3 | 31.3 |
| 256M | 107.97ns | 122.11ns | 174.90ns | 117.58ns | 144.34ns | 37.77n | 12.21ns |
| 256M cycles | 54.0 | 91.6 | 209.9 | 182.3 | 144.3 | 43.5 | 31.7 |
Задержки кеша на Эльбруса 8СВ таковы:
* L1: 3 такта с 1,94 нс
* L2: 11 тактов с 7,1 нс
* L3: 33 такта с 21,31 нс
* ОЗУ: 90-180 тактов с 117 нс
Характеристики кеша для Эльбрус 8С можно посмотреть здесь: [Архитектура Эльбрус 8С](http://mcst.ru/files/57571b/cf0cd8/50722d/000000/alfonsodemenkokozhin_i_dr-mikroarhitektura_vosmiyadernogo_mikroprotsessora.pdf)
Исходный код: [Test TLB](https://github.com/EntityFX/test-tlb)
### Тесты памяти STREAM
> Array size = 10000000 (elements), Offset = 0 (elements)
>
>
>
> Memory per array = 76.3 MiB (= 0.1 GiB).
>
>
>
> Total memory required = 228.9 MiB (= 0.2 GiB).
| CPU | Frequency | Threads | Memory Type | Copy (MB/s) | Scale (MB/s) | Add (MB/s) | Triad (MB/s) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Elbrus 4C | 750 | 4 | DDR3-1600 | 9 436.30 | 9 559.70 | 10 368.50 | 10 464.80 |
| Elbrus 8C | 1300 | 8 | DDR3-1600 | 11 406.70 | 11 351.70 | 12 207.50 | 12 355.10 |
| Elbrus 8CB | 1550 | 8 | DDR4-2400 | 23 181.80 | 22 965.20 | 25 423.90 | 25 710.20 |
| Allwinner A64 | 1152 | 4 | LPDDR3-800 | 2 419.90 | 2 421.30 | 2 112.70 | 2 110.10 |
| AMD A6-3650 | 2600 | 4 | DDR3-1333 | 6 563.60 | 6 587.90 | 7 202.80 | 7 088.00 |
Исходный код: [STREAM](https://github.com/jeffhammond/STREAM)
### Geekbench 4/5 (В режиме RTC: x86 -> e2k трансляция)
Geekbench 5
| CPU | Frequency | Threads | Single Thread | Multi Thread |
| --- | --- | --- | --- | --- |
| [Эльбрус 8С](https://browser.geekbench.com/v5/cpu/3111363) | 1300 | 8 | 142 | 941 |
| [Эльбрус 8СВ](https://browser.geekbench.com/v5/cpu/5537127) | 1550 | 8 | 159 | 1100 |
| [Intel Core i7 2600](https://browser.geekbench.com/v5/cpu/3462610) | 3440 | 8 | 720 | 2845 |
| [Amd A6 3650](https://browser.geekbench.com/v5/cpu/3444484) | 2600 | 4 | 345 | 1200 |
Geekbench 4
| CPU | Frequency | Threads | Single Thread | Multi Thread |
| --- | --- | --- | --- | --- |
| [Эльбрус 8С](https://browser.geekbench.com/v4/cpu/15659929) | 1300 | 8 | 873 | 3398 |
| [Эльбрус 8СВ](https://browser.geekbench.com/v4/cpu/15659957) | 1550 | 8 | 983 | 4042 |
| [Intel Pentium 4](https://browser.geekbench.com/v4/cpu/15717223) | 2800 | 1 | 795 | 766 |
| [Intel Core i7 2600](https://browser.geekbench.com/v4/cpu/15959140) | 3440 | 8 | 3702 | 12063 |
| [Qualcomm 625](https://browser.geekbench.com/v4/cpu/15659967) | 2000 | 8 | 852 | 2829 |
### Crystal Mark 2004 (В режиме RTC: x86 -> e2k трансляция)
| CPU | Threads | Frequency | ALU | FPU | MEM R (Mb/s) | MEM W (Mb/s) | Anounced |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 486 DX4 | 1 | 75 | 119 | 77 | 9 | 11 | 1993 |
| P1 (P54C) | 1 | 200 | 484 | 420 | 80 | 65 | 1994 |
| P1 MMX (P55C) | 1 | 233 | 675 | 686 | 112 | 75 | 1997 |
| P2 | 1 | 400 | 1219 | 1260 | 222 | 150 | 1998 |
| Transmeta Crusoe TM5800 | 1 | 1000 | 2347 | 1689 | 405 | 223 | 2000 |
| P3 (Coopermine) | 1 | 1000 | 3440 | 3730 | 355 | 170 | 2000 |
| P4 (Willamete) | 1 | 1600 | 3496 | 4110 | 1385 | 662 | 2001 |
| Celeron (Willamete) | 1 | 1800 | 3934 | 4594 | 1457 | 657 | 2001 |
| Athlon XP (Palomino) | 1 | 1400 | 4450 | 6220 | 430 | 520 | 2001 |
| P4 (Northwood) | 1 | 2400 | 5661 | 6747 | 1765 | 754 | 2002 |
| P4 (Prescott) | 1 | 2800 | 5908 | 6929 | 3744 | 851 | 2004 |
| Athlon 64 (Venice) | 1 | 1800 | 6699 | 7446 | 1778 | 906 | 2005 |
| Celeron 530 (Conroe-L) | 1 | 1733 | 7806 | 9117 | 3075 | 1226 | 2006 |
| P4 (Prescott) | 2 | 3000 | 9719 | 10233 | 3373 | 1578 | 2004 |
| Atom D525 | 4 | 1800 | 10505 | 7605 | 3407 | 1300 | 2010 |
| Athlon 64 X2 (Brisbane) | 2 | 2300 | 16713 | 19066 | 3973 | 2728 | 2007 |
| Core i3-6100 | 2 | 3700 | 17232 | 10484 | 5553 | 9594 | 2015 |
| Pentium T3200 (Merom) | 2 | 2000 | 20702 | 18063 | 4150 | 1598 | 2008 |
| Atom x5-Z8350 | 4 | 1440 | 21894 | 18018 | 4799 | 2048 | 2016 |
| Core i3-M330 | 4 | 2133 | 25595 | 26627 | 6807 | 4257 | 2010 |
| Core 2 Duo | 2 | 3160 | 28105 | 18196 | 6850 | 2845 | 2008 |
| Atom Z3795 | 4 | 1600 | 40231 | 34963 | 12060 | 5797 | 2016 |
| AMD A6-3650 | 4 | 2600 | 46978 | 35315 | 9711 | 3870 | 2011 |
| Core 2 Quad | 4 | 2833 | 47974 | 31391 | 9710 | 5493 | 2008 |
| Core i3-4130 | 4 | 3400 | 54296 | 39163 | 19450 | 9269 | 2013 |
| AMD Phenom II X4 965 (Agena) | 4 | 3400 | 59098 | 56272 | 11162 | 5973 | 2009 |
| Core i7-2600 | 8 | 3400 | 95369 | 71648 | 19547 | 9600 | 2011 |
| Core i7-9900K | 16 | 3600 | 270445 | 238256 | 44618 | 17900 | 2018 |
| Elbrus-8C RTC-x86 | 8 | 1300 | 65817 | 29977 | 49800 | 7945 | 2016 |
| Elbrus-8CB RTC-x86 | 8 | 1500 | 77481 | 37972 | 62100 | 13940 | 2018 |
| Elbrus-1C+ RTC-x86 | 1 | 1000 | 6862 | 2735 | 6230 | 1800 | 2015 |
Процессор Эльбрус-8С 1.3 ГГц на уровне AMD Phenom II X4 965 3.4 ГГц 4 ядра. 8СВ на 20% быстрее.
Бенчмарки сред/языков программирования
--------------------------------------
А теперь переходим к бенчмаркам языков программирования (C#, Java, JavaScript, Python, Lua).
Исходный код здесь: <https://github.com/EntityFX/EntityFX-Bench>
Исходный код для прощлых бенчмарков можете найти тут: <https://github.com/EntityFX/anybench>
### Микро бенчмарки
В цикле с большим числоv итераций проводим некоторые операции и замеряем время выполнения данного куска кода. Ниже буду приводить примеры на языке Python.
#### Arithmetics
Замеряет скорость арифметики: в цикле выполняет различные математические операции с замером времени выполнения.
Пример кода на Python:
```
@staticmethod
def _doArithmetics(i : int) -> float:
return math.floor(i / 10) * math.floor(i / 100) * math.floor(i / 100) * math.floor(i / 100) * 1.11) + math.floor(i / 100) * math.floor(i / 1000) * math.floor(i / 1000) * 2.22 - i * math.floor(i / 10000) * 3.33 + i * 5.33
```
#### Math
Замеряет скорость математических функций (Cos, Sin, Tan, Log, Power, Sqrt):
```
@staticmethod
def _doMath(i : int, li : float) -> float:
rev = 1.0 / (i + 1.0)
return (math.fabs(i) * math.acos(rev) * math.asin(rev) * math.atan(rev) + math.floor(li) + math.exp(rev) * math.cos(i) * math.sin(i) * math.pi) + math.sqrt(i)
```
#### Loops
Замеряет скорость работы холостых циклов. Кстати, некоторые компиляторы и рантаймы могут оптимизировать этот код.
#### Conditions
Замеряет скорость работы условий.
```
d = 0
i = 0; c = -1
while i < self._iterrations:
c = ((-1 if c == (-4) else c))
if (i == (-1)):
d = 3
elif (i == (-2)):
d = 2
elif (i == (-3)):
d = 1
d = (d + 1)
i += 1; c -= 1
return d
```
#### Array speed (Memory, Random Memory)
Замеряет скорость чтения из массива в переменную (последовательно или со случайными индексами)
**Большой кусок кода на Python**
```
def _measureArrayRead(self, size) :
block_size = 16
i = [0] * block_size
array0_ = list(map(lambda x: random.randint(-2147483647, 2147483647), range(0, size)))
end = len(array0_) - 1
k0 = math.floor(size / 1024)
k1 = 1 if k0 == 0 else k0
iter_internal = math.floor(self._iterrations / k1)
iter_internal = 1 if iter_internal == 0 else iter_internal
idx = 0
while idx < end:
i[0] = (array0_[idx])
i[1] = (array0_[idx + 1])
i[2] = (array0_[idx + 2])
i[3] = (array0_[idx + 3])
i[4] = (array0_[idx + 4])
i[5] = (array0_[idx + 5])
i[6] = (array0_[idx + 6])
i[7] = (array0_[idx + 7])
i[8] = (array0_[idx + 8])
i[9] = (array0_[idx + 9])
i[0xA] = (array0_[idx + 0xA])
i[0xB] = (array0_[idx + 0xB])
i[0xC] = (array0_[idx + 0xC])
i[0xD] = (array0_[idx + 0xD])
i[0xE] = (array0_[idx + 0xE])
i[0xF] = (array0_[idx + 0xF])
idx += block_size
start = time.time()
it = 0
while it < iter_internal:
idx = 0
while idx < end:
i[0] = (array0_[idx])
i[1] = (array0_[idx + 1])
i[2] = (array0_[idx + 2])
i[3] = (array0_[idx + 3])
i[4] = (array0_[idx + 4])
i[5] = (array0_[idx + 5])
i[6] = (array0_[idx + 6])
i[7] = (array0_[idx + 7])
i[8] = (array0_[idx + 8])
i[9] = (array0_[idx + 9])
i[0xA] = (array0_[idx + 0xA])
i[0xB] = (array0_[idx + 0xB])
i[0xC] = (array0_[idx + 0xC])
i[0xD] = (array0_[idx + 0xD])
i[0xE] = (array0_[idx + 0xE])
i[0xF] = (array0_[idx + 0xF])
idx += block_size
it += 1
elapsed = time.time() - start
return (iter_internal * len(array0_) * 4 / elapsed / 1024 / 1024, i)
```
#### String manipulation
Скорость работы со строковыми функциями (replace, upper, lower)
```
@staticmethod
def _doStringManipilation(str0_ : str) -> str:
return ("/".join(str0_.split(' ')).replace("/", "_").upper() + "AAA").lower().replace("aaa", ".")
```
#### Hash algorithms
Алгоритмы SHA1 и SHA256 над байтами строк.
```
@staticmethod
def _doHash(i : int, prepared_bytes):
hashlib.sha1()
sha1_hash = hashlib.sha1(prepared_bytes[i % 3]).digest()
sha256_hash = hashlib.sha256(prepared_bytes[(i + 1) % 3]).digest()
return sha1_hash + sha256_hash
```
### Комплексные бенчмарки
Выполнил реализацию популярных бенчмарков Dhrystone, Whetstone, LINPACK, Scimark 2 на всех 5 языках программирования (конечно же использовал существующие исходники, но адаптировал под мои тесты).
#### Dhrystone
> Dhrystone — синтетический тест, который был написан Reinhold P. Weicker в 1984 году.
>
> Данный тест не использует операции с плавающей запятой, а версия 2.1 написана так, чтобы исключить возможность сильных оптимизаций при компиляции.
>
> Бенчмарк выдаёт результаты в VAX Dhrystones в секунду, где 1 VAX DMIPS = Dhrystones в секунду делить на 1757.
#### Whetstone
> Whetstone — синтетический тест, который был написан Harold Curnow в 1972 году на языке Fortran.
>
> Позже был переписан на языке C Roy Longbottom. Данный тест выдаёт результаты в MWIPS,
>
> также промежуточные результаты в MOPS (Миллионов операций в секунду) и MFLOPS (Миллионы вещественных операций с плавающей запятой в секунду).
>
> Данный тест производит различные подсчёты: производительность целочисленных и операций с плавающей запятой,
>
> производительность операций с массивами, с условным оператором, производительность тригонометрических функций и функций возведения в степень, логарифмов и извлечения корня.
#### LINPACK
> LINPACK — тест, который был написан Jack Dongarra на языке Fortran в 70х годах, позже переписан на язык C.
>
> Тест считает системы линейных уравнений, делает различные операции над двумерными (матрицами) и одномерными (векторами).
>
> Используется реализация Linpack 2000x2000.
#### Scimark 2
> SciMark 2 — набор тестов на языке C измеряющий производительность кода встречающегося в научных и профессиональных приложениях. Содержит в себе 5 вычислительных тестов: FFT (быстрое преобразование Фурье), Gauss-Seidel relaxation (Метод Гаусса — Зейделя для решения СЛАУ), Sparse matrix-multiply (Умножение разреженных матриц), Monte Carlo integration (Интегрирование методом Монте-Карло), и LU factorization (LU-разложение).
Переходим к результатам.
Результаты
----------
### Бенчмарки Java
**Результаты нативных бенчмарков**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/JavaBenchmarks.png?raw=true)
Результаты Java на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:
* Эльбрус 1С+ в 11 раз медленнее на 1 поток
* Эльбрус 4С в 10 раз медленнее на 1 поток
* Эльбрус 8С в 5,5 раз медленнее на 1 поток
* Эльбрус 8СВ в 4,5 раз медленнее на 1 поток
* Эльбрус 1С+ в 18 раз медленнее на всех потоках
* Эльбрус 4С в 12,5 раз медленнее на всех потоках
* Эльбрус 8С в 3 раз медленнее на всех потоках
* Эльбрус 8СВ в 2,5 раз медленнее на всех потоках
Результаты Java на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:
* Эльбрус 1С+ в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 2,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 2 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 2 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
* Эльбрус 1С+ в 5 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 2,75 раз медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 1,15 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,15 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц
Для Java делали очень серьёзные оптимизации, поэтому отставание в 2 раза на одинаковых частотах не является плохим результатом.
Про то, как оптимизировали Java можно почитать тут: [Java на Эльбрусе](https://students.jpoint.ru/presentations/track_3/Elbrus_sd_jpoint_pptx.pdf)
Посмотреть здесь:
### Бенчмарки C# (.Net Framework, .Net Core, Mono)
**Результаты бенчмарков на C#**
Так как сред исполнения несколько (.Net Framework, .Net Core, Mono), то я старался сравнивать одинаковые среды исполнения, т. е. Mono на e2k c Mono на x86.
Результаты C# (Mono) на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:
* Эльбрус 1С+ в 15,5 раз медленнее на 1 поток
* Эльбрус 4С в 19 раз медленнее на 1 поток
* Эльбрус 8С в 10,5 раз медленнее на 1 поток
* Эльбрус 8СВ в 8 раз медленнее на 1 поток
* Эльбрус 1С+ в 24 раз медленнее на всех потоках
* Эльбрус 4С в 12,5 раз медленнее на всех потоках
* Эльбрус 8С в 4,5 раз медленнее на всех потоках
* Эльбрус 8СВ в 4 раз медленнее на всех потоках
Результаты C# (Mono) на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:
* Эльбрус 1С+ в 4,5 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 4,2 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 3 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 3 раза медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
* Эльбрус 1С+ в 7 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 3 раза медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 1,5 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,2 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц
Результаты C# (NetCore) в режиме RTC на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:
* Эльбрус 8С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 3 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
* Эльбрус 8С в 2 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,5 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц
Результаты C# (NetCore) в режиме RTC на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:
* Эльбрус 8С в 1,3 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,2 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
* Эльбрус 8С в 1,25 раза быстрее на всех потоках Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,25 раза быстрее на всех потоках Core i7 2600 на частоте 1,55 ГГц
Mono сам по себе является достаточно медленной средой выполнения по сравнению с Net Fremework, а особенно с NetCore (до 3х раз). Что достаточно допустимо. Здесь я не знаю, делали ли оптимизации как это было сделано с Java.
Выходит NetCore в режиме RTC на Эльбрусах работает до 4х раз быстрее чем Mono. Будем ждать нативного NetCore для e2k.
### Бенчмарки JavaScript (Браузерные)
JavaScript версия бенчмарка: <http://laseroid.azurewebsites.net/js-bench/>
**Результаты бенчмарков на JavaScript**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/JavaScriptBenchmarks.png?raw=true)
Результаты JavaScript на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:
* Эльбрус 1С+ в 16 раз медленнее
* Эльбрус 4С в 12,5 раз медленнее
* Эльбрус 8С в 6,5 раз медленнее
* Эльбрус 8СВ в 5 раз медленнее
Результаты JavaScript на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:
* Эльбрус 1С+ в 5 раз медленнее Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 2,75 раза медленнее Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 2,5 раза медленнее Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 2,25 раз медленнее Core i7 2600 на частоте 1,55 ГГц
#### Другие популярные JavaScript бенчмарки
[Octane](https://chromium.github.io/octane/)
Firefox (версии разные)
| Cpu | Result (баллы) |
| --- | --- |
| Intel Core i7 2600 | 23321 |
| AMD A6-3650 | 11741 |
| Intel Pentium 4 2800 | 3387 |
| Elbrus 8C (rtc x86 32bit) | 2815 |
| Elbrus 8C | 2102 |
| Elbrus 1C+ | 739 |
[Kraken Benchmark](https://krakenbenchmark.mozilla.org/kraken-1.1/driver)
Firefox (версии разные)
| Cpu | Result (ms) |
| --- | --- |
| Elbrus 8C | 10493.4 |
| Elbrus 8CB RTC x86 | 9567.5 |
| Elbrus 8CB | 8714.2 |
| Intel Pentium 4 2800 | 9486.6 |
| AMD A6-3650 | 3052.5 |
| Intel Core i7 2600 (3.4 GHz) | 1456.8 |
[Sunspider](https://webkit.org/perf/sunspider-1.0.2/sunspider-1.0.2/driver.html)
Firefox (версии разные)
| Cpu | Result (ms) |
| --- | --- |
| Elbrus 8C | 3059.8 |
| Elbrus 8CB | 2394.6 |
| Intel Pentium 4 2800 | 1295.5 |
| AMD A6-3650 | 485.6 |
| Intel Core i7 2600 (3.4 GHz) | 242.9 |
Результаты слабоваты. Причина: низкие тактовые частоты и недостаточная оптимизация. Но это гораздо лучше, чем было раньше. Также браузер FX52 уже старый, а будет новая, надеюсь, там уже допилили JavaScript.
### Бенчмарки PHP
**Результаты бенчмарков на PHP**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/PHPBenchmarks.png?raw=true)
Результаты PHP на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:
* Эльбрус 2С+ в 15,5 раз медленнее
* Эльбрус 1С+ в 8 раз медленнее
* Эльбрус 4С в 4,5 раза медленнее
* Эльбрус 8С в 3 раза медленнее
* Эльбрус 8СВ в 2,5 раза медленнее
* Эльбрус R1000 в 12,5 раз медленнее
Результаты PHP на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:
* Эльбрус 2С+ в 2,3 раз медленнее Core i7 2600 на частоте 0,5 ГГц
* Эльбрус 1С+ в 2,3 раз медленнее Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С = Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 1,1 раза медленнее Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,1 раза медленнее Core i7 2600 на частоте 1,55 ГГц
* Эльбрус R1000 в 3,75 раз медленнее Core i7 2600 на частоте 1 ГГц
PHP показывает почти равную скорость на одинаковых частотах с Intel процессорами. Причина проста: здесь МЦСТ делали оптимизацию. Очень удивительно для интерпретируемого языка. Кстати, хочу обратить внимание на то что PHP 7.4 стал быстрее версии PHP 5.6 в 1,5 раза, поэтому я запускал бенчмарки на 2х версиях на Core i7 2600.
#### Другие популярные PHP бенчмарки
[PHP Simple Benchmark](https://github.com/rusoft/php-simple-benchmark-script)
| Test | Elbrus 8C | Elbrus 8CB | Pentium 4 2800 | AMD A6-3650 | Core i7-2600 | | Allwinner A64 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Frequency | 1300 | 1550 | 2800 | 2600 | 3400 | | 1152 |
| CPU Threads | 8 | 8 | 1 | 4 | 8 (4) | | 4 |
| Version | 7.0.33 | 7.0.33 | 7.2.24 | 7.4.3 | 7.0.33 | 5.6.20 | 7.0.33 |
| 01\_math (kOp/s) | 58.15 | 69.72 | 104.19 | 295.97 | 308.94 | 131.73 | 44.33 |
| 02\_string\_concat (MOp/s) | 3.56 | 3.92 | 4.00 | 13.15 | 5.52 | 0.56 | 3.07 |
| 03\_1\_string\_number\_concat (kOp/s) | 418.29 | 472.77 | 631.10 | 1510.00 | 1680.00 | 1600.00 | 332.99 |
| 03\_2\_string\_number\_format (kOp/s) | 506.39 | 573.89 | 724.44 | 1690.00 | 1810.00 | 1620.00 | 432.88 |
| 04\_string\_simple\_functions (kOp/s) | 77.06 | 91.50 | 198.03 | 332.67 | 39.12 | 57.60 | 59.48 |
| 05\_string\_multibyte (kOp/s) | 2.48 | 2.90 | -.-- | 57.53 | 11.01 | 12.77 | 2.50 |
| 06\_string\_manipulation (kOp/s) | 22.10 | 26.91 | 78.96 | 127.08 | 14.11 | 23.96 | 35.73 |
| 07\_regex (kOp/s) | 48.24 | 54.60 | 128.41 | 233.76 | 334.99 | 62.43 | 47.64 |
| 08\_1\_hashing (kOp/s) | 113.58 | 132.62 | 180.46 | 306.24 | 345.52 | 270.31 | 71.44 |
| 08\_2\_crypt (Op/s) | 361.21 | 403.62 | 571.99 | 813.60 | 460.00 | 454.15 | 238.00 |
| 09\_json\_encode (kOp/s) | -.-- | -.-- | 88.33 | 233.62 | 313.52 | 191.66 | 48.67 |
| 10\_json\_decode (kOp/s) | -.-- | -.-- | 68.02 | 143.01 | 211.62 | 94.15 | 33.57 |
| 11\_serialize (kOp/s) | 73.67 | 81.57 | 130.16 | 307.52 | 435.66 | 263.06 | 62.20 |
| 12\_unserialize (kOp/s) | 63.89 | 69.02 | 79.33 | 301.98 | 348.62 | 258.75 | 46.21 |
| 13\_array\_fill (MOp/s) | 2.08 | 2.50 | 5.30 | 9.69 | 14.07 | 5.35 | 1.97 |
| 14\_array\_range (kOp/s) | 50.36 | 57.54 | 31.68 | 61.01 | 1140.00 | 30.35 | 25.25 |
| 14\_array\_unset (MOp/s) | 2.08 | 2.48 | 7.17 | 14.05 | 14.45 | 7.32 | 2.16 |
| 15\_loops (MOp/s) | 13.57 | 16.21 | 38.75 | 150.46 | 78.92 | 42.54 | 12.64 |
| 16\_loop\_ifelse (MOps/s) | 4.74 | 5.64 | 13.41 | 28.34 | 19.04 | 18.72 | 4.48 |
| 17\_loop\_ternary (MOp/s) | 3.18 | 3.79 | 7.29 | 12.10 | 11.40 | 11.85 | 2.90 |
| 18\_1\_loop\_defined\_access (MOp/s) | 3.28 | 3.90 | 9.03 | 18.90 | 18.29 | 15.35 | 3.18 |
| 18\_2\_loop\_undefined\_access (MOp/s) | 0.60 | 0.66 | 1.13 | 2.60 | 2.40 | 2.10 | 0.49 |
| 19\_type\_functions (MOp/s) | 250.57 | 293.21 | 806.37 | 1560.00 | 1180.00 | 971.77 | 193.89 |
| 20\_type\_conversion (MOp/s) | 382.32 | 458.44 | 812.72 | 1570.00 | 1530.00 | 1510.00 | 298.61 |
| 21\_0\_loop\_exception\_none (MOp/s) | 7.45 | 8.91 | 19.67 | 56.57 | 26.35 | 15.67 | 6.97 |
| 21\_1\_loop\_exception\_try (MOp/s) | 6.48 | 7.74 | 19.11 | 52.18 | 23.61 | 18.99 | 6.39 |
| 21\_2\_loop\_exception\_catch (kOp/s) | 184.22 | 216.00 | 573.09 | 1380.00 | 1240.00 | 498.60 | 147.28 |
| 22\_loop\_null\_op (MOp/s) | 3.25 | 3.74 | 8.39 | 16.03 | 17.62 | -.-- | 3.08 |
| 23\_loop\_spaceship\_op (MOp/s) | 4.30 | 5.12 | 8.50 | 17.98 | 20.39 | -.-- | 3.96 |
| 24\_xmlrpc\_encode (Op/) | -.-- | -.-- | -.-- | -.-- | 17.6 | -.-- | -.-- |
| 25\_xmlrpc\_decode (Op/) | -.-- | -.-- | -.-- | -.-- | 9.16 | -.-- | -.-- |
| 26\_1\_class\_public\_properties (MOp/s) | 3.32 | 4.08 | 10.51 | 26.70 | 19.57 | 9.42 | 3.22 |
| 26\_2\_class\_getter\_setter (MOp/s) | 1.31 | 1.51 | 4.66 | 9.41 | 5.52 | 4.13 | 0.97 |
| 26\_3\_class\_magic\_methods (MOp/s) | 0.52 | 0.59 | 1.35 | 3.77 | 3.21 | 1.89 | 0.41 |
| Total (MOp/s) | 1.23 | 1.43 | 2.60 | 5.33 | 2.48 | 2.02 | 0.98 |
| Time (sec) | 488.324 | 419.895 | 231.485 | 113.087 | 252.376 | 261.652 | 609.787 |
### Бенчмарки Python
**Результаты бенчмарков на Python**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/PythonBenchmarks.png?raw=true)
Так как под Windows не удалось запустить многопоточный Python (я не Питонист, да и времени сделать универсальную многопоточность на всех ОС не было, принимаю патчи), приведу относительно Amd A6 3650, который на 40% медленнее Core i7.
Результаты Python на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:
* Эльбрус 2С+ в 30 раз медленнее на 1 поток
* Эльбрус 1С+ в 12,5 раз медленнее на 1 поток
* Эльбрус 4С в 15,5 раз медленнее на 1 поток
* Эльбрус 8С в 9 раз медленнее на 1 поток
* Эльбрус 8СВ в 7,8 раз медленнее на 1 поток
* Эльбрус 2С+ в 58 раз медленнее на всех потоках
* Эльбрус 1С+ в 25 раз медленнее на всех потоках
* Эльбрус 4С в 13,5 раз медленнее на всех потоках
* Эльбрус 8С в 4,2 раза медленнее на всех потоках
* Эльбрус 8СВ в 3,8 раза медленнее на всех потоках
Результаты Python на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:
* Эльбрус 2С+ в 4,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,5 ГГц
* Эльбрус 1С+ в 3,6 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
* Эльбрус 2С+ в 8,5 раз медленнее на всех потоках Core i7 2600 на частоте 0,5 ГГц
* Эльбрус 1С+ в 7,4 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 3 раз медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 1,5 раза медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 1,35 раза медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц
Во первых, для Python пока не делалось оптимизаций, которые повысили бы производительность. Во вторых, интерпретируемые языки плохо подходят к VLIW-архитектуре Эльбруса. Но МЦСТ советуют использовать CPython для производительности (Python -> C, а затем компилируем с помощью LCC). Про PyPy c Jit пока ничего не известно, но если потребуется, то такая среда выполнения будет реализована, а это сильно повысит производительность.
Также было замечено, что в некоторых случаях Python в режиме RTC (двоичная трансляция x86-64 в e2k) показывает большую производительность: в арифметике и математике. Значит есть ещё потенциал для оптимизации Python, возможно даже в 2 раза.
### Бенчмарки Lua
**Результаты бенчмарков на Lua**
[Ссылка на картинку](https://github.com/EntityFX/EntityFX-Bench/blob/master/results/doc/LuaBenchmarks.png?raw=true)
Результаты Lua на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:
* Эльбрус 2С+ в 16 раз медленнее
* Эльбрус 1С+ в 6 раз медленнее
* Эльбрус 4С в 10 раз медленнее
* Эльбрус 8С в 6 раз медленнее
* Эльбрус 8СВ в 5 раз медленнее
* Эльбрус R1000 в 9 раз медленнее
Результаты Lua на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:
* Эльбрус 2С+ в 2,4 раза медленнее Core i7 2600 на частоте 0,5 ГГц
* Эльбрус 1С+ в 1,75 раза медленнее Core i7 2600 на частоте 1 ГГц
* Эльбрус 4С в 2 раза медленнее Core i7 2600 на частоте 0,8 ГГц
* Эльбрус 8С в 2,3 раза медленнее Core i7 2600 на частоте 1,3 ГГц
* Эльбрус 8СВ в 2,2 раза медленнее Core i7 2600 на частоте 1,55 ГГц
* Эльбрус R1000 в 2,6 раз медленнее Core i7 2600 на частоте 1 ГГц
У Lua отставание всего в 2 раза на равных частотах, это достаточно терпимо для VLIW-архитектуры.
Выводы
------
Во сколько раз Core i7 2600 быстрее Эльбрусов:
Во сколько раз Core i7 2600 быстрее Эльбрусов, если бы он работал на частоте Эльбрусов:
Как мы знаем, Эльбрус имеет VLIW архитектуру, у которой повышение производительности достигается путём оптимизации компилируемого кода (Эльбрус имеет явный параллелизм). Также у Эльбруса нет предсказателя переходов и переупорядочивания инструкций (снова всё явно задаётся компилятором).
Следует:
* Компилируемые программы на C/C++ (возможно, другие) будут иметь хорошую производительность. Это достигается патчами участков кода, где нужно оптимизировать производительность и умным компилятором LCC (eLbrus C Compiler).
* Языки с JIT-трансляцией (Java, JavaScript, C# Mono) будут иметь среднюю производительность. Здесь оптимизируют саму среду исполнения. Возможно, также потребуется оптимизировать сами программы.
* Интерпретируемые языки (PHP, Python, Lua) будут иметь низкую производительность. Но оптимизация среды выполнения позволит поднять до среднего уровня.
Другие способы:
* Доработка компилятора LCC.
* Архитектурно-специфические доработки в самой ОС.
* Улучшать архитектуру Эльбрус:
+ Поднимать частоту
+ Добавить предсказатель и т. д.
Какие языки ещё хотелось бы протестировать:
* Golang (Ждём выпуска)
* Ruby
* Perl
P.S. Поздравляем команду МЦСТ с Новым Годом. Желаем удачи в разработке следующих поколений процессоров. Ждём массового появления устройств на процессорах с архитектурой E2K!
**Другая интересная информация**
"Что такое Эльбрус?
Эльбрус — это полувековая история развития отечественной вычислительной технологии.
Это уникальная российская архитектура микропроцессора.
Это группа компаний объединенных одной идеей.
И наконец, это просто современный микропроцессор."
elbrus.ru
*Web*:
Официальный сайт: <http://elbrus.ru>
Официальная вики: <http://wiki.community.elbrus.ru>
Официальный форум: <http://forum.community.elbrus.ru>
Персональный сайт Максима Горшенина: <http://imaxai.ru>
Отличная вики на сайте ALT Linux Team: [https://www.altlinux.org/Эльбрус](https://www.altlinux.org/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81)
*Telegram*:
<https://t.me/imaxairu> — основной канал с новостями из мира микропроцессоров Эльбрус из первых рук
<https://t.me/e2k_chat> — на текущий момент основной чат по микропроцессорам Эльбрус, в котором можно пообщаться с разработчиками (организован сотрудниками компании Промобит, хорошо известной по продуктам BITBLAZE)
<https://t.me/joinchat/FUktBxkwG8FKlhdzQ7DegQ> — чат для поболтать на разные темы любителями (и не очень) микропроцессоров Эльбрус с целью не засорения основного чата ненужной информацией, одним словом флудильня фан-клуба :)
*Instagram*:
Максим Горшенин и Эльбрусы: <https://instagram.com/imaxai>
*Youtube*:
Официальный канал группы компаний Elbrus: <https://www.youtube.com/c/ElbrusTV>
Частный канал Максима Горшенина: <https://www.youtube.com/c/MaximGorshenin>
Частный канал Михаила Захарова с эмз "Звезда": <https://www.youtube.com/channel/UC3mtwuC2ugAngyO9tY2mqRw>
Канал фанатов Е2К — Elbrus PC Test (<https://www.youtube.com/channel/UC4zlCBy0eFLkE-BxgqQK8FA>):
* <https://youtu.be/wTZXJ1DJlRs> — тест Blender 2.80
* <https://youtu.be/NEcCAgtOlU8> — тест PostgreSQL 11.5
* <https://youtu.be/LcUnHXpQhnA> — SuperTuxKart
* <https://youtu.be/ZX-MKezC_Uo> — Half-Life & Counter-Strike
Серия видеороликов по Эльбрусам от Дмитрия Бачило:
* <https://youtu.be/ZP_ll1qahXQ> — распаковка
* <https://youtu.be/LS6HloN09g4> — Кремниевые Титаны
* <https://youtu.be/58XlDUOTdBI> — разборка
* <https://youtu.be/buWzWtXHimk> — тесты
* <https://youtu.be/I70_OwzHX98> — стрим с Эльбруса
Серия видеороликов по играм на Эльбрусах от Дмитрия Пугачева:
* <https://youtu.be/yEN7WlIC6B8> — Doom 3
* <https://youtu.be/yXpy0AX4pqE> — Quake 1 (darkplaces)
* <https://youtu.be/W3VryXQfUY4> — Vulkan test 01
* <https://youtu.be/XIwtYxaSanc> — SuperTuxKart
* <https://youtu.be/YbV4OlY2X1I> — Jedi Academy
* <https://youtu.be/x7flQ3wWwXo> — Quake 1 (Vulkan API)
* <https://youtu.be/nSTDFTslV2c> — Minetest
Старенький, но не устаревающий ликбез по Эльбрусам Константина Трушкина на HighLoad++ 2014: <https://youtu.be/ZTxOSGBCRec>
Актуальными моделями микропроцессоров Эльбрус являются:
* Эльбрус-8СВ (<http://mcst.ru/elbrus-8cb>)
* Эльбрус-8С (<http://mcst.ru/elbrus-8c>)
* Эльбрус-1С+ (<http://mcst.ru/elbrus-1c-plus>)
О существующих и будующих моделях микропроцессоров можно прочитать в вики [Модели процессоров Эльбрус](https://www.altlinux.org/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80%D0%BE%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81)
Альта и оф. вики [Характеристики процессоров Эльбрус](http://wiki.elbrus.ru/%D0%A5%D0%B0%D1%80%D0%B0%D0%BA%D1%82%D0%B5%D1%80%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%B8_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80%D0%BE%D0%B2_%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81)
Результаты тестирования [Результаты тестирования Эльбрус](https://www.altlinux.org/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81/%D1%82%D0%B5%D1%81%D1%82%D1%8B/%D1%80%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%D1%8B) энтузиастами дают примерную оценку производительности. И это не предел, т.к. работы над совершенствованием оптимизирующего компилятора ведутся постоянно.
Попробовать ПК с процессором Эльбрус вживую можно в [Яндекс.Музее](https://yandex.ru/profile/219658402738) в Москве.
Полезно прочитать:
Руководство по эффективному программированию на платформе «Эльбрус» <http://mcst.ru/elbrus_prog> — Нейман-заде М. И., Королёв С. Д. — 2020 [ [PDF](http://mcst.ru/files/5ed39a/dd0cd8/50506b/000000/elbrus_prog_2020-05-30.pdf) ] [ [HTML](http://mcst.ru/files/5ed3c4/750cd8/50ef27/000001/elbrus_prog_2020-05-30.tgz) ]
Микропроцессоры и вычислительные комплексы семейства «Эльбрус» (<http://mcst.ru/files/511cea/886487/1a8f40/000000/book_elbrus.pdf>) — Ким А. К., Перекатов В. И., Ермаков С. Г. — СПб.: Питер, 2013 — 272 с. ( PDF )
Операционные системы для архитектуры E2K:
АЛЬТ 8 СП (<http://altsp.su/produkty/o-produktakh/>) | Рабочая станция (<https://www.basealt.ru/products/alt-workstation/>) | Сервер (<https://www.basealt.ru/products/alt-server/>) | Образование (<https://www.basealt.ru/products/alt-education/>)
★ Astra Linux SE "Ленинград" (<http://astralinux.ru/>)
Эльбрус Линукс (<http://mcst.ru/programmnoe-obespechenie-elbrus>)
Попробовать ОС Эльбрус Линукс для x86\_64:
<https://yadi.sk/d/spqkqOAncT-aKQ>
Документация:
<https://yadi.sk/d/2shOcqIrmZQLLA>
Интересное:
Вопрос:
Зачем VLIW, давай другую?
Ответ:
1. <http://www.mcst.ru/e2k_arch.shtml>
2. <https://t.me/e2k_chat/89326>
Лекция Бориса Бабаяна "История развития архитектуры вычислительных машин":
Часть 1 — <https://youtu.be/Swk27K9m_SA>
Часть 2 — <https://youtu.be/QFD0NboTwTU> | https://habr.com/ru/post/534296/ | null | ru | null |
# JavaScript на сервере, 1ms на трансформацию
#### Зачем?
Вопрос “Зачем?” — самый главный при принятии любого решения. В нашем случае причин было несколько.
Во-первых, люди. Текущий шаблонизатор обрабатывался Си. Все вопросы о его изменениях решались не быстро. А самое главное, что писали шаблонизатор одни люди, а использовали совсем другие.
Вообще это частая и, на мой взгляд, не очень хорошая практика написания инструментов для верстальщиков. Понятно, что им нужны инструменты, но реализуют эти инструменты люди, которые весьма отдаленно себе представляют ежедневные задачи верстальщиков. Скорее наоборот, часто принимаются решения плана «дадим им писать условия и циклы, а больше на верстке ничего понадобится не может». Возможно, это вина самих верстальщиков и их квалификации.
Но в Mail.Ru Group есть целая команда высококвалифицированных людей, знающих JS, способных самостоятельно написать инструмент, а самое главное — они же им и будут пользоваться.
Во-вторых, задачи. Возьмем проект Почта@Mail.ru. Мы не можем отказаться от шаблонизации на сервере – нам нужна быстрая загрузка при первом входе. Мы не можем отказаться от шаблонизации на клиенте – люди должны видеть высокую скорость реакции на их действия, а значит, обязателен AJAX и шаблонизация на клиенте.
Проблема очевидна: два набора совершенно разных шаблонов на сервере и на клиенте. А самое обидное, что решают они одну и ту же задачу. Дублирование логики нас просто измотало.
v8 — это интерпретатор JavaScript, а значит, мы можем получить один шаблон, который работает как на сервере, так и на клиенте.
В-третьих, скорость. Прочитав много статей, в которых хвалят скорость v8, решили, что надо проверить их справедливость. Но сначала нужно было понять, каким мы хотим видеть новый шаблонизатор.
#### Что нужно
Скажу сразу, мы очень сильно ограничены по серверному времени на трансформацию, поэтому реализовывать нечто очень функциональное возможности не было. Однако и оставлять старый функционал с единственной разницей в добавлении прослойки из v8 — странная идея.
Я давно и много использую для трансформации XSLT (не самый быстрый вариант трансформации), хотя, если его правильно использовать, он показывает хорошие цифры (я говорю про libxslt). Но у XSLT есть очень мощный инструмент шаблонизации – переопределение шаблонов. Мы решили реализовать нечто похожее, но намного проще.
```
/head.xml
…
Mail.ru
/mail.xml
…
Почта Mail.ru
```
Странно было бы использовать v8 и не дать в шаблонах доступ к JavaScript.
```
var text = “mail.ru”
text
```
И еще много чего по мелочи, помимо стандартных условий и циклов.
#### XML
В качестве синтаксиса для шаблонизатора мы взяли XML.
Поддержка базового функционала в IDE. Сто процентов популярных IDE знают, что такое XML. Расстановку переносов, подсветку, базовое автодополнение вы получаете бесплатно.
Валидация на уровне IDE. Валидный HTML получается за счет валидных шаблонов. Опять же, все IDE умеют валидировать xml как таковой.
Модульность из коробки (name spaces). Базовые возможности шаблонизатора очень быстро захочется расширить. Например, добавить тег, который позволяет делать проекты на нескольких языках. Система Name Spaces позволяет легко это сделать.
Широкий набор готовых инструментов. За много лет скопилось множество инструментов для обработки XML, например, библиотеки по обработке XML посредством XSL или целый класс SAX парсеров, XSD и DTD схемы для валидации и т.п.
Совпадение синтаксиса обрабатывающих конструкций и результирующих конструкций. Другими словами, создавать XML на XML удобно, fest-шаблоны легко читать. Плюс решены все вопросы экранирования данных.
#### Реализация
Ковбойство. Я сам недавно узнал, что есть такой термин.
До этого я был уверен, что самый надежный способ выполнения задачи — парное программирование и тесты. Тесты, как всегда, себя оправдали, а вот парному программированию нашлись альтернативы.
Отличие этой задачи от типичной: был известен шаблон и результирующий HTML, который этот шаблон должен выдавать. Мы с Костей (Frontend разработчик почты) начали писать свои реализации. Раз в неделю мы сравнивали замеры скорости трансформации.
Мы выбрали два разных подхода: он компилировал шаблон в функцию, а я — в структуру. Пример самой простой структуры:
```
01 [
02 {action:"template"},
03 "...",
04 {action:"value"},
05 "json.value"
06 ]
```
Вторая строка означает начало шаблона. Третью надо просто отдать браузеру. Четвертая говорит, что пятую надо исполнить как JavaScript и результат исполнения отдать браузеру.
```
01 [
02 {action:"template"},
03 "....”,
04 {action:"if"},
05 "json.value",
06 "true",
07 "false"
08 ]
```
Вариант немного сложнее. Четвертая строчка означает, что пятую надо исполнить и если результат истина или ложь, то отдать шестую или седьмую строку соответственно.
Вариант с функцией особо пояснять не надо.
```
01 function template(json){
02 var html = "";
03 html += "…";
04 html += json.value;
05 return html;
07 }
```
Забегая вперед, скажу, что его вариант оказался быстрее. Некоторое время мы шли почти ровно, но вариант со структурой уперся в потолок намного раньше.
Чтобы понимать, что дал такой подход: моя первая реализация выполняла задачу за 200ms. Когда мы выжали все, что можно, а потом соединили лучшее из двух наших программ, то получили 3ms.
Если описать текущую реализацию кратко, то мы циклы транслируем в циклы, условные операторы в условные операторы и т.д.
```
fest:foreach for(i = 0; i < l; i++) {}
fest:if if(value) {}
fest:choose if(value) {} else {}
```
Нет сужений контекста. Да, это ограничение, но зато нет накладных расходов на ограничение контекста, а самое главное, что, как только сужаешь контекст, сразу возникает задача достать что-то из глобального контекста или из контекста уровнем выше.
Важно, что шаблоны транслируются в JS-функцию, которая работает в режиме strict mode. Это не дает верстальщикам шансов написать код, который приведет к утечкам памяти.
Везде, где нужна логическая работа с данными, доступен JavaScript.
```
\_javascript\_
```
Все конструкции, которые предполагают исполнение JavaScript, оборачиваются в try catch.
Все конструкции, которые предполагают вывод в HTML после выполнения JavaScript, по умолчанию проходят HTML escape.
```
json.name
```
```
try {
html += __escape(json.name)
} catch(e) {}
```
С самого начала разработка шаблонизатора ведется в открытом виде.
<https://github.com/mailru/fest>
#### Возможности интеграции
С одной стороны, v8 — это только библиотека, которая позволяет интерпретировать JavaScript. Сама по себе она кажется бесполезной – никакого доступа к системе. Но, с другой стороны, она легко прикручивается к другим языкам.
Имея нулевой опыт программирования на Cи и Perl, я сделал тестовые примеры на обоих языках. Плюс на текущий момент у нас есть связка с Python.
Ну и, конечно, NodeJS для прототипов и браузеры — среды, где JavaScript шаблоны работают из коробки.
#### Условия, близкие к боевым
Получив 3ms, я пошел к сервер-сайд программистам. На вопрос, сколько у меня есть времени на запрос, который отдает список писем пользователя, они сказали: не больше 4ms. У меня уже было 3ms на трансформацию, надо было пробовать.
Список писем у нас отдает наш собственный http-сервер, написанный на Cи. Получение данных — операции, которые не конкурируют за процессор, поэтому их не замеряли. Остановились на подготовке данных к трансформации и на самой трансформации.
По историческим причинам наш http сервер хранит данные в плоском хеше.
```
msg_length = 5
msg_1_title = “letter”
msg_1_Unread = 1
```
Так как мы говорим о JavaScript, то первое, что приходит на ум, — это JSON
```
msg = [ {title: “letter”, Unread: true} ]
```
Мы взяли строку с плоским хешом, поместили ее в память и стали добиваться результата, когда при трансформации шаблона в v8 JavaScript оперировал с JSON.
Вариантов перебрали много. Пробрасывать объект, пробрасывать строку и парсить ее на JavaScript, пробрасывать строку и пропускать ее через JSON.parse.
Как ни странно, самым быстрым оказалось преобразовать плоский хеш в строку, которая совпадает с JSON, и в v8 отдать строку
```
“template([ {title: \“letter\”, Unread: true} ])”
```
Но, несмотря на все, мы уперлись в 6ms при трансформации 2ms. Все были готовы сдаться. Я все же решил взять исходные данные, строку с плоским хешом и, используя тот же скомпилированный шаблон, получить нужный HTML на NodeJS.
Получил 4ms. Когда пришел с этой цифрой к нашим сишникам, честно говоря, ожидал фразы “Классно, но NodeJS писать у нас нет ресурсов” Но вместо этого услышал “Если NodeJS может за 4ms, значит мы тоже сможем!”.
Именно в этот момент я понял — мы доведем это до продакшена. Появилось второе дыхание!
Решение оказалось простым. Раз мы 67% времени теряем на подготовке данных, а данные в принципе у нас уже есть, надо выкинуть подготовку данных.
Мы пробросили в v8 фукцию \_\_get(‘key’). Таким образом, мы из v8 забирали данные напрямую из хеша нашего http сервера. Нет конвертации данных в нужный формат. Нет преобразования этой строки в объект внутри v8. Мы вышли на 3ms и имели запас 1ms.
#### Почти продакшен
Итак, выглядит все замечательно, но мы еще и близко не были на продакшене. Чешутся руки попробовать.
Берем отдельный сервер, поднимаем на нем версию http сервера, который работает с v8, и дублируем реальные запросы на него. Оставляем на 30 часов одно ядро 2.2 ГГц Xeon.
```
10 000 000+ хитов
1.6ms среднее время трансформации
992 422 10% между 2 и 5ms
208 464 2% между 5 и 10ms
39 649 0,4% больше 10ms
```
Только 12% были больше 2ms. v8 стабильно ведет себя по памяти.
#### Продакшен
Я пришел с последними цифрами к заместителю технического директора, сказав, что v8 готов к продакшену, надо сделать отдельный небольшой проект, который, если что, можно и забыть в случае неудачи. В ответ получил «цифры хорошие, отдельный проект, провал которого не страшен, — это правильно, но ты правда хочешь запустить v8? Начни с главной страницы Mail.Ru». Вопрос поставлен правильно – либо мы делаем дело, либо развлекаемся в сторонке.
Верстка главной страницы на fest заняла три дня. Выключили один сервер из балансера, залили туда версию с v8 и продублировали запросы. Все выкладки будут происходить в контексте одного демона/ядра.
Дальше я расскажу очень поучительную историю с хорошим концом.
Всегда детально выясняйте, что показывают ваши графики. Мы пустили на тестовый сервер половину нагрузки. Потребление процессора было в три раза выше обычного. Выглядело как провал, проигрыш по ресурсам в шесть раз по сравнению с текущим шаблонизатором.
Стали смотреть. Тут я немного расскажу про архитектуру главной. На ней собирается информация от разных проектов. Собирает ее внутренняя разработка, мы ее называем RB. Из 165кб, которые генерируются для отдачи главной, 100кб собирает RB. И происходит следующее: RB отдает куски HTML через http сервер в v8, v8 конкатенирует их со своими строками, а результат возвращает все это обратно в http-сервер.
Налицо двойной проброс данных. Сделали оптимизацию. Теперь v8 вместо построения одной большой строки, включающей в себя данные от RB, отдает данные сразу в http-сервер.
```
__push_string(‘foo’);
__push_rb(id);
__push_string(‘bar’);
```
Как плюс, нет конкатенации строк на v8, нет двойного проброса RB из сервера в v8 и обратно, а самое главное, любой проброс данных — это конвертация из utf-8 в utf-16 и обратно. V8 все хранит в utf-16.
Был профит, ресурсы потреблялись в два раза больше, чем обычно, а не в три. Т.е. мы все еще проигрывали в четыре раза, хотя вроде бы выжали все до капли.
А теперь поучительная часть. Я интереса ради взял нагрузку, которую мы тестировали, умножил на два, на количество демонов на машине и на количество машин. Получил 440 000 000 хитов. При этом у нас в сутки 110 000 000 хитов. Закрались смутные сомнения.
Пошли смотреть логии. Оказалось, что на каждый запрос с нагрузкой мы получали три запроса с отчетами в логи для статистики! Реальная нагрузка на один http-сервер в четыре раза ниже той, на которой тестируемся мы!
На следующее утро мы раскатили версию главной страницы с v8.
Данные на сегодня:
Размер отдаваемого HTML, который генерирует v8 65кб.
Время, работы v8 на запрос 1ms.
В среднем v8 требует 40MB на контекст.
#### Пара уточнений
Все, кто думают про v8, натыкались на статью Игоря Сысоева [sysoev.ru/prog/v8.html](http://sysoev.ru/prog/v8.html)
За все время работы над этой задачей нам очень сильно помогал разработчик v8 Вячеслав Егоров (http://mrale.ph).
Опасения про память оправданны. Если для вас критична корректная работа (при условии, что нехватка памяти — это штатная ситуация), то у вас будут проблемы. Корректно перехватить ошибку аллокации можно, но все, что можно сделать по этому поводу, — это корректно перезапуститься.
Но скажу честно, у нас есть только один продукт, где это критично. Что касается главной страницы — у нас многократный запас по памяти и мы его очень хорошо мониторим.
Оказалось, что у нас v8 trunk течет. Вячеславу воспроизвести это не удалось, но, я думаю, мы соберем тестовый пример, который поможет разработчикам найти утечку. Версия 3.6 ведет себя по памяти прекрасно.
#### Полезные ссылки
— [github.com/mailru/fest](https://github.com/mailru/fest) шаблонизатор
— [code.google.com/p/v8](http://code.google.com/p/v8/) v8 API
— [sysoev.ru/prog/v8.html](http://sysoev.ru/prog/v8.html) статья Игоря Сысоева
Андрей Сумин, руководитель разработки клиентской части Mail.ru | https://habr.com/ru/post/141361/ | null | ru | null |
# «Секретики» DPAPI. Взгляд на осла
В дополнение к нашей прошлой [статье](https://habr.com/ru/post/434514/) про расшифровку DPAPI-блобов расскажем еще о двух случаях, с которыми нам пришлось столкнуться. Речь пойдет о сохраненных паролях в браузерах MS IE11 и Edge.
Стратегия остается прежней – будем все расшифровывать в режиме offline. Для этого необходимо забрать нужные файлы.
В зависимости от операционной системы (Windows 7 или выше) сохраненные пароли следует искать в двух местах:
В случае Windows 7 это ветка реестра
```
HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\IntelliForms\Storage2
```
В случае Windows 8 и выше — хранилище Windows Vault.
Так же следует отметить что на Windows 7 пароли http basic авторизации так же хранятся в Windows Vault, так что забрать его не помешает в любом случае.
Ну и по старой доброй традиции — все это конечно же шифруется через DPAPI-механизмы.
Теперь рассмотрим алгоритм расшифровки более подробно.
### Windows 7 + IE11 (Edge)
Как уже упоминалось выше, пароли хранятся в реестре текущего пользователя и представляют из себя DPAPI-блобы, зашифрованные мастер-ключом пользователя.
Но есть важное отличие — при шифровании пароля применяется энтропия. Энтропия — это URL, по которому вводится пароль в формате `("https://url"+"\x00").lower().encode("utf-16-le")`.
**Для расшифровки пароля нужно знать полный URL!** Иначе никак.
Но, чтобы IE сам знал как расшифровывать пароль — этот URL хешируется и сохраняется в реестре в качестве имени ключа с DPAPI-blob.
Рассмотрим небольшой пример. Для сайта `https://rdot.org/forum/` сохраненный пароль будет выглядеть так:
```
A88E21329B5372B856CE238B79D1F28D8EA1FD359D REG_BINARY 01000000D08C9DDF0115D1118C7A00C......BC310C51EE0F9B05D
```
где
A88… — это хешированный URL `https://rdot.org/forum/`
01000000D08C… — DPAPI-блоб, содержащий username и пароль
Алгоритм хеширования URL незамысловатый. Подробнее о нем можно почитать в ЦРУ-шных наработках [Vault7](https://wikileaks.org/ciav7p1/cms/index.html).
На питоне он выглядит следующим образом:
```
import hashlib
url = "https://rdot.org/Forum/".lower() + "\x00"
url_utf_16_le = url.encode("utf-16-le")
sha1obj = hashlib.sha1(url_utf_16_le)
urldigest = sha1obj.digest()
checksum = 0
len(urldigest)
for abyte in urldigest:
checksum = (checksum + (ord(abyte))) & 0xFF
hash = sha1obj.hexdigest().upper()
cksum = "%02X" % checksum
reg_value_name = "%s%s" % (hash, cksum)
print reg_value_name
```
Список последних 50-ти введенных URL можно почерпнуть так же из реестра:
```
HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\typedurls
```
Вернемся к примеру. Допустим нам необходимо найти в реестре сохраненный пароль от `https://rdot.org/forum/`.
Подставив значение URL в скрипт конвертации — мы получим значение
```
A88E21329B5372B856CE238B79D1F28D8EA1FD359D
```
Ключ с этим наименованием нам необходимо отыскать в реестре
```
req query "HKEY_USERS\\Software\Microsoft\Internet Explorer\IntelliForms\Storage2"
```
Если такой ключ найден — его необходимо скопировать в файл в виде hex-значений (т.е. интерпретировав значение ключа как hex blob) и произвести расшифровку как DPAPI-blob c применением энтропии: `("https://rdot.org/forum/".lower() + "\x00").encode("utf-16-le")`
Для расшифровки можно воспользоваться dpapick, внеся соответствующие изменения для учета энтропии в расшифровке.
В файле examples/filegeneric.py вызов функции
```
probe.try_decrypt_with_password(options.password, mkp, options.sid)
```
заменить на
```
probe.try_decrypt_with_password(options.password, mkp, options.sid, entropy=("https://rdot.org/forum/".lower() + "\x00").encode("utf-16-le"))
```
и после этого вызвать dpapick как обычно:
```
./filegeneric.py --sid --masterkey --password <..> --inputfile
```
Если мастер-ключ расшифровался верно, то на выходе получим сохраненные логин и пароль (после некоторого количества служебных бинарных данных).
### Windows 8.1 и выше
В случае сохранения паролей на Win8 и выше пароли от http форм, равно как и http basic авторизации, хранятся в Windows Vault. И что хорошо — вместе с паролем сохраняется и полный URL сайта, к которому он подходит.
Сам Vault шифруется двухступенчато — сначала весь блок данных шифруется AES'ом, а симметричный ключ для расшифровки шифруется DPAPI и сохраняется в файл. Полностью алгоритм по шифровке-расшифровке описан в статье ребят из [Zena Forensics](http://blog.digital-forensics.it/2016/01/windows-revaulting.html).
Ими же разработаны специальные декрипторы для Windows Vault на основе dpapick (dpapilab). Их можно взять на гите ZF или скачать форк с нашего [гитхаба](https://github.com/mis-team/dpapilab).
Хранилище Vault расположено в профиле пользователя:
```
C:\Users\\AppData\Local\Microsoft\Vault\\
```
Внутри файл .vpol — DPAPI-блоб, зашифрованный ключом пользователя, и хранящий AES-key для расшифровки .vcrd
Для расшифровки Vault необходимо запустить:
```
./vaultdec.py --masterkey --sid --password
```
Вместо пароля можно применить доменный ключ, как было показано в [предыдущей статье](https://habr.com/ru/post/434514/). Так же следует отметить, что если в машина в домене и включена политика Credential Roaming, то данные Windows Vault будут храниться в ldap. Про это можно прочитать в первой нашей статье про DPAPI.
Маленькое дополнение: для корректной работы скрипта Вам скорее всего потребуется установить старые питоновские либы:
```
apt install python-construct.legacy
```
### Шпаргалка
Для расшифровки паролей IE, Edge а так же сохраненных в Windows паролей Вам необходимо забрать:
**каталог c Vault**
```
c:\Users\\AppData\Local\Microsoft\Vault\\
```
**каталог c мастер-ключами**
```
c:\Users\\AppData\roaming\microsoft\Protect\\
```
**содержимое ключей реестра**
```
HKEY_USERS\\Software\Microsoft\Internet Explorer\IntelliForms\Storage2
HKEY\_USERS>\\Software\Microsoft\Internet Explorer\typedurls
```
Помимо этого, необходимо знать пароль пользователя или доменный dpapi backup-ключ для расшифровки без пароля. | https://habr.com/ru/post/437390/ | null | ru | null |
# RadSensor v1.0: собираем портативный персональный дозиметр из готовых компонентов
Дозиметр не для Сережи
----------------------
В постоянно изменяющемся мире дозиметр является не только способом утолить любопытство и поймать на мушку хоть немного веселых Зивертов, но и способом обнаружения вполне реальных угроз. От проверки “любопытной старинной штуковины” из дедовского гаража, до отслеживания радиоактивного фона в зонах расположения АЭС, от обеспечения безопасности при вылазке в заброшки до мониторинга глобальных и локальных техногенных катастроф.
Нетленной классикой Хабра является цикл статей “Дозиметр для Серёжи”. В этом материале много истории, теории и хардовой (если не сказать “крафтовой”) сборки. Мы респектуем автору, и Сереже тоже. Но ставим перед собой другую, более практическую задачу - собрать дешёвый, функциональный и удобный дозиметр из готовых компонентов. В качестве основных элементов будут использованы Wemos D1 и модуль RadSens (ардуино-дозиметр на базе трубки Гейгера СБМ-20).
RadSensor (таково гордое имя нашего детектора) берет лучшее от прошлых проектов, а также учитывает их ошибки и расширяет функционал счетчика, в частности:
* увеличено время автономной работы;
* реализован функционал аудиоотклика;
* повышена эргономичность и универсальность корпуса;
* проект в целом упрощен и избавлен от “крафта”
Не устаем повторять, что основной критерий успеха материала - наличие удачных повторов и ремейков проекта со стороны маленьких электронщиков-школьников, бесшабашных туристов-студентов, а также практичных грибников-родителей.
Перед тем как листать дальше настоятельно рекомендуем ознакомиться с легендарным материалом (<https://habr.com/ru/post/471236/>). Краткая история и матчасть сами себя не прочитают ;)
Ознакомились? Отлично, тогда приступим!
Персональный дозиметр своими руками
-----------------------------------
Шутейки иссякли. Далее вас ждет сухая пошаговая инструкция по сборке устройства от закупки компонентов до кода и тестирования.
### План покупок (BOM)
1. Плата разработки Wemos D1, от 117 руб. на [Али](https://aliexpress.ru/item/1005001621784437.html?item_id=1005001621784437&sku_id=12000016846399621)
2. Модуль дозиметра RadSens, от 4550 руб. на [Али](https://aliexpress.ru/item/1005002590519046.html) / [Озоне](https://www.ozon.ru/product/modul-dozimetra-schetchika-geygera-i2c-s-derzhatelem-pod-trubku-arduino-sovmestimyy-249759642/)
3. OLED-экран 1.3” с I2C, от 161 руб на [Али](https://aliexpress.ru/item/4001145494936.html?sku_id=10000014888634895)
4. Пассивный пьезоизлучатель, от 48.5 руб. на [Али](https://aliexpress.ru/item/4000785325910.html?sku_id=10000007816863808)
5. Плата заряда TP4056, от 25 руб. на [Али](https://aliexpress.ru/item/1005001636470790.html?item_id=1005001636470790&sku_id=12000016918510328)
6. Аккумулятор 18650, от 210 руб. на [Али](https://aliexpress.ru/item/1005004392079183.html?sku_id=12000029017212037)
7. Бокс одинарный для 18650 аккумулятора, от 19 руб. на [Али](https://aliexpress.ru/item/1005001707889794.html?sku_id=12000017237055961)
8. Макетная плата 7\*3 см, от 17 руб. на [Али](https://aliexpress.ru/item/33005775828.html?item_id=33005775828&sku_id=67090308528)
9. Выключатель KCD-01, от 64 руб. за 10 шт на [Али](https://aliexpress.ru/item/4001165826718.html?sku_id=10000014982124402)
10. Разъём XH-2.54 с обжатыми проводами, от 66 руб. за две пары на [Али](https://aliexpress.ru/item/1005001829958447.html?sku_id=12000027309990963)
11. Резисторы номиналами 220 и 100 кОм
12. Винты/саморезы с диаметром резьбы 3 и 2.5 мм
13. Корпус, изготовленный на 3d-принтере - о нем ниже
Общая стоимость компонентов ~5500 рублей.
Цена сравнима с древними дозиметрами советской или китайской разработки. Аналогичное, но современное решение на Озоне обходится уже в 7-9 тысяч рублей.
### Схема устройства
Соединения показаны ниже на схеме. Особенности сборки:
* В верхней части макетной платы располагается Wemos (2 пина от края) и OLED (2 пина от края).
* Внизу макетки установлены: зарядкаTP4056 (Type-C сдвинут максимально близко к краю платы, но не вылезает за её пределы) и пьезоизлучатель (любая удобная позиция).
* Выключатель стоит на разрыве плюсового выходного пина контроллера заряда. Если подключить его на разрыв плюсового провода батареи, то контроллер заряда будет уходить в защиту, это ведёт к некорректной работе устройства.
Для расчёта и вывода остатка заряда батареи используется АЦП (пин А0). Для его правильной работы необходимо понизить напряжение с помощью делителя нпряжения. Подробнее о нем вы можете прочитать в статье о сборке анемометра (<https://habr.com/ru/post/676348/>).
схема обновлена 13.11.2022В результате должно получиться подобное устройство. Рекомендуем заизолировать контакты на лицевой стороне платы. Это одна из возможных способов собрать её, поэтому мы приветствуем критику и предложения :)
### Корпус для дозиметра
Мы постарались создать максимально удобный для печати, сборки и эксплуатации корпус.
На углу предусмотрена проушина диаметром 3 мм под шнурок или брелок.
Под трубкой Гейгера сделаны прорези для возможности детекции альфа-частиц, сделаны отверстия под пьезоизлучатель.
Посадочные места дозиметра адаптированы под длинную и короткую версии модуля RadSens.
Кнопка включения утоплена и защищена от случайных нажатий
На крышке предусмотрены посадочное место для OLED-экрана для предотвращения западания, добавлены боковые стенки для увеличения жёсткости корпуса
Модель адаптирована под 3d-печать, подобрана нормальная толщина стенки, минимизировано число поддержек
Найти модели корпуса (stl и step-файлы) вы можете в нашем [GitHub](https://github.com/climateguard/RadSens/tree/master/extras/3D-models/RadSensor).
### Код
Для проекта использован слегка доработанный код из нашей предыдущей статьи "[Народная дозиметрия](https://habr.com/ru/post/662343/)". Нововведения:
* добавлен звук приветствия при включении устройства;
* добавлена индикация заряда;
* реализовано предупреждение при превышении порога интенсивности излучения.
Для работы с OLED-экраном используется библиотека Алекса Гавера GyverOled.
Вы также можете найти код в примерах библиотеки RadSens на [GitHub](https://github.com/climateguard/RadSens/blob/master/examples/RadSensor/RadSensor.ino).
```
// Инициализируем библиотеки
#include
#include
#include
#define ADC\_pin A0 // задаём значение пина АЦП
#define buz\_pin 14 // Задаём значения пина для пищалки
GyverOLED oled; // Инициализируем 1.3" OLED-экран
CG\_RadSens radSens(RS\_DEFAULT\_I2C\_ADDRESS); // Инициализируем RadSens
uint16\_t ADC; // Переменная для значений АЦП
uint32\_t timer\_cnt; // Таймер для измерений дозиметра
uint32\_t timer\_bat; // Таймер для измерения заряда батареи
uint32\_t timer\_imp; // Таймер опроса импульсов для пьезоизлучателя
uint32\_t pulsesPrev; // Число импульсов за предыдущую итерацию
//Функция аудиоприветствия
void hello() {
for (int i = 1; i < 5; i++) {
tone(buz\_pin, i \* 1000);
delay(100);
}
tone(buz\_pin, 0);
delay(100);
oled.setScale(2);
oled.setCursor(10, 3);
oled.print("Radsensor");
oled.update();
delay(3000);
oled.clear();
}
//Функция, которая создаёт "трески" пьезоизлучателя при появлении импульсов
void beep() { // Функция, описывающая время и частоту пищания пьезоизлучателя
tone(buz\_pin, 3500);
delay(13);
tone(buz\_pin, 0);
delay(40);
}
//Функция предупреждения при превышении порога излучения
void warning() {
for (int i = 0; i < 3; i++) {
tone(buz\_pin, 1500);
delay(250);
tone(buz\_pin, 0);
delay(250);
}
}
void setup() {
Wire.begin();
oled.init(); // Инициализируем OLED в коде
oled.clear();
oled.update();
pinMode(ADC\_pin, OUTPUT); // Инициализируем АЦП как получатель данных
hello(); // Приветствуем пищанием
oled.update(); // Обновляем экран
pulsesPrev = radSens.getNumberOfPulses(); // Записываем значение для предотвращения серии тресков на старте
}
void loop() {
// Раз в 250 мс происходит опрос счётчика импульсов для создания тресков, если число импульсов за 250 мс превысит 5, раздастся предупреждение
if (millis() - timer\_imp > 250) {
timer\_imp = millis();
int pulses = radSens.getNumberOfPulses();
if (pulses - pulsesPrev > 5 ) {
pulsesPrev = pulses;
warning();
}
if (pulses > pulsesPrev) {
for (int i = 0; i < (pulses - pulsesPrev); i++) {
beep();
}
pulsesPrev = pulses;
}
}
// Снимаем показания с дозиметра и выводим их на экран
if (millis() - timer\_cnt > 1000) {
timer\_cnt = millis();
char buf1[50];
char buf2[50];
char buf3[50];
sprintf(buf1, "%.1f мкр/ч", radSens.getRadIntensyDynamic()); // Собираем строку с показаниями динамической интенсивности
sprintf(buf2, "Стат: %.1f мкр/ч ", radSens.getRadIntensyStatic()); // Собираем строку с показаниями средней интенсивности за период работы
oled.setCursor(0, 2);
oled.setScale(2);
oled.print(buf1);
oled.setCursor(0, 6);
oled.setScale(1);
oled.print(buf2);
}
// Считываем показание с АЦП, рисуем батарею и создаём индикацию заряда, показания АЦП вы можете подстроить под своё удобство
if (millis() - timer\_bat > 5000) {
timer\_bat = millis();
ADC = analogRead(ADC\_pin);
oled.rect(110, 0, 124, 8, OLED\_STROKE);
oled.rect(125, 3, 126, 5, OLED\_FILL);
if (ADC >= 350) {
oled.rect(112, 2, 114, 6, OLED\_FILL);
oled.rect(116, 2, 118, 6, OLED\_FILL);
oled.rect(120, 2, 122, 6, OLED\_FILL);
}
if (ADC < 350 && ADC >= 335) {
oled.rect(112, 2, 114, 6, OLED\_FILL);
oled.rect(116, 2, 118, 6, OLED\_FILL);
}
if (ADC < 335 && ADC >= 320) {
oled.rect(112, 2, 114, 6, OLED\_FILL);
}
if (ADC < 320){
oled.rect(110, 0, 124, 8, OLED\_STROKE);
oled.rect(125, 3, 126, 5, OLED\_FILL);
}
}
oled.update(); // Обновляем экран в конце цикла
}
```
Сборка мобильного DIY-дозиметра
-------------------------------
Для придания большей компактности мы свели к минимуму свободное пространство внутри корпуса. Поэтому необходимо придерживаться простого алгоритма сборки.
1. Устанавливаем бокс для 18650 с помощью винта диаметром 3х7 мм и вставляем выключатель в отверстие с торца, подпаиваем к нему провода для разрыва линии +OUT контроллера заряда.
2. Припаиваем провода от бокса к соответствующим выходам контроллера заряда, провода от выключателя – в разрыв между +OUT и плюсовыми контактами потребителей. Затем подключаем два шлейфа для дозиметра и экрана, выводим их и закрепляем корпус на три винта 2.5х7 мм. После вставляем батарею в бокс.
3. Подключаем модуль RadSens через коннектор и закрепляем его винтам 2.5х7 мм.
4. Закрепляем экран винтами 2.5х5 мм и подключаем его.
5. Закрепляем крышку винтами 3х5 мм.
### Тестирование собранного счетчика
Как и в предыдущих статьях мы проводим тестирование на сульфате калия. Если у вас в тумбочке завалялся кусок урана - можете использовать его, но помните о мерах безопасности.
Дозиметр для DIY-щиков
----------------------
В рамках материала мы описали только базу дозиметра. Проект можно и нужно развивать: создать приложуху для сбора и записи статистики на телефон, интегрировать с Народным Мониторингом, добавить функции фонарика, датчика температуры и лазерной сабли. Пожалуйста, выбирайте задачку по себе, предлагайте новые идеи и помогайте нам.
Наш же новый челендж - автономный дозиметр, работающий от солнечной батареи и передающий данные по модему на Нармон. Ждите, скоро на просторах хабра...
Также мы планируем провести в Москве несколько мастер-классов по сборке дозиметров и прочих проектов. Если DIY-электроника для Вас в новинку, но очень хочется попробовать - присоединяйтесь к [сообществу ClimateGuard](https://t.me/climateguard_community), ловите объявления и приходите к нам в гости на Электрозавод (МЭЛЗ).
Пользуясь случаем команда инженеров ClimateGuard передает благодарности и респекты:
* бессменному (и бессмертному, Илюха выздоравливай!) автору Илье Радченко (@octopoly) за подготовку материала;
* Алексу Гаверу (@AlexGyver) за прекрасную библиотеку GyverOLED;
* магазину Амперкот за предоставленные компоненты и желание создавать крутые и полезные образовательные наборы;
* сообществу, поддерживающему проекты и участвующему в нашей жизни;
* ...и конечно же вам, дорогие читатели, за уделенные время и интерес к статье!
Давайте сплачиваться и нести DIY в массы! | https://habr.com/ru/post/691774/ | null | ru | null |
# Как LLVM оптимизирует функцию
Оптимизирующий AOT-компилятор обычно структурирован так:
1. фронтенд, преобразующий исходный код в промежуточное представление
2. конвейер машинно-независимой оптимизации (IR): последовательность проходов, которые переписывают IR для устранения неэффективных участков и структур, которые не могут быть непосредственно преобразованы в машинный код. Иногда эту часть называют middle-end.
3. Машинно-зависимый бэкенд для генерации ассемблерного кода или машинного кода.
В некоторых компиляторах формат IR остаётся неизменным на протяжении всего процесса оптимизации, в других его формат или семантика меняется. В LLVM формат и семантика фиксированы, и, следовательно, возможно запускать проходы в любой последовательности без риска неверной компиляции или аварийного завершения работы компилятора.
Последовательность проходов оптимизации разработана разработчиками компилятора, целью при этом является выполнение работы за приемлемое время. Она меняется время от времени, и, конечно же, существует разный набор проходов для запуска на разных уровнях оптимизации. Одна из долгосрочных тем в компьютерных исследованиях, это использование машинного обучения или других методов для нахождения наилучшего конвейера оптимизации для общего применения и для специфических областей применения, для которых не очень хорошо подходит используемый по умолчанию конвейер.
Принципы разработки проходов — минималистичность и ортогональность: каждый проход должен хорошо делать одну вещь, и их функциональность не должна перекрываться. На практике, иногда возможны компромиссы. На практике, когда два прохода генерируют работу один для другого, они могут быть объединены в один больший проход. Также некоторая функциональность IR-уровня, такая, как сворачивание константных операторов, настолько полезна, что её нет смысла выносить в отдельный проход, LLVM по умолчанию сворачивает константные операции, когда создаётся инструкция.
В этом посте мы посмотрим, как работают некоторые проходы оптимизации LLVM. Я подразумеваю, что вы читали [эту часть](https://habr.com/ru/post/431688/), про то, как Clang компилирует функцию или что вы более или менее понимаете как работает LLVM IR. Особенно полезно понимать SSA (static single assignment)-форму: [Википедия](https://ru.wikipedia.org/wiki/SSA) даст вам начальное представление, и [эта книга](http://ssabook.gforge.inria.fr/latest/book.pdf) даст вам больше информации, чем вы хотели бы знать. Также читайте [LLVM Language Reference](https://llvm.org/docs/LangRef.html) и [список проходов оптимизации](https://llvm.org/docs/Passes.html).
Посмотрим, как Clang/LLVM 6.0.1 оптимизирует этот C++ код:
```
bool is_sorted(int *a, int n) {
for (int i = 0; i < n - 1; i++)
if (a[i] > a[i + 1])
return false;
return true;
}
```
При этом мы помним, что конвейер оптимизации — очень оживлённое место, и мы пропустим много весёлых моментов, таких, как:
Инлайнинг — простая, но очень важная оптимизация, которая не происходит в данном примере, т.к. мы рассматриваем только одну функцию. Практически все оптимизации, специфичные для С++, но не для С. Автовекторизацию, которой мешает ранний выход из цикла
В тексте ниже я буду пропускать все проходы, которые не вносят изменений в код. Также мы не будем заглядывать в бэкенд, в котором также выполняется много работы. Но даже оставшиеся проходы — это очень много! (Извините за картинки, но это, кажется, наилучший способ избежать трудностей с форматированием).
[Вот файл IR](https://blog.regehr.org/extra_files/is_sorted2.ll.txt), созданный Clang (я вручную удалил атрибут «optnone», который вставил Clang) и командная строка, используемая, чтобы увидеть эффект каждого прохода оптимизации:
```
opt -O2 -print-before-all -print-after-all is_sorted2.ll
```
Первый проход, это "[упрощение CFG](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/SimplifyCFGPass.cpp)" (control flow graph). Так как Clang не выполняет оптимизации, IR, который он порождает, содержит простые возможности для оптимизации:
Здесь базовый блок 26 просто выполняет переход к блоку 27. Такие блоки можно удалить, перенаправив ссылки на них блок назначения. LLVM автоматически перенумерует блоки. Полный список преобразований, производимых SimplifyCFG, перечислен наверху прохода.
`Этот файл реализует удаление невыполняемого кода и слияние базовых блоков, вместе с рядом других оптимизаций потока управления. Например:
* удаление базовых блоков, не имеющих предшественников
* слияние базового блока с его предшественником, если предшественник только один и предшественник имеет только один последующий блок.
* удаление phi-узлов для базовых блоков, имеющих единственного предшественника.
* удаление базовых блоков, состоящих только их безусловного перехода.
* изменение инструкций invoke для nounwind-функций на call
* изменение "if (x) if (y)" на "if (x&y)"`
Большая часть возможностей для оптимизации CFG появляется как результат работы других проходов LLVM. Например, удаление недостижимого кода (dead code elimination) и перемещение инвариантов цикла с лёгкостью может привести к возникновению пустых базовых блоков.
Следующий проход, [SROA](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/SROA.cpp) (scalar replacement of aggregates), один из наиболее интенсивно используемых. Его название приводит к некоторой путанице, потому что SROA — только одна из его функций. Проход проверяет каждую инструкцию alloca (выделение памяти в стеке функции), и пытается преобразовать её в SSA-регистры. Одна инструкция alloca (*то есть, фактически, переменная на стеке* прим. перев..) превращается в множество регистров, если она статически присваивается несколько раз, а также, если alloca является классом или структурой, она разделяется на компоненты (это и называется «скалярной заменой», о которой говорится в названии прохода). Простая версия SROA сдалась бы на стековых переменных, для которых применяется операция взятия адреса, но версия LLVM взаимодействует с алгоритмом анализа алиасов, и поступает интеллектуальным образом (хотя это и не требуется в следующем примере).
После SROA, инструкции alloca (и соответствующие им инструкции load и store) исчезают, и код становится более чистым и пригодным для последующих оптимизаций (конечно, SROA не может удалить все alloca в общем случае, это происходит только в том случае, если анализ указателей может полностью избавиться от алиасов). В процессе своей работы SROA вставляет в код инструкции phi. Инструкции phi составляют ядро SSA-представления, и отсутствие phi в коде, который генерирует Clang говорит нам о том, что Clang генерирует тривиальный вариант SSA, в котором базовые блоки связаны через память, а не через SSA-регистры.
Далее следует “[early common subexpression elimination](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/EarlyCSE.cpp)”, CSE (раннее удаление общих подвыражений). CSE пытается устранить случаи избыточных подвыражений, которые могут встречаться как в коде, написанном человеком, так и в частично оптимизированном коде. “Early CSE” — быстрый и простой вариант CSE, который выявляет тривиальные избыточные вычисления.
Здесь %10 и %17 делают одно и тоже, то есть код может быть переписан так, что будет использовано одно значение, а второе удалено. Это даёт некоторое представление о преимуществе SSA: когда каждый регистр присваивается лишь однажды, нет такой вещи, как множество версий одного регистра. Таким образом, избыточные вычисления могут быть выявлены с использованием синтаксической эквивалентности, без использования глубокого анализа программы (это не так для локаций памяти, которые существуют вне мира SSA).
Далее запускается несколько проходов, не имеющих эффекта в нашем случае, а затем запускается "[оптимизатор глобальных переменных](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/IPO/GlobalOpt.cpp)", который описан так:
`Этот проход преобразует простые глобальные переменные, для которых нигде не берётся адрес. В очевидных случаях, операции чтения записи глобальных переменных помечаются как константные, удаляются переменные, для которых происходит только запись, и т.п.`
Этот проход делает такие изменения:
Он добавил атрибут функции: метаданные, используемые одной частью компилятора для сохранения информации о том, что может быть полезно для другой части компилятора. Вы можете прочитать о назначении этого атрибута [здесь](https://reviews.llvm.org/D20348).
В отличие от других оптимизаций, которые мы рассматривали, оптимизатор глобальных переменных является межпроцедурным, он смотрит целиком на модуль LLVM. Модуль — это (более-менее) эквивалент единице компиляции в C и C++. В противоположность межпроцедурной оптимизации, внутрипроцедурная видит только одну функцию за раз.
Следующий проход объединяет инструкции и называется “[instruction combiner](https://github.com/llvm-mirror/llvm/tree/release_60/lib/Transforms/InstCombine)“, InstCombine. Это большая и разнообразная коллекция оптимизаций ([peephole optimizations](https://en.wikipedia.org/wiki/Peephole_optimization)), которые (обычно) переписывают некоторые инструкции, объединённые общими данными, в более эффективную форму. InstCombine не меняет порядок выполнения (control flow) функции. В приведённом примере он изменил не так много:
Здесь вместо вычитания 1 из %1, для того, чтобы вычислить %4, мы прибавляем -1. Это не оптимизация, а приведение к каноническому виду. Когда существует много способов сделать вычисление, LLVM пытается привести его к канонической (часто произвольно выбранной) форме, которую последующие проходы и бэкенды ожидают увидеть. Второе изменение, сделанное InstCombine, это приведение к канонической форме двух операций знакового расширения (инструкция sext), которые вычисляют %7 и %11, преобразованных к расширению нулями (zext). Это преобразование является безопасным, когда компилятор может доказать, что операнд sext неотрицательный. В данном случае это так, потому что переменная цикла изменяется от 0 до n (если n отрицательное, цикл не выполняется вообще). Последним изменением стало добавление флага «nuw» (no unsigned wrap) к инструкции, которая вычисляет %10. Мы можем видеть, что это безопасно, из того, что (1) переменная цикла всегда увеличивается и (2) если переменная начинается с нуля и увеличивается, она бы стала неопределённой при смене знака при пересечении INT\_MAX, перед тем, как достигнет беззнакового переполнения, следующего за UINT\_MAX. Этот флаг может быть использован для последующих оптимизаций.
Далее, второй раз запускается SimplifyCFG, и удаляет два пустых базовых блока:
Затем проход "[вывод атрибутов функций](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/IPO/FunctionAttrs.cpp)" (“Deduce function attributes”) аннотирует функцию:
“Norecurse” означает, что функция не включена ни в какие рекурсивные вызовы, “readonly” означает, что функция не изменяет глобальное состояние. Атрибут параметра “nocapture” означает, что параметр нигде не сохраняется после выхода из функции, и “readonly” означает, что память не модифицируется функцией. Вы можете посмотреть [список атрибутов функций](https://releases.llvm.org/6.0.0/docs/LangRef.html#function-attributes) и [атрибутов параметров](https://releases.llvm.org/6.0.0/docs/LangRef.html#parameter-attributes).
Затем проход “[rotate loops](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/LoopRotation.cpp)” перемещает код в попытках улучшить условия для последующих оптимизаций:
Хотя разница выглядит пугающе, изменения на самом деле небольшие. Мы можем увидеть, что произошло, в более читаемом виде, если мы попросим LLVM нарисовать граф передачи управления до и после прохода ротации циклов. Вот их вид до (слева) и после (справа):
Оригинальный код по-прежнему соответствует структуре цикла, которую сгенерировал Clang:
```
initializer
goto COND
COND:
if (condition)
goto BODY
else
goto EXIT
BODY:
body
modifier
goto COND
EXIT:
```
После работы прохода цикл выглядит так:
```
initializer
if (condition)
goto BODY
else
goto EXIT
BODY:
body
modifier
if (condition)
goto BODY
else
goto EXIT
EXIT:
```
(Исправления, предложенные Йоханнесом Дурфертом, приведены ниже — спасибо!)
Цель прохода «loop rotation» состоит в удалении одной ветви, что обеспечивает возможность дальнейших оптимизаций. Я не нашёл лучшего описания этого преобразования в интернете.
Проход «CFG simplification» (упрощение графа потока управления) сворачивает два базовых блока, которые содержат только вырожденные (одновходовые) phi-инструкции:
Проход «instruction combiner» (объединение инструкций) превращает “%4 = 0 s< (%1 — 1)" в "%4 = %1 s> 1″ (где s< и s> — операции сравнения знаковых операндов), это полезное преобразование, оно сокращает длину цепочек зависимостей и также может создавать «мёртвые» (недостижимые) инструкции (см. [патч](https://reviews.llvm.org/D29774), который это выполняет). Этот проход также удаляет тривиальные phi-инструкции, которые были добавлены проходом «loop rotation».
Далее следует проход “[canonicalize natural loops](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Utils/LoopSimplify.cpp)”, который описан в его собственном исходнике так:
`Данный проход выполняет некоторые преобразования естественных циклов в более простую форму, что делает последующий анализ и преобразования более простыми и эффективными.
Вставка блока перед циклом (Loop pre-header) гарантирует, что будет единственная, некритическое ребро входа в заголовок цикла. Это упрощает количество анализов и преобразований,таких, как LICM.
Вставка блока на выходе из цикла гарантирует, что все блоки, являющиеся выходными для цикла (то есть имеющие предшественников в теле цикла) будут иметь предшественников только в теле цикла (и заголовок цикла будет для них доминирующим). Это упрощает преобразования, такие, как "store-sinking", встроенные в LICM.
Этот проход гарантирует, что цикл имеет в точности одно ребро передачи управления из конца цикла в начало (backedge).
Инструкция Indirectbr вносит некоторые усложнения. Если цикл содержит эту инструкцию или в него выполняется вход этой инструкцией, невозможно выполнить преобразования цикла гарантированным образом. Код клиента должен проверять, что эти условия истинны, прежде чем полагаться на них.
Отметим, что проход simplifycfg очистит блоки, которые были разделены, но в дальнейшем это не потребовалось, то есть использование этого прохода не пессимизирует сгенерированный код.
Этот проход, очевидно, изменяет CFG, обновляет информацию о циклах и о доминаторах.`
Здесь мы видим, что произошла вставка выходного блока:
Затем следует "[упрощение переменной цикла](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/IndVarSimplify.cpp)":
`Это преобразование анализирует и преобразует переменные цикла (и вычисления, в которых они участвуют), в более простую форму, подходящую для последующих анализов и преобразований.
Если количество проходов цикла вычислимо, этот проход выполняет соответствующие изменения:
Выходное условие цикла приводится к каноническому виду, при котором переменная цикла сравнивается с конечной величиной. Например, цикл ‘for (i = 7; i*i < 1000; ++i)' преобразуется в 'for (i = 0; i != 25; ++i)'.
Любое использование вне цикла выражения с использованием переменной цикла indvar заменяется на вычисление выходного соответствующего выражения вне цикла, устраняя зависимость этого значения от переменной цикла. Если единственной целью цикла является вычисление выходного значения соответствующего производного выражения, это преобразование делает цикл "мёртвым".`
Эффектом этого прохода будет изменение 32-битной переменной цикла на 64-битную:
Я не знаю, почему zext — ранее приведённое к каноническому виду из sext, вернулось опять к sext.
Сейчас проход “[global value numbering](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/GVN.cpp)” выполняет очень умную оптимизацию. Одной из причин написания этого поста является желание её показать. Можете ли вы увидеть её здесь?
Увидели? Да, две инструкции load в цикле слева, соответствующие a[i] и a[i + 1]. Здесь GVN обнаружил, что в загрузке a[i] нет необходимости, потому что a[i + 1] из одной итерации цикла может быть перенесена в следующую, как a[i]. Этот простой трюк наполовину сокращает количество чтений из памяти, выполняемых функцией. И LLVM, и [GCC](https://gcc.godbolt.org/z/KpHmbm) научились выполнять это преобразование лишь недавно.
Возможно, вы спросите себя, будет ли работать этот трюк, если мы сравниваем a[i] с a[i + 2]. Получается так, что нет, но GCC может выделить [до четырёх регистров](https://gcc.godbolt.org/z/TrKpFa) для таких случаев.
Потом запускается проход “[bit-tracking dead code elimination](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/BDCE.cpp)”:
`Этот файл реализует проход "Bit-Tracking Dead Code Elimination". Некоторые инструкции (сдвиги, некоторые инструкции "и" и "или" и т.п.) "убивают" некоторые входные биты. Мы отслеживаем эти входные биты и удаляем инструкции, которые вычисляют только "мёртвые" биты.`
Но здесь получается, что такие хитрости не нужны, потому что единственный мёртвый код, это инструкция GEP (get element pointer), и она тривиально мертва (проход GVN удалил инструкцию load, которая использовала адрес, вычисляемый этой инструкцией):
Сейчас алгоритм объединения инструкций поместил add в другой базовый блок. Логика, по которой это преобразование было помещено в InstCombine, не ясна мне, возможно, не нашлось какого-то очевидного места, куда можно было его поместить:
Сейчас происходит нечто более странное: проход “[jump threading](https://github.com/llvm-mirror/llvm/blob/release_60/lib/Transforms/Scalar/JumpThreading.cpp)” удалил то, что проход “canonicalize natural loops” сделал ранее:
Затем мы снова выполняем приведение к каноническому виду:
И упрощение CFG преобразует это по-другому:
И обратно:
И снова туда:
И обратно:
И туда:
И наконец, мы закончили с миддлендом! Код справа — это тот код, который мы передадим (в нашем случае) бэкенду x86-64.
Вам, возможно, любопытно, являются ли колебания в поведении в конце конвейера результатом бага компилятора, но давайте будем учитывать, что эта функция очень, очень простая и очень много проходов вовлечены в её обработку, но я даже не упомянул про них, потому что они не внесли в код никаких изменений. На протяжении всей второй половины конвейера оптимизации, мы в основном наблюдаем вырожденные случаи для данной функции.
Благодарности: некоторые студенты в моём углублённом курсе компиляторов этой осенью оставили обратную связь на черновик этого поста (и я также использовал этот материал для домашних заданий). Я прошёлся по рассмотренным здесь функциям в [этом](https://www.cs.cmu.edu/~fp/courses/15411-f13/lectures/17-loopopt.pdf) хорошем наборе лекций об оптимизации циклов. | https://habr.com/ru/post/433598/ | null | ru | null |
# Дистилляция BERT для задачи классификации
Большие языковые модели это конечно хорошо, но иногда требуется использовать что-то маленькое и быстрое.
Постановка задачи
-----------------
Дистилляция будет проводиться для модели BERT, обученной на задачу бинарной классификации. В качестве данных был выбран [открытый корпус русскоязычных твитов](https://study.mokoron.com/). Вдохновлялся двумя статьями: по [дистилляции данных из BERT в BiLSTM](https://habr.com/ru/company/avito/blog/485290/), и собственно по [дистилляции BERT](https://habr.com/ru/post/562064/). Нового ничего не добавлю, хочется все причесать и сделать пошаговый туториал для простого использования. Весь код на [github](https://github.com/shitkov/distillation).
План работ
----------
1. Baseline 1: TF-IDF + RandomForest
2. Baseline 2: BiLSTM
3. Дистилляция BERT > BiLSTM
4. Дистилляция BERT > tinyBERT
TF-IDF + RandomForest
---------------------
Все стандартно: нижний регистр, лемматизация, удаление стоп-слов. Полученные вектора классифицируем [RandomForest](https://en.wikipedia.org/wiki/Random_forest). Получаем [F1](https://en.wikipedia.org/wiki/F-score) чуть больше **0.75**.
Как обучить TF-IDF + RF
```
import re
import pandas as pd
from pymystem3 import Mystem
# get data
data = pd.read_csv('data.csv')
texts = list(data['comment'])
labels = list(map(int, data['toxic'].values))
# clean texts
texts = [re.sub('[^а-яё ]', ' ', str(t).lower()) for t in texts]
texts = [re.sub(r" +", " ", t).strip() for t in texts]
# lemmatize
mstm = Mystem()
normalized = [''.join(mstm.lemmatize(t)[:-1]) for t in texts]
# remove stopwords
with open('./stopwords.txt') as f:
stopwords = [line.rstrip('\n') for line in f]
def drop_stop(text):
tokens = text.split(' ')
tokens = [t for t in tokens if t not in stopwords]
return ' '.join(tokens)
normalized = [drop_stop(text) for text in normalized]
# new dataset
df = pd.DataFrame()
df['text'] = texts
df['norm'] = normalized
df['label'] = labels
# train-valid-test-split
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.3, random_state=42)
valid, test = train_test_split(test, test_size=0.5, random_state=42)
# tf-idf
from sklearn.feature_extraction.text import TfidfVectorizer
model_tfidf = TfidfVectorizer(max_features=5000)
train_tfidf = model_tfidf.fit_transform(train['norm'].values)
valid_tfidf = model_tfidf.transform(valid['norm'].values)
test_tfidf = model_tfidf.transform(test['norm'].values)
# RF
from sklearn.ensemble import RandomForestClassifier
cls = RandomForestClassifier(random_state=42)
cls.fit(train_tfidf, train['label'].values)
# prediction
predictions = cls.predict(test_tfidf)
# score
from sklearn.metrics import f1_score
f1_score(predictions, test['label'].values)
```
### BiLSTM
Попробуем улучшить бэйзлайн с помощью нейросетевого подхода. Все стандартно: учим токенизатор, учим сетку. В качестве базовой архитектуры берем BiLSTM. Получаем [F1](https://en.wikipedia.org/wiki/F-score) чуть больше **0.79**. Небольшой, но прирост есть.
Как обучить BiLSTM
```
# get data
import pandas as pd
train = pd.read_csv('train.csv')
valid = pd.read_csv('valid.csv')
test = pd.read_csv('test.csv')
# create tokenizer
from tokenizers import Tokenizer
from tokenizers import ByteLevelBPETokenizer
from tokenizers.pre_tokenizers import Whitespace
tokenizer = ByteLevelBPETokenizer()
tokenizer.pre_tokenizer = Whitespace()
tokenizer.enable_padding(pad_id=0, pad_token='')
texts\_path = 'texts.txt'
with open(texts\_path, 'w') as f:
for text in list(train['text'].values):
f.write("%s\n" % text)
tokenizer.train(
files=[texts\_path],
vocab\_size=5\_000,
min\_frequency=2,
special\_tokens=['', '']
)
# create dataset
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
class CustomDataset(Dataset):
def \_\_init\_\_(self, tokens, labels, max\_len):
self.tokens = tokens
self.labels = labels
self.max\_len = max\_len
def \_\_len\_\_(self):
return len(self.tokens)
def \_\_getitem\_\_(self, idx):
label = self.labels[idx]
label = torch.tensor(label)
tokens = self.tokens[idx]
out = torch.zeros(self.max\_len, dtype=torch.long)
out[:len(tokens)] = torch.tensor(tokens, dtype=torch.long)[:self.max\_len]
return out, label
max\_len = 64
BATCH\_SIZE = 16
train\_labels = list(train['label'])
train\_tokens = [tokenizer.encode(text).ids for text in list(train['text'])]
train\_dataset = CustomDataset(train\_tokens, train\_labels, max\_len)
train\_loader = DataLoader(train\_dataset, batch\_size=BATCH\_SIZE, shuffle=False)
test\_labels = list(test['label'])
test\_tokens = [tokenizer.encode(text).ids for text in list(test['text'])]
test\_dataset = CustomDataset(test\_tokens, test\_labels, max\_len)
test\_loader = DataLoader(test\_dataset, batch\_size=BATCH\_SIZE, shuffle=False)
# create BiLSTM
class LSTM\_classifier(nn.Module):
def \_\_init\_\_(self, hidden\_dim=128, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.3, n\_classes=2):
super().\_\_init\_\_()
self.embedding\_layer = nn.Embedding(vocab\_size, embedding\_dim)
self.lstm\_layer = nn.LSTM(embedding\_dim, hidden\_dim, batch\_first=True, bidirectional=True)
self.dropout\_layer = nn.Dropout(dropout)
self.fc\_layer = nn.Linear(hidden\_dim \* 2, linear\_dim)
self.batchnorm = nn.BatchNorm1d(linear\_dim)
self.relu = nn.ReLU()
self.out\_layer = nn.Linear(linear\_dim, n\_classes)
def forward(self, inputs):
batch\_size = inputs.size(0)
embeddings = self.embedding\_layer(inputs)
lstm\_out, (ht, ct) = self.lstm\_layer(embeddings)
out = ht.transpose(0, 1)
out = out.reshape(batch\_size, -1)
out = self.fc\_layer(out)
out = self.batchnorm(out)
out = self.relu(out)
out = self.dropout\_layer(out)
out = self.out\_layer(out)
out = torch.squeeze(out, 1)
out = torch.sigmoid(out)
return out
def init\_weights(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier\_uniform\_(m.weight)
m.bias.data.fill\_(0.01)
def eval\_nn(model, data\_loader):
predicted = []
labels = []
model.eval()
with torch.no\_grad():
for data in data\_loader:
x, y = data
x = x.to(device)
outputs = model(x)
\_, predict = torch.max(outputs.data, 1)
predict = predict.cpu().detach().numpy().tolist()
predicted += predict
labels += y
score = f1\_score(labels, predicted, average='binary')
return score
def train\_nn(model, optimizer, loss\_function, train\_loader, test\_loader, device, epochs=20):
best\_score = 0
for epoch in range(epochs):
model.train()
for inputs, labels in tqdm(train\_loader):
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero\_grad()
predict = model(inputs)
loss = loss\_function(predict, labels)
loss.backward()
optimizer.step()
score = eval\_nn(model, test\_loader)
print(epoch, 'valid:', score)
if score > best\_score:
torch.save(model.state\_dict(),'lstm.pt')
best\_score = score
return best\_score
# fit NN
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
model = LSTM\_classifier(hidden\_dim=256, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.1)
model.apply(init\_weights)
model.to(device)
optimizer = optim.AdamW(model.parameters())
loss\_function = nn.CrossEntropyLoss().to(device)
train\_nn(model, optimizer, loss\_function, train\_loader, valid\_loader, device, epochs=20)
eval\_nn(model, test\_loader)
```
Учим BERT
---------
Обучим модель-учитель. В качестве учителя я выбрал героя вышеупомянутой [статьи по дистилляции](https://habr.com/ru/post/562064/) - [rubert-tiny](https://huggingface.co/cointegrated/rubert-tiny) от [@cointegrated](/users/cointegrated). Получаем [F1](https://en.wikipedia.org/wiki/F-score) чуть больше **0.91**. Я особо не игрался с обучением, можно думаю было получить метрику и получше, особенно если использовать большой BERT, но и так достаточно показательно. Как обучить BERT на бинарную классификацию можно глянуть в моей [прошлой статье](https://habr.com/ru/post/567028/), или прямо тут:
как обучить BERT
```
import torch
from torch.utils.data import Dataset
class BertDataset(Dataset):
def __init__(self, texts, targets, tokenizer, max_len=512):
self.texts = texts
self.targets = targets
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
text = str(self.texts[idx])
target = self.targets[idx]
encoding = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
return_token_type_ids=False,
padding='max_length',
return_attention_mask=True,
return_tensors='pt',
truncation=True
)
return {
'text': text,
'input_ids': encoding['input_ids'].flatten(),
'attention_mask': encoding['attention_mask'].flatten(),
'targets': torch.tensor(target, dtype=torch.long)
}
from tqdm import tqdm
import numpy as np
import torch
from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import Dataset, DataLoader
from transformers import AdamW, get_linear_schedule_with_warmup
from sklearn.metrics import precision_recall_fscore_support
class BertClassifier:
def __init__(self, path, n_classes=2):
self.path = path
self.model = BertForSequenceClassification.from_pretrained(path)
self.tokenizer = BertTokenizer.from_pretrained(path)
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.max_len = 512
self.out_features = self.model.bert.encoder.layer[1].output.dense.out_features
self.model.classifier = torch.nn.Linear(self.out_features, n_classes)
self.model.to(self.device)
def preparation(self, X_train, y_train, epochs):
# create datasets
self.train_set = BertDataset(X_train, y_train, self.tokenizer)
# create data loaders
self.train_loader = DataLoader(self.train_set, batch_size=2, shuffle=True)
# helpers initialization
self.optimizer = AdamW(
self.model.parameters(),
lr=2e-5,
weight_decay=0.005,
correct_bias=True
)
self.scheduler = get_linear_schedule_with_warmup(
self.optimizer,
num_warmup_steps=500,
num_training_steps=len(self.train_loader) * epochs
)
self.loss_fn = torch.nn.CrossEntropyLoss().to(self.device)
def fit(self):
self.model = self.model.train()
losses = []
correct_predictions = 0
for data in tqdm(self.train_loader):
input_ids = data["input_ids"].to(self.device)
attention_mask = data["attention_mask"].to(self.device)
targets = data["targets"].to(self.device)
outputs = self.model(
input_ids=input_ids,
attention_mask=attention_mask
)
preds = torch.argmax(outputs.logits, dim=1)
loss = self.loss_fn(outputs.logits, targets)
correct_predictions += torch.sum(preds == targets)
losses.append(loss.item())
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
self.optimizer.step()
self.scheduler.step()
self.optimizer.zero_grad()
train_acc = correct_predictions.double() / len(self.train_set)
train_loss = np.mean(losses)
return train_acc, train_loss
def train(self, X_train, y_train, X_valid, y_valid, X_test, y_test, epochs=1):
print('*' * 10)
print(f'Model: {self.path}')
self.preparation(X_train, y_train, epochs)
for epoch in range(epochs):
print(f'Epoch {epoch + 1}/{epochs}')
train_acc, train_loss = self.fit()
print(f'Train loss {train_loss} accuracy {train_acc}')
predictions_valid = [self.predict(x) for x in X_valid]
precision, recall, f1score = precision_recall_fscore_support(y_valid, predictions_valid, average='macro')[:3]
print('Valid:')
print(f'precision: {precision}, recall: {recall}, f1score: {f1score}')
predictions_test = [self.predict(x) for x in X_test]
precision, recall, f1score = precision_recall_fscore_support(y_test, predictions_test, average='macro')[:3]
print('Test:')
print(f'precision: {precision}, recall: {recall}, f1score: {f1score}')
print('*' * 10)
def predict(self, text):
self.model = self.model.eval()
encoding = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
return_token_type_ids=False,
truncation=True,
padding='max_length',
return_attention_mask=True,
return_tensors='pt',
)
out = {
'text': text,
'input_ids': encoding['input_ids'].flatten(),
'attention_mask': encoding['attention_mask'].flatten()
}
input_ids = out["input_ids"].to(self.device)
attention_mask = out["attention_mask"].to(self.device)
outputs = self.model(
input_ids=input_ids.unsqueeze(0),
attention_mask=attention_mask.unsqueeze(0)
)
prediction = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
return prediction
import pandas as pd
train = pd.read_csv('train.csv')
valid = pd.read_csv('valid.csv')
test = pd.read_csv('test.csv')
classifier = BertClassifier(
path='cointegrated/rubert-tiny',
n_classes=2
)
classifier.train(
X_train=list(train['text']),
y_train=list(train['label']),
X_valid=list(valid['text']),
y_valid=list(valid['label']),
X_test=list(test['text']),
y_test=list(test['label']),
epochs=1
)
path = './trainer'
classifier.model.save_pretrained(path)
classifier.tokenizer.save_pretrained(path)
```
Дистилляция BERT > BiLSTM
-------------------------
Основная идея - приближение BiLSTM-учеником выхода BERT-учителя. Для этого при обучении используем функцию ошибки MSE. Можно использовать совместно с обучением на метках и CrossEntropyLoss. Подробнее можно почитать в [статье по ссылке](https://habr.com/ru/company/avito/blog/485290/). На моих тестовых данных дистилляция докинула всего пару процентов: F1 чуть больше **0.82**.
Код дистилляции
```
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from tokenizers import Tokenizer
from tokenizers import ByteLevelBPETokenizer
from tokenizers.pre_tokenizers import Whitespace
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import AdamW, get_linear_schedule_with_warmup
from sklearn.metrics import precision_recall_fscore_support
from sklearn.metrics import f1_score
import numpy as np
import pandas as pd
### data
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')
### tokenizer: train
tokenizer = ByteLevelBPETokenizer()
tokenizer.pre_tokenizer = Whitespace()
tokenizer.enable_padding(pad_id=0, pad_token='')
texts\_path = 'texts.txt'
with open(texts\_path, 'w') as f:
for text in list(train['text'].values):
f.write("%s\n" % text)
tokenizer.train(
files=[texts\_path],
vocab\_size=5\_000,
min\_frequency=2,
special\_tokens=['', '']
)
### load BERT tokenizer
tokenizer\_bert = BertTokenizer.from\_pretrained('./rubert-tiny')
### dataset
class CustomDataset(Dataset):
def \_\_init\_\_(self, tokens, labels, max\_len):
self.tokens = tokens
self.labels = labels
self.max\_len = max\_len
def \_\_len\_\_(self):
return len(self.tokens)
def \_\_getitem\_\_(self, idx):
label = self.labels[idx]
label = torch.tensor(label)
tokens = self.tokens[idx]
out = torch.zeros(self.max\_len, dtype=torch.long)
out[:len(tokens)] = torch.tensor(tokens, dtype=torch.long)[:self.max\_len]
return out, label
max\_len = 64
BATCH\_SIZE = 16
train\_labels = list(train['label'])
train\_tokens = [tokenizer.encode(str(text)).ids for text in list(train['text'])]
train\_dataset = CustomDataset(train\_tokens, train\_labels, max\_len)
train\_loader = DataLoader(train\_dataset, batch\_size=BATCH\_SIZE, shuffle=False)
test\_labels = list(test['label'])
test\_tokens = [tokenizer.encode(str(text)).ids for text in list(test['text'])]
test\_dataset = CustomDataset(test\_tokens, test\_labels, max\_len)
test\_loader = DataLoader(test\_dataset, batch\_size=BATCH\_SIZE, shuffle=False)
class LSTM\_classifier(nn.Module):
def \_\_init\_\_(self, hidden\_dim=128, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.3, n\_classes=2):
super().\_\_init\_\_()
self.embedding\_layer = nn.Embedding(vocab\_size, embedding\_dim)
self.lstm\_layer = nn.LSTM(embedding\_dim, hidden\_dim, batch\_first=True, bidirectional=True)
self.dropout\_layer = nn.Dropout(dropout)
self.fc\_layer = nn.Linear(hidden\_dim \* 2, linear\_dim)
self.batchnorm = nn.BatchNorm1d(linear\_dim)
self.relu = nn.ReLU()
self.out\_layer = nn.Linear(linear\_dim, n\_classes)
def forward(self, inputs):
batch\_size = inputs.size(0)
embeddings = self.embedding\_layer(inputs)
lstm\_out, (ht, ct) = self.lstm\_layer(embeddings)
out = ht.transpose(0, 1)
out = out.reshape(batch\_size, -1)
out = self.fc\_layer(out)
out = self.batchnorm(out)
out = self.relu(out)
out = self.dropout\_layer(out)
out = self.out\_layer(out)
out = torch.squeeze(out, 1)
out = torch.sigmoid(out)
return out
########
def init\_weights(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier\_uniform\_(m.weight)
m.bias.data.fill\_(0.01)
def eval\_nn(model, data\_loader):
predicted = []
labels = []
model.eval()
with torch.no\_grad():
for data in data\_loader:
x, y = data
x = x.to(device)
outputs = model(x)
\_, predict = torch.max(outputs.data, 1)
predict = predict.cpu().detach().numpy().tolist()
predicted += predict
labels += y
score = f1\_score(labels, predicted, average='binary')
return score
def train\_nn(model, optimizer, loss\_function, train\_loader, test\_loader, device, epochs=20):
best\_score = 0
for epoch in range(epochs):
model.train()
for inputs, labels in train\_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero\_grad()
predict = model(inputs)
loss = loss\_function(predict, labels)
loss.backward()
optimizer.step()
score = eval\_nn(model, test\_loader)
print(epoch, 'valid:', score)
if score > best\_score:
torch.save(model.state\_dict(), 'lstm.pt')
best\_score = score
return best\_score
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
model = LSTM\_classifier(hidden\_dim=256, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.1)
model.apply(init\_weights);
model.to(device);
optimizer = optim.AdamW(model.parameters())
loss\_function = nn.CrossEntropyLoss().to(device)
train\_nn(model, optimizer, loss\_function, train\_loader, test\_loader, device, epochs=3)
#####
class DistillDataset(Dataset):
def \_\_init\_\_(self, texts, labels, tokenizer\_bert, tokenizer\_lstm, max\_len):
self.texts = texts
self.labels = labels
self.tokenizer\_bert = tokenizer\_bert
self.tokenizer\_lstm = tokenizer\_lstm
self.max\_len = max\_len
def \_\_len\_\_(self):
return len(self.texts)
def \_\_getitem\_\_(self, idx):
text = self.texts[idx]
label = self.labels[idx]
label = torch.tensor(label)
# lstm
tokens\_lstm = self.tokenizer\_lstm.encode(str(text)).ids
out\_lstm = torch.zeros(self.max\_len, dtype=torch.long)
out\_lstm[:len(tokens\_lstm)] = torch.tensor(tokens\_lstm, dtype=torch.long)[:self.max\_len]
# bert
encoding = self.tokenizer\_bert.encode\_plus(
str(text),
add\_special\_tokens=True,
max\_length=self.max\_len,
return\_token\_type\_ids=False,
truncation=True,
padding='max\_length',
return\_attention\_mask=True,
return\_tensors='pt',
)
out\_bert = {
'input\_ids': encoding['input\_ids'].flatten(),
'attention\_mask': encoding['attention\_mask'].flatten()
}
return out\_lstm, out\_bert, label
train\_dataset\_distill = DistillDataset(
list(train['text']),
list(train['label']),
tokenizer\_bert,
tokenizer,
max\_len
)
train\_loader\_distill = DataLoader(train\_dataset\_distill, batch\_size=BATCH\_SIZE, shuffle=True)
### BERT-teacher model
class BertTrainer:
def \_\_init\_\_(self, path\_model, n\_classes=2):
self.model = BertForSequenceClassification.from\_pretrained(path\_model, num\_labels=n\_classes)
self.device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
self.max\_len = 512
self.model.to(self.device)
self.model = self.model.eval()
def predict(self, inputs):
input\_ids = inputs["input\_ids"].to(self.device)
attention\_mask = inputs["attention\_mask"].to(self.device)
with torch.no\_grad():
outputs = self.model(
input\_ids=input\_ids,
attention\_mask=attention\_mask
)
return outputs.logits
teacher = BertTrainer('./rubert-tiny')
### BiLSTM-student model
class CustomLSTM(nn.Module):
def \_\_init\_\_(self, hidden\_dim=128, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.3, n\_classes=2):
super().\_\_init\_\_()
self.embedding\_layer = nn.Embedding(vocab\_size, embedding\_dim)
self.lstm\_layer = nn.LSTM(embedding\_dim, hidden\_dim, batch\_first=True, bidirectional=True)
self.dropout\_layer = nn.Dropout(dropout)
self.fc\_layer = nn.Linear(hidden\_dim \* 2, linear\_dim)
self.batchnorm = nn.BatchNorm1d(linear\_dim)
self.relu = nn.ReLU()
self.out\_layer = nn.Linear(linear\_dim, n\_classes)
def forward(self, inputs):
batch\_size = inputs.size(0)
embeddings = self.embedding\_layer(inputs)
lstm\_out, (ht, ct) = self.lstm\_layer(embeddings)
out = ht.transpose(0, 1)
out = out.reshape(batch\_size, -1)
out = self.fc\_layer(out)
out = self.batchnorm(out)
out = self.relu(out)
out = self.dropout\_layer(out)
out = self.out\_layer(out)
# out = torch.squeeze(out, 1)
# out = torch.sigmoid(out)
return out
def loss\_function(output, teacher\_prob, real\_label, a=0.5):
criterion\_mse = torch.nn.MSELoss()
criterion\_ce = torch.nn.CrossEntropyLoss()
return a \* criterion\_ce(output, real\_label) + (1 - a) \* criterion\_mse(output, teacher\_prob)
def init\_weights(m):
if isinstance(m, nn.Linear):
torch.nn.init.xavier\_uniform\_(m.weight)
m.bias.data.fill\_(0.01)
def eval\_nn(model, data\_loader):
predicted = []
labels = []
model.eval()
with torch.no\_grad():
for data in data\_loader:
x, y = data
x = x.to(device)
outputs = model(x)
\_, predict = torch.max(outputs.data, 1)
predict = predict.cpu().detach().numpy().tolist()
predicted += predict
labels += y
score = f1\_score(labels, predicted, average='binary')
return labels, predicted, score
def train\_distill(model, teacher, optimizer, loss\_function, distill\_loader, train\_loader, test\_loader, device, epochs=30, alpha=0.5):
best\_score = 0
score\_list = []
for epoch in range(epochs):
model.train()
for inputs, inputs\_teacher, labels in distill\_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero\_grad()
predict = model(inputs)
teacher\_predict = teacher.predict(inputs\_teacher)
loss = loss\_function(predict, teacher\_predict, labels, alpha)
loss.backward()
optimizer.step()
score\_train = round(eval\_nn(model, train\_loader)[2], 3)
score\_test = round(eval\_nn(model, test\_loader)[2], 3)
score\_list.append((score\_train, score\_test))
print(epoch, score\_train, score\_test)
if score\_test > best\_score:
best\_score = score\_test
best\_model = model
torch.save(best\_model.state\_dict(), f'./results/lstm\_{best\_score}.pt')
return best\_model, best\_score, score\_list
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
vocab\_size = tokenizer.get\_vocab\_size()
vocab\_size
score\_alpha = []
for alpha in [0, 0.25, 0.5, 0.75, 1]:
model = LSTM\_classifier(hidden\_dim=256, vocab\_size=5000, embedding\_dim=300, linear\_dim=128, dropout=0.1)
model.apply(init\_weights)
model.to(device)
optimizer = optim.AdamW(model.parameters())
\_, \_, score\_list = train\_distill(model, teacher, optimizer, loss\_function, train\_loader\_distill, train\_loader, test\_loader, device, 30, alpha)
score\_alpha.append(score\_list)
import matplotlib.pyplot as plt
import numpy as np
a\_list = [1, 0.75, 0.5, 0.25, 0]
for i, score in enumerate(score\_alpha):
\_, score\_test = list(zip(\*score))
plt.plot(score\_test, label=f'{a\_list[i]}')
plt.grid(True)
plt.legend()
plt.show()
```
### Дистилляция BERT > tinyBERT
Основная идея, как и в прошлом пункте - приближать учеником поведение учителя. Есть много вариантов что и как приближать, я взял всего два:
1. Приближать [CLS]-токен по MSE.
2. Дистилляция распределения токенов по дивергенции Кульбака-Лейблера.
Дополнительно в процессе обучения решаем задачу MLM - предсказание замаскированных токенов. Уменьшение размера модели осуществляется за счет сокращения словаря и уменьшения количества голов внимания, а также количества и размерности скрытых слоев.
Обучение итогового классификатора в итоге делится на 2 этапа:
1. Обучение языковой модели.
2. Обучение головы для классификации.
Я применял дистилляцию только для первого этапа, голову для классификации учил уже непосредственно на дистиллированной модели. Думаю можно было накинуть и вариант с MSE как в примере с BiLSTM, но оставил эти эксперименты на потом.
Ключевые моменты реализации:
Сокращение словаря:
```
from transformers import BertTokenizerFast, BertForPreTraining, BertModel, BertConfig
from collections import Counter
from tqdm.auto import tqdm, trange
import pandas as pd
train = pd.read_csv('train.csv')
X_train=list(train['text'])
tokenizer = BertTokenizerFast.from_pretrained('./rubert-tiny')
cnt = Counter()
for text in tqdm(X_train):
cnt.update(tokenizer(str(text))['input_ids'])
resulting_vocab = {
tokenizer.vocab[k] for k in tokenizer.special_tokens_map.values()
}
for k, v in cnt.items():
if v > 5:
resulting_vocab.add(k)
resulting_vocab = sorted(resulting_vocab)
tokenizer.save_pretrained('./bert_distill');
inv_voc = {idx: word for word, idx in tokenizer.vocab.items()}
with open('./bert_distill/vocab.txt', 'w', encoding='utf-8') as f:
for idx in resulting_vocab:
f.write(inv_voc[idx] + '\n')
```
Инициализация весов
```
config = BertConfig(
emb_size=256,
hidden_size=256,
intermediate_size=256,
max_position_embeddings=512,
num_attention_heads=8,
num_hidden_layers=3,
vocab_size=tokenizer_distill.vocab_size
)
model = BertForPreTraining(config)
model.save_pretrained('./bert_distill')
from transformers import BertModel
# load model without CLS-head
teacher = BertForPreTraining.from_pretrained('./rubert-tiny')
tokenizer_teacher = BertTokenizerFast.from_pretrained('./rubert-tiny')
# copy input embeddings accordingly with resulting_vocab
model.bert.embeddings.word_embeddings.weight.data = teacher.bert.embeddings.word_embeddings.weight.data[resulting_vocab, :256].clone()
model.bert.embeddings.position_embeddings.weight.data = teacher.bert.embeddings.position_embeddings.weight.data[:, :256].clone()
# copy output embeddings
model.cls.predictions.decoder.weight.data = teacher.cls.predictions.decoder.weight.data[resulting_vocab, :256].clone()
```
MLM-loss
```
inputs = tokenizer_distill(texts, return_tensors='pt', padding=True, truncation=True, max_length=16)
inputs = preprocess_inputs(inputs, tokenizer_distill, data_collator)
outputs = model(**inputs, output_hidden_states=True)
loss += nn.CrossEntropyLoss(
outputs.prediction_logits.view(-1, model.config.vocab_size),
inputs['labels'].view(-1)
)
```
KL-loss
```
def loss_kl(inputs, outputs, model, teacher, vocab_mapping, temperature=1.0):
new_inputs = torch.tensor(
[[vocab_mapping[i] for i in row] for row in inputs['input_ids']]
).to(inputs['input_ids'].device)
with torch.no_grad():
teacher_out = teacher(
input_ids=new_inputs,
token_type_ids=inputs['token_type_ids'],
attention_mask=inputs['attention_mask']
)
# the whole batch, all tokens after the [cls], the whole dimension
kd_loss = torch.nn.KLDivLoss(reduction='batchmean')(
F.log_softmax(outputs.prediction_logits[:, 1:, :] / temperature, dim=1),
F.softmax(teacher_out.prediction_logits[:, 1:, vocab_mapping] / temperature, dim=1)
) / outputs.prediction_logits.shape[-1]
return kd_loss
```
MSE-loss
```
input_teacher = {k: v for k, v in tokenizer_teacher(
texts,
return_tensors='pt',
padding=True,
max_length=16,
truncation=True
).items()}
with torch.no_grad():
out_teacher = teacher_mse(**input_teacher)
embeddings_teacher_norm = torch.nn.functional.normalize(out_teacher.pooler_output)
input_distill = {k: v for k, v in tokenizer_distill(
texts,
return_tensors='pt',
padding=True,
max_length=16,
truncation=True
).items()}
out = model(**input_distill, output_hidden_states=True)
embeddings = model.bert.pooler(out.hidden_states[-1])
embeddings_norm = torch.nn.functional.normalize(adapter_emb(embeddings))
loss = torch.nn.MSELoss(embeddings_norm, embeddings_teacher_norm)
```
Размер итоговой модели составил **16 Мб**, метрика F1 **0.86**. Учил модель я 12 часов на макбук эйр 19 года с i5 и 8 Гб оперативной памяти. Думаю, если погонять подольше, то и результат будет получше.
Код и данные для обучения представлены на [github](https://github.com/shitkov/distillation), замечания, дополнения и исправления приветствуются. | https://habr.com/ru/post/692570/ | null | ru | null |
# Программирование в уравнениях
В обычном, как императивном, так и функциональном программировании вся программа по большому счету сводится к огромному числу равенств **x = ...**, где слева стоит переменная, а справа — выражение, зависящее от переменных. А языки программирования предоставляют синтаксический сахар, что бы записать это множество как можно более компактно. Это уже почти уравнения, только тривиальные.
Некоторые сложности обнаруживаются в ленивых языках:
```
fib = 1:1:(zipWith (+) fib (tail fib))
```
Здесь fib присутствует и в левой и в правой части, то есть мы получаем полноценное уравнение, решением которого будет бесконечная последовательность чисел Фибоначчи. Так как на бесконечных последовательностях естественным образом определяется топология, Haskell может решить это уравнение методом проcтых итераций (через оператор неподвижной точки).
Еще дальше по пути уравнений пошел Prolog. Каждый предикат определяет уравнение на множествах, хоть и записывается без знака равенства. Решаются такие уравнения почти перебором и возможность использовать в них арифметику сильно ограничена.
Но есть язык, в котором уравнения являются важнейшей частью — это [Modelica](http://en.wikipedia.org/wiki/Modelica).
```
model Point
Real x,y;
equation
end Point;
model Line
parameter Real len;
Point p1,p2;
equation
len = (p1.x-p2.x)^2 + (p1.y-p2.y)^2;
end Line;
```
Здесь отрезок определяется как координаты концов и длинна, при этом длина и координаты связаны очевидным уравнением.
(К сожалению, source такого языка не знает, а вставить раскрашенный pygment-ом html не получается.)
Естественно, уравнения могут быть объединены в систему:
```
model Hand
Point ph,pl;
parameter Real l1,h1,l2,h2;
Line ll1(len = l1),lh1(len = h1),ll2(len = l2),lh2(len = h2);
Real arcl,arch;
Point p;
equation
ll1.p1 = pl;
lh1.p1 = ph;
ll1.p2.x = pl.x + l1 * arcl;
lh1.p2.x = ph.x + h1 * arch;
ll1.p2 = ll2.p1;
lh1.p2 = lh2.p1;
p = ll2.p2;
p = lh2.p2;
end Hand;
```
Здесь описывается манипулятор, состоящий из четырех соединенных шарнирами реек управляемый двумя сервоприводами.
Как следует из названия, Modelica предназначена для моделирования сложных, гетерогенных систем. Ее реализации есть у знаменитого [Вольфрама](http://en.wikipedia.org/wiki/Wolfram_SystemModeler), производителя САПР (не путать и «чертежными программами») [CATIA](http://www.3ds.com/products-services/catia/capabilities/catia-systems-engineering/modelica-systems-simulation/dymola/). Есть также и свободные реализации, такие как [OpenModelica](http://www.openmodelica.org).
Так как моделируемые объекты редко описываются алгебраическими уравнениями, Modelica умеет решать и обыкновенные дифференциальные уравнения. К сожалению, уравнения в частных производных она пока не осилила, но обычно можно разбить систему на конечные элементы и породить обыкновенные дифуры в цикле.
В качестве примера приведу модель ~~очень сложной~~ гибридной электромеханической системы — Гауссгана:
```
model Gauss
extends Modelica.Electrical.Analog.Interfaces.OnePort;
Real x (start = -1);
Real sp (start = 0);
Real co;
Real pw (start = 0);
Real ke;
Real se;
Real pe;
equation
der(pw) = i*v;
ke = sp^2/2;
se = i^2/2;
pe = pw - ke - se;
co = (if abs(x) > 0.2 then (abs(x)*(x^(-5))/3.0) else (x/((0.2^5)*3.0)));
der(sp) = -co * i;
der(x) = sp;
der(i) = v + (co * sp);
end Gauss;
model Main
Modelica.Electrical.Analog.Basic.Ground g;
Modelica.Electrical.Analog.Sources.ConstantVoltage ps;
Modelica.Electrical.Analog.Basic.Resistor rps;
Gauss gun;
equation
connect(ps.p, g.p);
connect(ps.p, gun.p);
connect(ps.n, rps.p);
connect(rps.n, gun.n);
end Main;
```
Здесь x — координата снаряда, v — напряжение, i — ток. Для отладки вычисляется полная энергия pe — ее график будет горизонтальной прямой.
Кроме текстового представления программы, в Modelica стандартизовано и графическое (хотя лично я предпочитаю работать с текстом). Для повторного использования кода применяется знакомое многим по ООП наследование. Есть обширные библиотеки по электротехнике, теплотехнике, механике и, даже, биохимии.
Разработчики «Моделик» не расчитывают охватить все одной системой — большинство реализаций допускает комоделирование с помощью [Functional Mock-up Interface](http://en.wikipedia.org/wiki/Functional_Mock-up_Interface). При желании этот же интерфейс можно задействовать для взаимодействия с внешним миром, но это пока открытая область. | https://habr.com/ru/post/202596/ | null | ru | null |
# Сниппет menuCaching для MODX Revolution
Идея сниппета очень проста. Часто требуется сделать на сайте меню, которое остаётся неизменным на всех страницах. Меняется только CSS-класс активного пункта меню. Зачем нам на каждой странице делать запросы в БД и генерировать меню, если требуется только поменять CSS-класс? А если это большое меню с выпадающими подуровнями, на его генерацию может тратиться слишком много ресурсов. Сниппет **menuCaching** позволяет избавить сервер от этой лишней работы.
##### Описание сниппета
Сниппет позволяет не генерировать меню для каждой страницы отдельно только ради того чтобы поставить CSS-класс на активный пункт меню.
Меню генерируется только один раз для всего сайта, но активные пункты отмечаются.
##### Пример использования
```
[[menuCaching?
&snippetToCache=`Wayfinder`
&cacheSuffix=`top_menu`
&contexts=`web`
&startId=`0`
&level=`1`
&hereClass=`active`
&rowTpl=`@CODE: - [[[+wf.linktext]]]([[+wf.link]])
`
]]
```
Рекомендуется создать набор параметров (например «top\_menu») чтобы, опять же, избавить парсер MODX от лишней работы:
```
[[menuCaching@top_menu]]
```
Что здесь происходит, я думаю, вы уже догадались. В кэше меню хранится в таком виде:
```
* Пункт меню 1
* Пункт меню 2
* Пункт меню 3
```
Остаётся только заменить метки типа {{active1}} на класс активного элемента, а остальные убрать, что и делает сниппет. В комплект к сниппету входит плагин, который очищает кэш при нажатии кнопки «Обновить сайт» в админке.
Важный параметр сниппета — **cacheSuffix**. В примере создаётся кэш для всего сайта, но можно создавать кэш для отдельных родительских категорий, а внутри одной категории всё будет браться из кэша:
```
&cacheSuffix=`[[*parent]]`
```
Данный сниппет можно использовать не только для меню, а например для разных слайдеров и т.п. блоков, которые на сайте не меняются на разных страницах.
Сниппет **menuCaching** в репозитории MODX: <http://modx.com/extras/package/menucaching>
**Добавлено**
Результаты тестирования с большим меню. Вызовы обоих сниппетов некэшированные, т.е. [[!snippet]] (для теста, в реальности надо кэшировать).
*Wayfinder*
Первый вызов любой из страниц где есть меню: **2.5815 сек.**
Переход на любую другую страницу с этим же меню: **2.4566 сек.** (т.е. хвалёный cacheResults не помогает)
Обновляем страницу: **1.0021 сек.** (только в этом случае cacheResults спасает)
*Тот же Wayfinder, через menuCaching*
Первый вызов любой из страниц где есть меню: **2.4842 сек.** (в рамках погрешности, естественно разницы нет)
Переход на любую другую страницу с этим же меню: **0.7008 сек.** (результат тот же, а время отличается)
Обновляем страницу: **0.4187 сек.** | https://habr.com/ru/post/167053/ | null | ru | null |
# Простой плагин для Twig или разворачиваем константы
Twig — отличный шаблонизатор и, в отличие от остальных, с которыми мне приходилось сталкиваться, со временем нравится мне все больше и больше. Достоинств у Twig много и одно из них — расширяемость.
Некоторое время мне тихонько портила жизнь небольшая проблема, на которую лень было тратить время. Недавно я все же заставил себя и, думаю, решение ее хорошо бы подошло для небольшой статейки о плагинах в Twig.
Сама проблема — в константах внутри шаблонов. Бывают такие задачи, когда в шаблоне необходимо зашиться на какие-нибудь идентификаторы. Цифрами расставлять их — не совсем хорошо, а если для них еще и существуют константы — грех не воспользоваться функцией `constant`. Но дело в том, что после компиляции из шаблона она все равно вычисляется в рантайме.
И что же у нас может получиться? Мы на волне рефакторинга убиваем или переименовываем константу, а о шаблоне забываем. И IDE забывает, даже хваленый PHPStorm. Успешно компилируем перед деплоем всю нашу гору шаблонов, раскидываем на сервера. Ничего не упало, просто работает все не очень, а на нашу голову сваливается огромная простыня одинаковых ворнингов. Плохо? Отвратительно!
Решение? Резолвить константы в процессе компиляции шаблона, на отсутствующие — ругаться.
Тем, кто не знаком с Twig или знаком не очень хорошо, расскажем (очень кратко) что каждый шаблон парсится плагинами (даже базовые возможности реализованы в шаблонизаторе с помощью плагинов), обрабатывается и компилируется в php-класс, у которого потом дергается метод `display`. Для примера возьмем такой код шаблона, как раз с нашей константой:
```
{% if usertype == constant('Users::TYPE_TROLL') %}
Давай, до свидания!
{% else %}
Привет!
{% endif %}
```
Шаблон разберется в относительно большое дерево объектов.
**Здесь немного укороченный, но все равно большой вывод print\_r представления нашего шаблона**
```
[body] => Twig_Node_Body Object (
[nodes:protected] => Array (
[0] => Twig_Node_If Object (
[nodes:protected] => Array (
[tests] => Twig_Node Object (
[nodes:protected] => Array (
[0] => Twig_Node_Expression_Binary_Equal Object (
[nodes:protected] => Array (
[left] => Twig_Node_Expression_Name Object (
[attributes:protected] => Array (
[name] => usertype
)
)
[right] => Twig_Node_Expression_Function Object (
[nodes:protected] => Array (
[arguments] => Twig_Node Object (
[nodes:protected] => Array (
[0] => Twig_Node_Expression_Constant Object (
[attributes:protected] => Array (
[value] => Users::TYPE_TROLL
)
)
)
)
)
[attributes:protected] => Array (
[name] => constant
)
)
)
)
[1] => Twig_Node_Text Object (
[attributes:protected] => Array (
[data] => Давай, до свидания!
)
)
)
)
[else] => Twig_Node_Text Object (
[attributes:protected] => Array (
[data] => Привет!
)
)
)
)
)
)
```
Оно дополнительно обрабатывается [сюда нам нужно вклиниться] и в итоге компилируется вот в такой файл (тоже слегка укороченный вариант):
```
class __TwigTemplate_long_long_hash extends Twig_Template {
protected function doDisplay(array $context, array $blocks = array()) {
if (((isset($context["usertype"]) ? $context["usertype"] : null) == twig_constant("Users::TYPE_TROLL"))) {
echo "Давай, до свидания!";
} else {
echo "Привет!";
}
}
}
```
`$context` здесь — то, что попало в кучу переменных на вход этому шаблону. Надеюсь, все понятно и ничего объяснять не надо. Функция `twig_constant` практически не отличается от стандартной `constant` и резолвится в рантайме.
Чтобы посмотреть на проблему своими глазами убираем константу из кода и на рендере ловим:
`PHP Warning: constant(): Couldn't find constant Users::TYPE_TROLL in vendor/twig/twig/lib/Twig/Extension/Core.php on line 1387`
Именно вызов `twig_constant` в компилированном варианте нам нужно заменить на значение константы.
Для расширений в шаблонизаторе предусмотрен класс `Twig_Extension`, от которого мы и наследуем наше расширение. Расширение может предоставлять шаблонизатору наборы функций, фильтров и прочей ерунды, какой только можно придумать, через специальные методы, которые вы можете сами найти в интерфейсе `Twig_ExtensionInterface`. Нас интересует метод `getNodeVisitors`, который возвращает массив объектов, через которых будут пропущены все элементы распарсенного дерева шаблона перед его компиляцией.
```
class Template_Extensions_ConstEvaluator extends Twig_Extension {
public function getNodeVisitors() {
return [
new Template_Extensions_NodeVisitor_ConstEvaluator()
];
}
public function getName() {
return 'const_evaluator';
}
}
```
Нам нужно перед компиляцией просто пройтись по всем нодам, найти среди них функцию constant с обычным текстовым аргументом и поменять на его значение, либо ругнуться на то, что такой константы нет.
Вот таким наш node visitor и получается:
```
class Template_Extensions_NodeVisitor_ConstEvaluator implements Twig_NodeVisitorInterface {
public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
{
// ищем ноду-функцию с названием constant и 1 аргументом
if ($node instanceof Twig_Node_Expression_Function
&& 'constant' === $node->getAttribute('name')
&& 1 === $node->count()
) {
// получаем аргументы функции
$args = $node->getNode('arguments');
if ($args instanceof Twig_Node
&& 1 === $args->count()
) {
$constNode = $args->getNode(0);
// 1 текстовый аргумент
if ($constNode instanceof Twig_Node_Expression_Constant
&& null !== $value = $constNode->getAttribute('value')
) {
if (null === $constantEvaluated = constant($value)) {
// не можем найти константу - ругаемся
throw new Twig_Error(
sprintf(
"Can't evaluate constant('%s')",
$value
)
);
}
// все нашлось, возвращаем вместо функции ноду со значением константы
// не введитесь в заблуждение названием класса :]
return new Twig_Node_Expression_Constant($constantEvaluated, $node->getLine());
}
}
}
// все ок, возвращаем то, что получили, в целости и сохранности
return $node;
}
public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env) {
return $node;
}
}
```
Вот так мы и заменили чуть ли не треть нашего дерева шаблона обычным значением.
**На всякий случай покажу, что же получилось в компилированном варианте**
```
class __TwigTemplate_long_long_hash extends Twig_Template {
protected function doDisplay(array $context, array $blocks = array()) {
if (((isset($context["usertype"]) ? $context["usertype"] : null) == 2)) {
echo "Давай, до свидания!";
} else {
echo "Привет!";
}
}
}
```
Просто, интересно, полезно.
Надеюсь, кого-то это подтолкнет покопаться в Twig и попытаться расширить его чем-то кроме функций, да фильтров. Готов выслушать любую критику, а утром — даже ответить на вопросы. Дискас! | https://habr.com/ru/post/200614/ | null | ru | null |
# Еще один способ защиты веб-форм от роботов
Предисловие
-----------
Выношу на суд читателей хабры свой способ защиты форм от спам-ботов. Способ базируется на том, что большинство ботов не умеют читать таблицы стилей и выполнять коды javascript. Зато около 90% всех браузеров поддерживают эти технологии. Остальные 10% — это старые браузеры и браузеры с отключенным javascript. Если вдуматься, то навряд ли пользователи этих 10% имеют своей целью пользоваться формами обратной связи, регистрации на форумах, гостевых и пр. Сейчас вкратце рассмотрю способы борьбы с таким спамом на сегодняшний день.
Существующие способы борьбы и их минусы
---------------------------------------
#### Способы:
* Использование CAPTCHA
* Комбинирование перечисленных способов
#### Минусы:
К минусам можем отнести раздражение пользователя, которого заставляют решать головоломки, угадывать числа, буквы. Дальше, большинство сегодняшних графических капчей являются так называемыми «слабыми капчами» и взламываются с помощью нехитрых серверных скриптов OCR. Здесь также стоит упомянуть «метод леммингов», где в процессе распознавания капчи принимают участие множество настоящих людей: спамеры переразмещают вопрос/картинку со взламываемого сайта на специальных сайтах с высокой посещаемостью, где, чтобы получить доступ к информации человек разгадывает таку капчу и передает результат спамерам. Еще метод поинтересней — прямой наем людей для отгадывания.
Суть моего способа
------------------
На странице создаем фиктивную форму и прячем ее поля от глаз пользователя, используя элемент таблицы стилей display:none. Далее, запустив на странице определенную javascript-функцию где-то за пределами фиктивной формы, выводим вместо нее настоящую с действительными названиями полей. При отправке роботом фиктивной формы, интерпретатор получает массив с неверными названиями и, например, выводит сообщение об ошибке. В случае же с реальным пользователем, форма обрабатывается нормально.
#### Преимущества:
* 95% гарантия отсечения спам-бота
* отсутствие нужды для человека разгадывать captcha
* простота реализации для разработчика
* нагрузка на спамерский сервер из-за потребности выполнять javascript и css
#### Минусы:
* Рано или поздно взломают
Реализация
----------
Основная часть работы выполняется на стороне клиента с помощью CSS и Javascript. С
помощью CSS, который желательно подключать к странице из отдельного файла, прячем
форму-ловушку от глаз пользователя:
`#ourGreatForm {display:none;}`
Дальше пишем простой javascript (кстати, тоже можно вынести в отдельный файл), со следующим содержанием:
```
function GenerateSomethingGreatForRealPeople() {
// Объявляем о нашей переменной
var ourfields = '
'+
'
'+
'
'+
'';
// Заменяем подставные поля на тех машинах, где выполняется Javascript
document.getElementById("ourGreatForm").innerHTML=ourfields;
// Включаем отображение реальных полей
document.getElementById("ourGreatForm").style.display="block";
}
``` | https://habr.com/ru/post/16190/ | null | ru | null |
# Как зарегистрировать пользователя и не сломать себе голову
С чего начинается работа с приложением, ботом или сайтом? Ответ прост — с регистрации пользователя в вашей системе.
В этой статье я расскажу, с какими неочевидными проблемами мы столкнулись при разработке регистрации в ботах, сайтах и приложениях. Простая на первый взгляд операция может принести существенные проблемы, если не учитывать некоторые нюансы.
Кажется, что может быть проще регистрации? Сделал стринговую переменную с ФИО, закрыл дело и пошел писать настоящий функционал. Но не тут-то было.
С вероятностью 90%, если вы сделаете так, то поначалу все будет хорошо работать, однако через некоторое время могут возникнут проблемы. Вы посмотрите в свою БД и обнаружите огромное количество мусора вместо данных, а в худшем — вы найдете свою базу в открытом доступе на всяких сомнительных форумах.
### Почему это произошло?
Если у вас такой выбор даты, то можете ее просто убрать, никакого смысла в ней нетВо-первых, никакой мотивации давать вам свои реальные данные у пользователя нет, например, в [стиме](https://www.reddit.com/r/gaming/comments/qr138/valve_93_of_steam_users_born_on_january_1st) 93% пользователей родилось 1 января. Объясняется такая аномалия очень просто — первый день в году стоит по умолчанию в форме выбора даты рождения и, конечно, пользователь не тратит свое время на выбор реальной даты, а просто жмет кнопку ОК и идет качать игры. И получается, что эти данные просто мусор и никакой адекватной аналитики сделать не получится. Почему это плохо, я не буду тут писать, вы все сами понимаете. Ну, а второе — просто безопасность, но об этом я расскажу чуть позже.
У нас есть проблема и нам надо ее решать. Как всегда, нужно использовать кнут и пряник для баланса. Как накормить кондитерским изделием — это задача вашего продукта, потому что для каждого случая все уникально. А вот кнут достаточно стандартный и универсальный для всех проектов.
### Регулярные выражения
Очевидным решением будет проверять на адекватность данные, которые пишет пользователь. Есть всякие исключения, но, как правило, людей не зовут "X Æ A-12". Поэтому можно смело внедрять регулярные выражения и прогонять через них данные от пользователя.
Какие конкретно регулярки ставить решать только вам, для каждого проекта, повторяюсь, свое решение. А далее поговорим о типовых случаях, которые нам доставили немало головной боли.
Итак, вам в начале надо определиться о ЦА вашего продукта, поскольку каждый конкретный выбор поведет вас по уникальному пути. Продукт для какого рынка? Русского или зарубежного? Если зарубежного, то какого — китайского или европейского? Пользователи пишут на латинице, кириллице или на своей уникальной системе письма?
Да-да, это все нужно для простой и тупой, на первый взгляд, задачи как регистрация пользователя. Дело в том, что мы с вами европейцы и мыслим соответствующее, а в мире огромное количество народа с другими культурами, у которых другой тип письменного мышления, если это так можно назвать. Вариантов огромное количество, более опытные люди расскажут вам о работе со всякими редкими вещами по типу старомоногольской вертикальной письменности ᠮᠤᠩᠭᠤᠯ ( Вот тут забавно, хабр не умеет корректно отображать такой вариант письма) или арабской вязи. Поэтому определяемся, с чем мы будем работать и отсекаем все лишнее. По стандарту будем регистрировать человека на кириллице, в регулярных выражениях разрешаем только её.
Но есть одиннадцать нюансов:
----------------------------
1. **ФИО одним полем.**
Зачастую вместо трех полей делают одно, куда предлагают ввести все, что у человека есть. Кажется, в чем тут проблема? Первое слово — фамилия, второе — имя, а третье, соответственно — отчество. Но не тут было, во-первых, пользователи часто путают очередность, во-вторых, уних может быть двойное имя или отсутствовать отчество. И это либо запретит регистрацию этого пользователя, либо снизит качество данных.
В идеале вы должны всегда разбивать ФИО на три разных переменных, но иногда это невозможно, потому что долгая регистрация отобьет желание использовать ваш продукт, и поэтому надо от человека в одном поле как можно быстрее получить данные. Но тогда вам надо будет отказываться от части функционала или писать монстра, который определяет где что находится и уже внутри вашей программы присваивать соответствующий класс.
**2. Двойные фамилии.**
Раз уже начали с этим нюансом, то продолжаем. Банальная конструкция из одного поля нормально работает, до того как вам впервые встречается человек с двойной фамилией. И тут возникает проблема — двойная фамилия по сути это одно слово, но знак не принадлежит к кириллице, из-за чего регистрация невозможна. Так что необходимо помнить об этом.
**3. Двойные имена.**
Аналогично с предыдущим пунктом, только теперь представьте, что бывают люди с двойными именами и с двойными фамилиями одновременно, и их полное ФИО может быть очень длинным, поэтому разучиваем максимальную длину вводимого текста с запасом.
**4. ФИО из большого количества слов.**
Культурный фактор, мы в России привыкли, что слов в ФИО три, хотя в некоторых странах оно может состоять из большего количества. Поэтому также учитываем это в регулярных выражениях, или делаем пометку какую часть имени и где использовать.
**5. Отчество.**
Из-за того, что мы все немного русскоцентричны, мы иногда забываем о других культурах, где наименования строились по совершенно другим принципам. Среднеазиатские, японские, китайские, корейские ФИО могут состоять из большего количества слов, и ни одно из них не будет отчеством.
**6. Проблемы с Оглы, ибн.**
А тут обратная ситуация, в тюркских языках Оглы по сути является отчеством, однако оно может писаться как через дефис, так и как отдельное слово. Учтите этот пункт, чтобы не перепутать расфасовку по переменным.
**7. Несколько видов - .**
‐, −, –, —. Нет, это не смайлики, это слева на право: дефис, минус, короткое тире и тире. И если у вас стоит проверка на двойное имя/фамилию, то там должен стоять знак дефиса, но пользователи могут вставить любой другой из этих символов, а регулярка просто не пропустит дальше.
**8. Латиница в буквах.**
Еще дополнительный аргумент вводить регулярки — это латинские буквы в русских словах. Вы не представляете сколько вам добавит боли выискивать скрытую латинскую "o" в фамилии Иванoв.
**9. Буква Ё.**
Если все остальные случаи являются универсальными для любых языков, то этот кейс только для русского языка. Дело в том, что regex просто не знает, что у нас в алфавите есть буква [ё](https://www.5-tv.ru/news/58920/). Т.е. если вы напишите регулярное выражение для имени и фамилии не больше, чем 50 символов`([А-Я][а-я]{1,49})\ ([А-Я][а-я]{1,49})`, то такое выражение не пропустит ни мое имя (Пётр), ни содержащую эту букву фамилию. Поэтому отдельно добавляем ее в регулярки.
Добавляем в регулярки ё для корректной работы.**10. Несколько тысяч символов.**
Самый тупой и самый надежный способ повесить регистрацию. Вы вводите несколько десятков тысяч символов и просто ждете. Вот тут зависит от платформы, с которой вы работаете. У нас часто был телеграмм, поэтому на нем и покажу. Он разбивает огромные сообщения на несколько частей и одновременно отсылает их на сервер. И получается, что тригер работает не на одно сообщение, а на десятки, если не сотни. Например, если у вас стоит ответное сообщение после регистрации
привет, username,
то пользователю придут несколько сотен огромных сообщений, включая это длинное имя на тысячи символов. Из-за этого есть вероятность повесить весь ваш сервис или частично сломать его.
Я лично видел, как загрузочный экран мобильного приложения Сбербанка был искорежен именем в несколько тысяч случайных символов. Так что это бич не только маленьких проектов.
**11. Транскрипция (слаги).**
Чуть в сторону, но думаю будет полезно. Если у вас есть перевод значений в латиницу (например, ФИО для писем за границу), то необходимо использовать единый инструмент создания слагов (человекочитаемые идентификаторы) в проекте. У нас в одном проекте были использованы 2 разных методологии создания слагов на фронте и бэке, и мы долго не понимали в чем проблема. Оказалось, что у нас идет ключевание через слаги, которые сформированы по-разному. Например, слово "транслитерация" в различных системах выглядит вот так: Transliteraciya и Transliteratsiya.
Ну, а теперь ответ на главный вопрос — почему такая обложка поста?
На скрине вы видите SQL-инъекцию. Вы наверное часто встречали это выражение, но не понимали что это по сути.
Так что же такое эта ваша SQL-иньекция? Если совсем просто, то при регистрации под видом имени пользователя вам в БД летит тупо, скорее всего, вредоносный SQL-код. Какой конкретно — неизвестно, но это дыра прямо к вам в БД.
- Как вас зовут?
- Меня зовут `DROP DATABASE base1`
И все, вашей базы больше нет. Да, конечно, шанс, что атакующий угадает с названием таблицы, очень мал, но никто не отменял брутфорс и промышленный шпионаж, оставлять такую дыру очень опасно. По защите от инъекций написаны сотни статей и это стандарт в ИБ. Поэтому инъекции, в подавляющем числе случаев можно сделать только тогда, когда разработчик вообще не подозревает, что так можно.
Это было финальным аргументом необходимости вводить регулярные выражения.
Основные выводы:
----------------
1. Меньше европоцентричности. У других культур свои правила составления имен —и это надо учитывать. Либо подгонять под свой формат, но по унифицированым сценариям.
2. Если можно разделить ФИО на отдельные поля — делите обязательно, это вам значительно упростит жизнь.
3. Если нет совсем критичных противопоказаний, то на всякий случай добавьте регулярные выражения.
4. Помните, что если вы напрямую кладете что-то в БД, то значит при желании, *внешние* *специалисты* могут сделать все что угодно с вашей базой.
5. Лучше предусмотреть самые редкие варианты написания имен, чтобы потом не бегать и искать проблему, которую зачастую сложно обнаружить.
Я не претендую на гайд, описал лишь те случаи, с которыми лично столкнулся и которые добавили мне немало головной боли. Смысл статьи — помочь новичкам обнаружить скрытые подводные камни и избавить их проекты от потенциальных проблем. | https://habr.com/ru/post/590525/ | null | ru | null |
# RS-485 на отечественных микроконтроллерах от фирмы Миландр
Несколько дней назад я имел неосторожность завуалированно пообещать запилить пост про Миландр… Ну что ж, попробуем.
Как вы, вероятно, уже знаете, существует российская компания Миландр, которая, среди прочего, выпускает микроконтроллеры на ядре ARM Cortex-M. Волею судеб я был вынужден с ними познакомиться достаточно плотно, и *познал боль*.
Небольшая часть этой боли, вызванная работой с RS-485, описана далее. Заранее прошу прощения, если слишком сильно разжевываю базовые понятия, но мне хотелось сделать эту статью доступной для понимания более широкой аудитории.
Так же заранее оговорюсь, что имел дело только с 1986ВЕ91 и 1986ВЕ1, о других уверенно говорить не могу.
**TL; DR**Миландровскому UART’у не хватает прерывания «Transmit complete», костыль – «режим проверки по шлейфу», т.е. режим эха. Но с нюансами.
### Вступление
Интерфейс RS-485 (так же известный как EIA-485, хотя я ни разу не слышал, чтобы его так называли в обиходе) – это асинхронный полудуплексный интерфейс с топологией «шина». Этот стандарт оговаривает только физику — т.е. уровни напряжения и временные диаграммы — но не оговаривает протокол обмена, защиту от ошибок передачи, арбитраж и тому подобное.
По факту, RS-485 — это просто полудуплексный UART с повышенными уровнями напряжения по дифференциальной паре. Именно эта простота и обеспечивает популярность RS-485.
Чтобы превратить UART в RS-485 используются специальные микросхемы-преобразователи, такие как MAX485 или 5559ИН10АУ (от того же Миландра). Они работают почти «прозрачно» для программиста, которому остается только правильно выбирать режим работы микросхемы – прием или передача. Делается это с помощью ног nRE (not Receiver Output Enable) и DE (Driver Output Enable), которые, как правило, объединяются и управляются одной ногой микроконтроллера.
Поднятие этой ноги переключает микросхему на передачу, а опускание — на прием.
Соответственно, все, что требуется от программиста, это поднять эту ногу RE-DE, передать нужное количество байт, опустить ногу и ждать ответа. Звучит достаточно просто, правда?
Хе-хе.
### Проблема
Эту ногу нужно опустить в тот момент, когда все передаваемые байты полностью переданы на линию. Как поймать этот момент? Для этого нужно отловить событие «Transmit complete» (передача завершена), которое генерирует блок UART'a в микроконтроллере. В большинстве своем события – это выставление бита в каком-нибудь регистре или запрос прерывания. Чтобы отловить выставление бита в регистре, регистр нужно опрашивать, т.е. использовать код, вроде этого:
```
while( MDR_UART1->FR & UART_FR_BUSY ) {;}
```
Это если мы можем себе позволить полностью остановить выполнение программы, пока все байты не будут переданы. Как правило, мы себе этого позволить не можем.
Прерывание в этом отношении гораздо удобнее, поскольку оно прилетает само по себе, асинхронно. В прерывании мы можем быстренько опустить RE-DE и всего делов.
Разумеется, если бы мы могли так сделать, никакой боли бы не было и этого поста бы тоже не было.
Дело в том, что в блоке UART, который Миландр ставит во все свои микроконтроллеры на Cortex-M (насколько мне известно), нет прерывания по событию «Передача завершена». Есть только флаг. И есть прерывание «Буфер передатчика пуст». И прерывание «байт принят», конечно же.
**Еще есть**куча других прерываний и режим FIFO, на мой взгляд, совершенно бесполезный. Если кто-нибудь понимает, зачем он нужен, расскажите, пожалуйста!
Проблема в том, что «Буфер передатчика пуст» – это совсем не то же самое, что «Передача завершена». Насколько я понимаю внутреннее устройства UART'a, событие «Буфер пуст» означает, что в буфере передатчика есть хотя бы одно свободное место. Даже в случае, если это место всего одно (т.е. буфер размером в один байт), это лишь означает, что последний передаваемый байт был скопирован во внутренний сдвиговый регистр, из которого этот байт будет выползать на линию, бит за битом.
Короче говоря, событие «буфер передатчика пуст», не означает, что все байты были переданы полностью. Если мы опустим RE-DE в этот момент, то мы «обрежем» нашу посылку.
Что же делать?
### Ребус
**Расшифровка:** «Прополка битовых полей» — это локальный мем из короткой, но наполненной болью темы на форуме Миландра — [forum.milandr.ru/viewtopic.php?f=33&t=626](http://forum.milandr.ru/viewtopic.php?f=33&t=626).
Простейшее решение – это таки «пропалывать» (от английского «poll» — непрерывный опрос) флаг UART\_FR\_BUSY.
Разумеется, это решение не очень приятно. Если мы не можем блокирующе проверять этот флаг, то приходится проверять его периодически. Чтобы проверять его периодически, приходится городить целый огород (особенно, если вы хотите написать переносимый модуль, а не просто разово решить эту проблему).
Если использовать какую-нибудь ОСРВ, то ради этой прополки приходится заводить целую отдельную задачу, будить ее в прерывании, ставить ей не самый низкий приоритет, морока, короче.
Но, казалось бы, ладно, помучились разок, дальше используем и радуемся. Но нет.
К сожалению, нам мало опустить RE-DE строго после того, как все байты были переданы до конца. Нам нужно опустить ее *не слишком поздно*. Потому что мы на шине не одни. На наше сообщение, скорее всего, должен прийти какой-то ответ от другого абонента. И если мы опустим RE-DE слишком поздно, мы не переключимся в режим приема и потеряем несколько бит ответа.
Время, которое мы можем себе позволить «передержать» ногу RE-DE, зависит, в основном, от скорости передачи (бодрейта) и от быстроты устройства, с которым мы общаемся по шине.
В моем случае скорость была относительно невелика (57600 бод), а устройство было достаточно резвым. И иногда так случалось, что у ответа терялся бит-другой.
В целом, не очень хорошее решение.
### Таймер
Второй вариант, который приходит в голову – использовать аппаратный таймер. Тогда в прерывании «Буфер передатчика пуст» мы запускаем таймер с таймаутом, который равен времени передачи одного байта (это время легко вычисляется из бодрейта), а в прерывании от таймера — опускать ногу.
Хороший, надежный способ. Только таймер жалко; их у Миландров традиционно немного – две-три штуки.
### Режим шлейфа
Если внимательно читать тех. описание на UART — [например, для 1986ВЕ91Т](https://ic.milandr.ru/upload/iblock/3e9/3e97676df3bc8852308a49e6050c40ca.pdf) — можно заметить вот этот очень короткий абзац:
`Проверка по шлейфу
Проверка по шлейфу (замыкание выхода передатчика на вход приемника) выполняется путем установки в 1 бита LBE в регистре управления контроллером UARTCR.`
Если же тех. описание не читать, то практически того же эффекта можно добиться, закоротив ноги RX и TX аппаратно.
**Мысли вслух**Интересно, причем тут какой-то шлейф? Обычно такой режим называется «эхо», ну да ладно.
Идея состоит в следующем — перед передачей последнего байта в посылке, нужно активировать режим «проверки по шлейфу». Тогда можно получить прерывание по приему нашего собственного последнего байта в тот момент, когда он полностью вылезет на шину! Ну, почти.
На практике оказалось, что прерывание по приему срабатывает *немножко* раньше, чем должно, примерно на треть битового интервала. Я не знаю с чем это связано; возможно, в режиме проверки по шлейфу не происходит настоящего сэмплирования линии, может быть, режим шлейфа не учитывает последний стоп-бит. Не знаю. Как бы то ни было, мы не можем опустить RE-DE сразу по входу в это прерывание, потому что так мы «отрежем» от нашего последнего байта стоп-бит или часть стоп-бита.
Строго говоря, можем или не можем зависит от соотношения скорости работы интерфейса (т.е. длительности одного битового интервала) и частоты работы микроконтроллера, но я на 80 МГц тактовой частоты и с бодрейтом 57600 не мог.
Далее возможны варианты.
Если вы можете себе позволить опрашивать флаг UART\_FR\_BUSY в течение одного битового интервала — на деле даже чуть меньше, потому что вход в прерывание и предварительные проверки тоже отнимают время — то выход найден. Для скорости 57600 максимальное время опроса составит ~18 микросекунд (один битовый интервал), на практике — около 5 микросекунд.
**Для тех, кому интересно, привожу код обработчика прерывания целиком.**
```
void Handle :: irqHandler(void)
{
UMBA_ASSERT( m_isInited );
m_irqCounter++;
// --------------------------------------------- Прием
// do нужен только чтобы делать break
do
{
if ( UART_GetITStatusMasked( m_mdrUart, UART_IT_RX ) != SET )
break;
// по-факту, прерывание сбрасывается при чтении байта, но это недокументированная фича
UART_ClearITPendingBit( m_mdrUart, UART_IT_RX );
uint8_t byte = UART_ReceiveData( m_mdrUart );
// для 485 используется режим шлейфа, поэтому мы можем принимать эхо самих себя
if( m_rs485Port != nullptr && m_echoBytesCounter > 0 )
{
// эхо нам не нужно
m_echoBytesCounter--;
if( m_echoBytesCounter == 0 )
{
// после последнего байта надо __подождать__,
// потому что мы принимаем его эхо до того, как стоп-бит до конца вылезет на линию
// из-за мажоритарной логики семплирования.
// Если не ждать, то можно потерять около трети стоп-бита.
// Время ожидания зависит от бодрейта, примерное время ожидания:
// бодрейт | длительность бита, | время ожидания, |
// | мкс | мкс |
// | | |
// 9600 | 105 | 32 |
// 57600 | 18 | 4,5 |
// 921600 | 1 | 0 |
// | | |
// при использовании двух стоп бит и/или бита четности,
// время прополки вроде как не меняется.
// Видимо, пропалывается только треть последнего бита, не важно какого.
// блокирующе пропалываем бит
while( m_mdrUart->FR & UART_FR_BUSY ) {;}
// и только теперь можно выключать передатчик и режим шлейфа
rs485TransmitDisable();
// семафор, что передача завершена
#ifdef UART_USE_FREERTOS
osSemaphoreGiveFromISR( m_transmitCompleteSem, NULL );
#endif
}
break;
}
// если в приемнике нет места - байт теряется и выставляется флаг overrun
#ifdef UART_USE_FREERTOS
BaseType_t result = osQueueSendToBackFromISR( m_rxQueue, &byte, NULL );
if( result == errQUEUE_FULL )
{
m_isRxOverrun = true;
}
#else
if( m_rxBuffer.isFull() )
{
m_isRxOverrun = true;
}
else
{
m_rxBuffer.writeHead(byte);
}
#endif
} while( 0 );
// --------------------------------------------- Ошибки
// Проверяем на ошибки - обязательно после приема!
// К сожалению, функций SPL для этого нет
m_error = m_mdrUart->RSR_ECR;
if( m_error != error_none )
{
// Ошибки в регистре сбрасывается
m_mdrUart->RSR_ECR = 0;
}
// --------------------------------------------- Передача
if( UART_GetITStatusMasked( m_mdrUart, UART_IT_TX ) != SET )
return;
// предпоследний байт в 485 - включаем режим шлейфа
if( m_txCount == m_txMsgSize - 1 && m_rs485Port != nullptr )
{
setEchoModeState( true );
m_echoBytesCounter = 2;
}
// все отправлено
else if( m_txCount == m_txMsgSize )
{
// явный сброс можно (и нужно) делать только для последнего байта
UART_ClearITPendingBit( m_mdrUart, UART_IT_TX );
m_pTxBuf = nullptr;
return;
}
// Еще есть, что отправить
UMBA_ASSERT( m_pTxBuf != nullptr );
UART_SendData( m_mdrUart, m_pTxBuf[ m_txCount ] );
m_txCount++;
}
```
Если вы можете себе позволить перемычку (в идеале – управляемую) между ногами RX и TX, то всё тоже хорошо.
К сожалению, на сегодняшний день других вариантов я предложить не могу.
На этом у меня все. Если кому-нибудь известны другие способы решения этой проблемы, прошу поделиться ими в комментариях.
Так же, пользуясь случаем и изменением правил Хабра, хочу пропиарить сайт [StartMilandr](https://startmilandr.ru/doku.php/start), который представляет собой собрание статей о микроконтроллерах Миландр. По неясной причине нагуглить его можно разве что случайно.
И, конечно же, напомнить о существовании [форка стандартной периферийной библиотеки,](https://github.com/eldarkg/emdr1986x-std-per-lib) в котором, в отличие от официальной библиотеки, исправляются баги и есть поддержка gcc. | https://habr.com/ru/post/439450/ | null | ru | null |
# AJAX в CakePHP на jQuery и Prototype
Небольшой пример реализации AJAX в CakePHP, пример показывает, как легко работать с AJAX в СakePHP, всю работу берет на себя фреймворк. Реализуем пример на библиотеке jquery.js затем переделаем наш пример на библиотеку prototype.js
**Начало**
Нам потребуется установленный и настроенный фреймворк CakePHP.
Наш пример будет состоять из постов и комментариев к ним, в комментариях мы задействуем технологию AJAX.
Создадим таблицы posts и comments:
```
CREATE TABLE `comments` (
`id` varchar(36) COLLATE utf8_unicode_ci NOT NULL,
`post_id` varchar(36) COLLATE utf8_unicode_ci NOT NULL,
`title` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`body` text COLLATE utf8_unicode_ci,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
CREATE TABLE `posts` (
`id` varchar(36) COLLATE utf8_unicode_ci NOT NULL,
`title` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
`body` text COLLATE utf8_unicode_ci,
`created` datetime DEFAULT NULL,
`modified` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
```
Всю “грязную” работу предоставим bake, а именно помощью команды cake bake, консольного приложения фреймворка CakePHP (\app\Console\cake ) я генерирую модель, контроллер, и вид нашего приложения, bake задаст пару вопросов и автоматически свяжет наши модели, установит проверку на вводимые в модель данные. Очень подробно работа cake bake рассмотрена в главе 8 “Using Shells: Get Further, Faster” книги Ahsanul Bari, Anupom Syam “CakePHP Application Development”.
**Подключаем jQuery**
Нужно добавить в файл app\View\Layouts\default.ctp следующую строку:
```
echo $this->Html->script('jquery-1.8.3.min');
```
Библиотеку 'jquery-1.8.3.min.js' необходимо положить в app\webroot\js\
Укажем хелперу фреймворка CakePHP какую из JavaScript библиотек мы используем, в контроллер app\Controller\AppController.php добавляем:
```
public $helpers = array('Js' => array('Jquery');
```
Но наше приложение уже использует хелперы 'Html','Form','Session','Paginator', они подключались автоматически, пока мы не задали хелпер явным образом, потому добавляем их в инициализатор хелпера:
```
public $helpers = array('Html','Form','Session','Js' => array('Jquery'),'Paginator');
```
**Движок AJAX**
Теперь основной код, который будет генерировать движок AJAX.
```
php foreach($comments as $comment): ?
**php echo $comment['Comment']['title'];?**
php echo $comment['Comment']['body'];?
php endforeach;?
php echo $this-Form->create('Comment',array('controller' =>'comments', action'=>'add','onSubmit'=>'return false;'));
echo $this->Form->input('Comment.title');
echo $this->Form->input('Comment.body');
echo $this->Form->input('Comment.post\_id',array('type'=>'hidden','value'=>$comment['Comment']['post\_id']));
echo $this->Js->submit('Add Comment',array('url'=>'/comments/add\_ajax','update'=>'#comments','evalScripts'=>'true'));
echo $this->Js->writeBuffer(); //сам движок
echo $this->Form->end(); ?>
```
Данный код помещаем в существующий файл app\View\Posts\view.ctp и немного измененный код для повторного использования в новый файл app\View\Comments\add\_success.ctp. Весь движок AJAX помещается в 3-х строках, если их удалить получим обычную форму для ввода:
```
'onSubmit'=>'return false;' //убираем обычную кнопку, генерируется в форме по умолчанию
echo $this->Js->submit('Add Comment',array('url'=>'/comments/add_ajax','update'=>'#comments','evalScripts'=>'true')); //добавляем кнопку с AJAX
echo $this->Js->writeBuffer(); //CakePHP генерирует и вставляет JavaScript код
```
Функция $this->Js->submit() поддерживает много параметров, возможно, вы заходите получить данные с сервера в формате JSON или использовать метод GET подробности настроек [тут](http://book.cakephp.org/2.0/en/core-libraries/helpers/js.html#JsHelper::request), но нас интересуют только:
```
'url'=>'/comments/add_ajax' // указываем контроллер и действие, которое должно выполниться при нажатии кнопки submit.
'update'=>'#comments', // указываем изменяемые данные в html файле, в данном случае идентификатор (#comments).
'evalScripts'=>'true' //для совместимости с библиотекой prototype, иначе AJAX машина будет работать только один раз.
```
если запустить наш пример, то увидим, что CakePHP уже сделал всю работу, а именно подключил и настроил функцию $.ajax библиотеки jQuery:
```
//<![CDATA[
$(document).ready(function () {$("#submit-1030630577").bind("click", function (event) {$.ajax({data:$("#submit-1030630577").closest("form").serialize(), dataType:"html", evalScripts:"true", success:function (data, textStatus) {$("#comments").html(data);}, type:"post", url:"\/comments\/add\_ajax"});
return false;});});
//]]>
```
[](http://farm9.staticflickr.com/8217/8388196515_15bde6c493_b_d.jpg)
**Меняем jQuery на Prototype**
Заменим:
```
//public $helpers = array('Html','Form','Session','Js' => array('Jquery'),'Paginator');
public $helpers = array('Html','Form','Session','Js' => array('Prototype'),'Paginator');
```
получим:
```
//<![CDATA[
document.observe("dom:loaded", function (event) {$("submit-1936204617").observe("click", function (event) {event.stop();
var jsRequest = new Ajax.Updater("comments", "/comments/add\_ajax", {evalScripts:"true", method:"post", parameters:$($("submit-1936204617").form).serialize()});});});
//]]>
```
[](http://farm9.staticflickr.com/8094/8388332351_1b9fef9091_b_d.jpg)
если грамотно проделать работу по подключению библиотеки Prototype:
```
//echo $this->Html->script('jquery-1.8.3.min');
echo $this->Html->script('prototype');
```
, то приложение будет уже работать на движке Prototype.
**Обработчик AJAX кнопки**
Обработчик AJAX кнопки находиться в контроллере app\Controller\CommentsController.php
```
public function add_ajax() {
if ($this->request->is('post')) {
$this->Comment->create();
if ($this->Comment->save($this->request->data)) {
$comments=$this->Comment->find('all',array('conditions'=>array('post_id'=>$this->request->data['Comment']['post_id']),'recursive'=>-1));
$this->set(compact('comments'));
$this->render('add_success','ajax');
} else {
$this->render('add_failure','ajax');
}
}
}
```
его описание выходит из рамки статьи, которую я хотел написать, Вы можете загрузить рассмотренный в этой статье пример [тут](https://github.com/selukov/sample-ajax/archive/master.zip).
**Список используемой литературы:**
Джон Рейсиг «JavaScript Профессиональные приёмы программирования»
Бенкен Е., Самков Г. «AJAX: программирование для Интернета»
Прохоренок Н. «jQuery Новый стиль программирования на JavaScript»
Прохоренок H. «HTML, JavaScript, PHP и MySQL. Джентльменский набор Web-мастера»
Ленгсторф Джейсон «PHP и jQuery для профессионалов»
Мишель Е. Дэвис, Джон А. Филлипс «Изучаем PHP и MySQL»
Дэвид Флэнаган «JavaScript. Подробное руководство, 5-е издание»
Mariano Iglesias «CakePHP 1.3 Application Development Cookbook»
David Golding «Beginning CakePHP From Novice to Professional»
Anupom Syam, Ahsanul Bari «CakePHP Application Development»
Kai Chan and John Omokore with Richard K. Miller «Practical CakePHP Projects» | https://habr.com/ru/post/166653/ | null | ru | null |
# Как сделать самому Луноход
*Если в детстве у тебя не было велосипеда, а теперь у тебя Бентли,
то всё равно в детстве у тебя велосипеда не было.*
Так уж получилось, что в моём детстве не было [Лунохода](https://ru.wikipedia.org/wiki/Big_Trak). А тут ещё и ребёнок родился. В общем, я подумал, и решил сделать игрушку нам обоим.
Создавать точную копию не хотелось, да и не умею я печатать корпуса дома, поэтому решил ограничиться воссозданием похожей функциональности. Кроме того, мне показалось негуманным вводить «программу» движения по памяти и не понимать, что именно получилось ввести, поэтому добавил дисплей.
Версия 1
--------
[](https://habrastorage.org/webt/sm/ay/3l/smay3lbljqcdvzqjzwbu2ttxs_e.jpeg)
Под рукой было недорогое шасси с Ebay и Arduino Uno.
[](https://habrastorage.org/webt/kd/cg/cn/kdcgcnk0xciyvdqa5rdxphli7po.jpeg)
Для управления моторчиками я взял PWM Servo Shield и на макетной плате спаял L293D + PCF8574:
[](https://habrastorage.org/webt/u1/ec/kr/u1eckrq4vkehkdeyl-nudkm-9rc.jpeg)
Для считывания с клавиатуры взял PCF8574 и горсть диодов:
[](https://habrastorage.org/webt/b9/ug/u7/b9ugu7un8he8atkfmhawtrdbqh0.jpeg)
Саму клавиатуру сделал печатной платой:
[](https://habrastorage.org/webt/fs/zc/vb/fszcvbs4vgseapjivkxzc5oupug.jpeg)
Дабы клавиатура не разваливалась в руках, закрепил сверху накладку. Её пришлось заказать у «фрезеровщиков» :)
[](https://habrastorage.org/webt/r_/pu/fs/r_pufsefgkfymv94owyxyxapg5c.jpeg)
Для отображения программы используется обычный дисплей 20 на 4 символа. Да, тоже через PCF8574 ;)
Для питания сначала использовал 4 батарейки, но они слишком быстро садились, и я заменил их на пару аккумуляторов 18650:
[](https://habrastorage.org/webt/bo/hm/mo/bohmmo2cv-vntgmain3xvgen2le.jpeg)
Для зарядки использовал модули TP4056, которые присоединил через реле к аккумуляторам, правда, не очень успешно.
Быстрее всего получилось написать прошивку. К сожалению, оказалось, что библиотека I2C LCD имеет лицензию GPL, и код отправился в корзину. Примерно тогда же я понял, что Arduino Uno не самый удачный вариант, и что горсть PCF8574 очень неудобно паять.
И я решил начать сначала.
Версия 2
--------
[](https://habrastorage.org/webt/mm/u-/2u/mmu-2u1-lknxojkkfdxn7lu-fge.jpeg)
Учёл предыдущий опыт, который подсказывал, что есть несколько проблем:
* Шасси с Ebay сделано из оргстекла и очень (!) хрупкое (я перетянул винт крепления редукторов и крепление просто сломалось).
* На шасси много крепёжных отверстий, но ни одного подходящего.
* Вместе с шасси идут редукторы 1:48, но они слишком шустрые.
* И вообще шасси маловато.
* У Arduino Uno мало «ног».
* Нет звукового модуля (а он нужен для команды «огонь»).
* Про Li-ion в интернете пишут страшилки, давать ребёнку потенциально опасное устройство не хочется.
В результате купил:
* [Редукторы 1:120.](https://www.ebay.com/itm/231130151482)
* [Моторы с двумя валами (в надежде установить потом ПИД-регулятор).](https://www.ebay.com/itm/192389719680)
* [Модуль L293.](https://ru.aliexpress.com/item/Mini-Motor-Drive-Shield-Expansion-Board-L293D-Module-For-for-Ar-UNO-MEGA-2560/1859086104.html)
* [Arduino Mega.](https://www.ebay.com/itm/400994708253)
* [Много цветных шлейфов!](https://www.ebay.com/itm/400932483189)
* [Свинцово-кислотный аккумулятор на 6В (он не так быстро садится, отдаёт больший ток, и он тяжелый — колёса меньше «шлифуют»).](https://www.chipdip.ru/product/dt-6033-134x34x60)
* [УЗ-датчики в качестве датчиков препятствий.](https://www.ebay.com/itm/170897438205)
* [Третье колесо в виде шарика.](http://tixer.ru/catalog/robotics/wheels-bearings/sharikovaya_opora/?sphrase_id=643150)
* [Тактовые кнопки.](https://www.ebay.com/itm/400978790341)
* [Толкатель кнопки.](https://ru.aliexpress.com/item/200Pcs-Tactile-Push-Button-Switch-Cap-micro-Switch-button-Cap-6-Color-Fit-6-6-7/1083007608.html?spm=a2g0s.9042311.0.0.274233edVnkrRY)
* [Щелевой датчик.](https://www.ebay.com/itm/263793936483)
Кроме того:
* [Дисплей LCD 2004 (5В) остался от версии 1.](https://www.ebay.com/itm/401086753914)
* Спаял ЦАП R-2R на монтажной плате ([вот здесь](https://github.com/TheJustMoose/R-2R) есть схема в KiCAD и 3D-модель).
*Achtung! Warning! Attention! Данные ссылки приведены исключительно для иллюстрации и упрощения дальнейшего поиска деталек. Я не могу гарантировать, что продавец внезапно не поменяет лот на какой-то другой, не изменит цену, количество и т.п.*
### Железо
Клавиатуру я перенёс на печатную плату (пожалуй, это единственный сложный для повторения элемент). Накладку на клавиатуру мне отфрезеровали на заказ.
Оставался вопрос: из чего же сделать шасси? Пластика подходящего не было, металл тяжело обрабатывать… А если взять фанеру? «Но это же не эстетично!», подумал было я. Но когда через полчаса я получил нормальное шасси, то изменил мнение. Шасси было не очень презентабельно и отправилось в корзину, но скорость обработки так понравилась, что я решил и дальше использовать фанеру.
Правда, второй лист я начал пилить только после того, как нарисовал примерный план:
[](https://habrastorage.org/webt/p4/d5/z6/p4d5z61sdda9ijwdhdyjos3n_v4.jpeg)
Для крепления моторов отрезал кусок алюминиевого уголка и высверлил:
[](https://habrastorage.org/webt/i0/rj/vd/i0rjvdxhrq_un4hvjwtawvyazuc.jpeg)
Платы закрепил на шестигранных стойках и соединил между собой шлейфами.
[](https://habrastorage.org/webt/sn/0q/px/sn0qpxiwvkuuklleww7kezhxco8.jpeg)
(здесь же можно заметить стабилизатор на 5В и немного контактов питания).
Проводов питания оказалось многовато, поэтому я сделал из stripboard плату питания (подробности [здесь](http://we.easyelectronics.ru/JustMoose/i-esche-raz-pro-stripboard.html)). Подозреваю, что можно взять обычный sensor shield, у которого выводов питания с избытком.
[](https://habrastorage.org/webt/xh/vq/ju/xhvqju2cwgoay0ppstplz9kcvug.jpeg)
Так как расширителей ввода-вывода больше не было, клавиатуру пришлось переделать ([исходники](https://github.com/TheJustMoose/JustCreeper/tree/master/pcb)). Я перенёс на неё диоды и резисторы подтяжки:
[](https://habrastorage.org/webt/gi/nx/8t/ginx8toy9ggmhcyna8xspa_1lcc.jpeg)
[](https://habrastorage.org/webt/by/lk/8-/bylk8-lq4iyyyq1irxipnokyco8.jpeg)
В качестве датчика оборотов использовал щелевую оптопару и шестерню (раскрасил её перманентным маркером):
[](https://habrastorage.org/webt/d_/im/j9/d_imj9ay5dlaac_nm_6bj2m72co.jpeg)
В качестве третьего колеса использовал шарик:
[](https://habrastorage.org/webt/r3/hg/6g/r3hg6goewxmgqs7gcee1lott-ra.jpeg)
Изначально там была опора в виде колёсика на коромысле, которая шла вместе с шасси. Однако при изменении направления движения колёсико начинало разворачиваться в самый неожиданный момент и тележку бросало в сторону.
### Схема соединений
Лучше всего посмотреть файлы consts.h и lcd.ino, они содержат самую актуальную информацию. Соединения, как они есть сейчас, выглядят так:
[](https://habrastorage.org/webt/x1/nv/si/x1nvsi4mf5zawo3aczqnln70bay.png)
*Картинка кликабельна.*
### Прошивка
[Прошивка](https://github.com/TheJustMoose/JustCreeper/), по сути своей, представляет обыкновенную программу, написанную в Arduino IDE. Режимов работы два: редактирование и выполнение. В процессе редактирования с клавиатуры принимается команда + количество повторений. Всё это упаковывается в 16-битное значение и складывается в массив в RAM. При выполнении программы из массива выгребаются значения и выполняются. Выполнение одного шага (в очень упрощённой форме) выглядит так:
````
если (уже работаем)
проверить счётчик пройденного пути
если (счётчик >= требуемая дистанция),
подождать немного
перейти к следующей команде
иначе
инкремент счётчика
иначе
выключить двигатели
взять очередную команду
включить двигатели
требуемая дистанция = константа*число повторений из команды
````
Пройденный путь определяется по количеству импульсов с оптопары, которая проверяется в прерывании таймера.
Единственное исключение — проигрывание звука. Если встречается команда «выстрел», то запускается простейший цикл `for`, который выгребает значения из wav-файла (он прошит в той же flash-памяти, что и программа) и выдаёт их на ЦАП R-2R. Когда значения заканчиваются, происходит возврат к обычному процессу выполнения программы.
К сожалению реальный мир несколько отличается от программной модели, на которую рассчитана прошивка, поэтому я добавил некоторое количество задержек, которые позволяют учесть инерцию шасси.
Я сознательно поставил MIT-лицензию. В моём понимании прошивку с такой лицензией можно свободно использовать как угодно, без необходимости публиковать дальнейшие изменения (не хочу никого ни к чему принуждать).
Руководство по эксплуатации ;)
------------------------------
Клавиатура слегка отличается от «классического» Лунохода:
* Слева расположен блок команд (зелёные — куда ехать, красная — пауза, снизу — Out, огонь, повтор).
* В середине — цифры с количеством повторений.
* Справа 8 клавиш управления (чёрная — удалить последнюю команду, красная — удалить всё, зелёная — запуск, жёлтая — запуск последней команды, синие — тест, серые — запасные).
Ещё раз табличкой:
| | | |
| --- | --- | --- |
| На картинке | Перевод | Смысл |
| Fwd | Ехать вперёд | |
| Bwd | Ехать назад | |
| Left | Повернуть налево | |
| Right | Повернуть направо | |
| Pause | Замереть | |
| Out | Не реализовано, оставлено на будущее | Сделал как в Луноходе |
| Fire | Огонь | Издаёт звук «пиу!» |
| Loop | Цикл | Повторить несколько предыдущих команд **один** раз |
| 0-9 | Число шагов | Максимум 20 |
| Bsp | Удалить последнюю команду | |
| Del | Удалить всю программу | Требуется подтверждение кнопкой Go! |
| T1, T2 | Тест | Запустить тестовую программу |
| Check | Выполнить последний шаг | |
| Go! | Выполнить все шаги | |
Программа вводится поочерёдным нажатием «Команда» и «Цифра». Потом жмём зелёный «Запуск» и смотрим на результат. Удаление происходит по нажатию красной кнопки, но не сразу: надо подтвердить своё решение нажатием зелёной кнопки «Запуск». При выключении питания программа удаляется.
Команда «Повтор» содержит один параметр: сколько шагов нужно повторить [один раз]. Пример: Fwd1, Pause1, Bwd1, Loop3; в результате команды Fwd1, Pause1, Bwd1 будут выполнены два раза. Первый раз потому, что они есть в программе, второй — потому что так указано в команде «Цикл».
На всякий случай контролируется заряд аккумулятора. Если он слишком мал, то выводится предупреждение и игрушка не едет.
GUI
---
Держать в голове всю программу тяжко, поэтому я прикрутил простейший индикатор, на котором дублируется вводимая информация.
После запуска отображается приглашение:
[](https://habrastorage.org/webt/ru/f0/-j/ruf0-j1algyiy0vgo6p15eu_k90.jpeg)
При вводе команды в левом верхнем углу отображается значок команды и количество повторений:
[](https://habrastorage.org/webt/o8/ru/v4/o8ruv4tuxzlu-2pgpbkjifumi1i.jpeg)
Если введено больше одной команды, снизу будет список (по сути, программа), а сверху всё так же будет отображаться вводимая команда:
[](https://habrastorage.org/webt/3i/wb/ve/3iwbve94ihdgrqyqikd8zko-b88.jpeg)
Почему получилось именно так
----------------------------
Игрушка создавалась из того, что было под руками или легко достать. Отдельно хочется сказать про Arduino. Она выбрана по нескольким причинам:
* У неё подходящее количество выводов, а их надо много (43):
+ 6 для управления моторами;
+ 8+4 для клавиатуры;
+ 11 для LCD;
+ 3 для ЦАП;
+ 8 для УЗ-датчиков;
+ 2 для датчиков оборотов;
+ 1 для замера напряжения на аккумуляторе.
* Я знаком с этой платформой.
* Она прошивается в один клик.
* От микроконтроллера не требуется каких-то гигантских скоростей или объёмов памяти.
* И особой экономичности тоже не требуется, т.к. 90 % тока потребляют моторы.
Что можно улучшить
------------------
**Шасси**. При резком старте колёса «шлифуют» и игрушка сбивается с курса. Можно попробовать сделать шестиколёсное шасси, или вообще гусеничное (на Aliexpress есть, но я пока не пробовал).
**GUI**. Сейчас на индикатор выводится только минимальный объём информации, и делается это самым простым способом.
**Код**. Пулитцера я точно не получу.
**Звук**. Есть дешевые и очень мелкие mp3-плееры. Можно смело выкинуть ЦАП R-2R и заменить его на готовый плеер.
**Резервные кнопки**. Можно сделать запись готовой программы в EEPROM, чтобы она не терялась при выключении питания. Реализация может быть как в магнитолах: при длинном нажатии программу сохраняем, при коротком — запускаем.
**Кнопка Out**. На данный момент не реализована. Можно прикрутить что-то типа реле/сервы к одному из выводов Arduino.
### Благодарности
* Ребёнку, который мотивировал меня всё это время.
* Жене, которая терпеливо ждала, пока я наиграюсь, и помогала с Corel Draw!
* Сергею Дудникову, который отрисовал накладку на клавиатуру.
* Андрею Шишкову, который эту самую накладку фрезеровал.
* Антону, который сделал мне отличный mp3 со звуком «пиу!».
* [hudbrog](https://habr.com/ru/users/hudbrog/), за идею реализовать ПИД-регулятор!
* Чатику самодельщиков, которые меня морально поддерживали и вынужденно смотрели на промежуточные итоги работы ;)
Неудачные дубли
---------------
Мне нравятся фильмы с Джеки Чаном, потому что в конце есть нарезка неудачных дублей. У меня без них тоже не обошлось. Больше всего меня удивил тот факт, кто круглое сверло с двумя канавками даёт треугольное отверстие ;)
| | |
| --- | --- |
| | |
| | |
| | |
| | | https://habr.com/ru/post/423409/ | null | ru | null |
# Типобезопасная работа с массивами PHP
Всем привет, расскажу о собственном велосипеде для удобной работы с массивами в PHP.
Type hinting
------------
В PHP7 появились подсказки типов (type hinting), что позволило IDE проводить более качественный статический анализ кода, качество нашего кода улучшилось (или правильно говорит "**стало более лучше**"? ).
Конечно и раньше можно было для IDE написать подсказку в коментах к коду, но теперь типы стали частью кода и теперь их стало возможным рефакторить и не бояться того что ты что то где то забудешь (рефакторить конечно в смысле переименовывать классы и интерфейсы).
Кроме того, что стало возможным указывать выходной тип, появилась возможность указывать тип входного аргумента.
Но кроме приятных возможностей type hinting накладывает и обязанности, то есть типы переменных действительно должны быть такими как указано в сигнатуре метода.
Если не проверять типы, то можно получить ошибки в методах и конструкторах (особенно радуют ошибки в конструкторах).
Писать проверки вручную утомительно, я решил это дело автоматизировать, но не через проверку, а через приведение к нужному типу.
В моей работе достаточно часто приходиться писать с нуля, обычно это или прототипы, или парсеры, или ETL для нового источника данных, по сути тоже парсер.
Работаешь конечно с массивами (например когда читаешь из \*.csv), работать с базой можно через ORM, но для моих задач это слишком громоздко, мне удобно работать с базой через PDO, которое отдаёт тебе данные опять же в массивах. «Любимый» Bitrix не умеет возвращать данные иначе как в массиве.
Как ни крути приходиться извлекать данных из массивов. Поэтому я написал обёртку для работы с массивами.
Что бы не копипастить код из проекта в проект я оформил [пакет для **Composer**](https://packagist.org/packages/sbwerewolf/language-specific):
```
composer require sbwerewolf/language-specific
```
ValueHandler
------------
Первоё моё требование было — всегда знать значение какого типа я получу. Перед этим значение конечно надо бы ещё получить, наверное по индексу, так мы пришли к тому что нам нужен метод **get**().
И теперь нужны методы для приведения типа, типов в PHP не много, получились такие методы:
1. int()
2. str()
3. bool()
4. double()
Иногда попадаются массивы, поэтому пусть будет и для массивов:
* array()
Иногда надо просто получить элемент как он есть:
* asIs()
Иногда элемента с заданным индексом может не быть и тогда надо использовать значение по умолчанию:
* default()
ArrayHandler
------------
Следующим требованием было получить возможность упростить массив из одного значения до ровно этого значения.
Покажу на примере из документации:
```
$connection = new PDO ($dsn,$login,$password);
$command = $connection->prepare('select name from employee where salary > 10000');
$command->execute();
$data = $command->fetchAll(PDO::FETCH_ASSOC);
/*
$data =
array (
0 =>
array (
'name' => 'Mike',
),
1 =>
array (
'name' => 'Tom',
),
2 =>
array (
'name' => 'Jerry',
),
3 =>
array (
'name' => 'Mary',
)
);
*/
$names = new ArrayHandler($data);
$result = $names->simplify();
echo var_export($result,true);
/*
LanguageSpecific\ArrayHandler::__set_state(array(
'_data' =>
array (
0 => 'Mike',
1 => 'Tom',
2 => 'Jerry',
3 => 'Mary',
),
))
*/
```
Можно конечно бежать по массиву, который вернётся из запроса, и делать такое присваивание:
```
$response[] = $element[0];
```
, но мне так не нравится, пусть это происходит автоматически, так появился метод **simplify**().
Ну и раз уж у нас есть обёртка над массивом, то добавим метод для проверки наличия индекса — **has**(), если захочется пробежаться по элементам массива, то поможет метод **next**().
На этом можно было бы и остановиться, потому что уровень автоматизации достиг комфортного уровня, но иногда приходиться работать с вложенным массивом вложенного массива, и мне удобней сразу получить **ArrayHandler** для целевого массива, поэтому я добавил метод **pull**(), который возвращает **ArrayHandler** для вложенного массива.
Выглядит это так:
```
$address = new ArrayHandler($item)->pull('metaDataProperty')->pull('GeocoderMetaData')->pull('Address')->asIs();
```
Можно конечно и так писать:
```
$address = $item['GeoObject']['metaDataProperty']['GeocoderMetaData']['Address'];
```
, но у меня в глазах рябит от количества квадратных скобок, мне удобней через **pull**().
Общие рассуждения
-----------------
Когда код подключается из Композера это очень удобно, кроме того что вы избавляетесь от необходимости копипастить, вы одной командой получаете свою библиотеку и она всегда под рукой.
Перед тем как делать свой пакет я посмотрел аналоги и ни чего подобного не нашёл, есть несколько проектов, которые просто обёртка над array, и в этих проектах просто оборачивают многие методы для работы с массивами, а типобезопасности ни где нет.
Видимо написать (int) или (bool) перед именем переменной всем просто и удобно и ни кто не видит смысла заморачиваться с отдельным репозиторием под это дело.
Возможности библиотеки чуть шире описанных в статье и больше информации можно получить [в документации (README.md)](https://github.com/SbWereWolf/language-specific/blob/master/README.md).
PHP5 ещё не редкость, поэтому у библиотеки есть отдельная версия для PHP5, отличается от версии для PHP7 названием нескольких методов и конечно весь type hinting только в коментах.
Есть версия библиотеки для PHP7.2, отличается только тем что в сигнатуре у метода **object**() появляется тип возвращаемого значения — object.
Код полностью покрыт тестами, но в принципе так и ломать не чему :)
Пользуйтесь на здоровье!
Ещё один пример использования
-----------------------------
```
foreach ($featureMember as $item) {
$pointInfo = extract($item);
$info = new ArrayHandler($pointInfo);
$address = $info->get('formatted')->default('Челябинск')->str();
$longitude = $info->get('longitude')->default(61.402554)->double();
$latitude = $info->get('latitude')->default(55.159897)->double();
$undefined = !$info->get('formatted')->has();
$properties = ['longitude' => $longitude, 'latitude' => $latitude, 'address ' => $address ,'undefined'=>$undefined,];
$result = json_encode($properties);
output($result);
}
```
Смотреть во время отладки на JSON в котором числа это числа, логические значения — логические, мне намного приятней чем только на строки.
А вам как? | https://habr.com/ru/post/476102/ | null | ru | null |
# Встречайте Node.js 14.0.0
Вышла версия [Node.js 14.0.0](https://nodejs.org/en/blog/release/v14.0.0/). Эта версия будет жить долго, до апреля 2023 года, и сейчас в ней еще не появилось всех ожидаемых нами новшеств. Они будут постепенно появляться летом, а 19 октября 14 версия станет LTS.
Что же появилось:
* Обновили v8 до версии 8.1, а это значит, что теперь можно использовать [опциональный чеининг](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining) через `?.` например: `config.server?.port` и оператор `??` [null-объединения](https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_Coalescing_Operator).
* В V8 изменился ArrayBuffer API, что может повлиять на работу нативных адонов, желательно протестировать.
* Улучшилась поддержка [WASI (WebAssembly System Interface)](https://nodejs.org/api/wasi.html), появившегося в 13 версии, но он все еще экспериментальный.
* ECMAScript модули больше не выводят предупреждение (в версии 13 уже не нужно было ключа для ESM, но сообщение про экспериментальный статус было).
* Много рефакторинга в потоках ([Stream](https://nodejs.org/api/stream.html)) касающегося совместимости интерфейсов, оптимизации и стабильности, но тоже стоит протестировать ваш код на совместимость.
* Много интересного можно найти в новом API для отслеживания ресурсов в асинхронном программировании: [`async_hooks`](https://nodejs.org/api/async_hooks.html), с этим имеет смысл начать разбираться, хоть это API еще экспериментальное, например, с версии 13 появился `AsyncLocalStorage`.
* В модуле fs появились новые функции: [`fs.readv`](https://nodejs.org/api/fs.html#fs_fs_readv_fd_buffers_position_callback), [`fs.readvSync`](https://nodejs.org/api/fs.html#fs_fs_readvsync_fd_buffers_position) и изменилась сигнатура [`fs.readSync`](https://nodejs.org/api/fs.html#fs_fs_readsync_fd_buffer_options).
* Еще в версии 13 было много изменений в [`модуле vm`](https://nodejs.org/api/vm.html), с которым публика вообще слабо знакома, советую почитать документацию, это интересный модуль.
Вчера, в день выхода 14 версии я закончил серию вебинаров Node.js 2020: Выйди и зайди нормально, в которой есть обзор всего, что появилось в версиях с 8 до 13 и о чем мало кто знает. Статья обновлена, добавлены ссылки на все три видео и слайды к ним: <https://habr.com/ru/post/497090/> | https://habr.com/ru/post/498408/ | null | ru | null |
# Развертывание Java приложения в OpenShift
Казалось бы что здесь такого? подключаем к проекту fabric8-maven-plugin и вперед: сборка, запуск приложения в OpenShift. Но когда изучал хотелось большего понимания этого процесса, а затем хотелось большего контроля и свободы над процессом сборки и развертывания приложения в OpenShift. Таким образом получился следующий сценарий и с такими особенностями.
* Сборку артефакта произвожу сам, своим инструментом (maven, gradle и др.)
* Контролирую создание Docker Image через Dockerfile
* Build и Deployment процесс в Openshift настраивается в шаблоне, т.е. любые характеристики контейнера, pod настраиваются.
* Таким образом сам процесс можно перенести во внешнюю систему сборки, развертывания
Конечно для этого использую доступные возможности самого OpenShift, которых предостаточно.
И так у меня есть подготовленный java артефакт, далее подготавливаю Dockerfile c нужными мне характеристиками и функциональностью
> Dockerfile
```
FROM openjdk
MAINTAINER Rylkov Alexander
COPY demo.springboot.mvn-0.0.1-SNAPSHOT.jar /deployments/app.jar
ENV JAVA\_OPTS="$JAVA\_OPTS -Xms500m -Xmx1024m"
EXPOSE 8080
EXPOSE 5005
ENTRYPOINT ["sh", "-c", "java $JAVA\_OPTS -jar /deployments/app.jar" ]
```
Таким образом в папке будет два файла: артефакт и Dockerfile
Состав файлов это условно, если например в Dockerfile потребуются еще дополнительные файлы для docker image, то их добавляем сюда. Сейчас собственно в Dockerfile указан базовый образ java и мое приложение Spring boot, открыто два порта и др.
На этом шаге имеем выбор/свободу в средстве сборки приложения и сборки docker image.
Далее подготавливаю OpenShift template для приложения, эта операция может быть разовой, ее надо только параметризовать. Поскольку он может содержать в себе все возможное для создания, запуска и работы приложения, то через него и будем управлять этими процессами. У меня он будет достаточно простой и состоять из трех самых необходимых конфигураций
* ImageStream
* BuildConfig
* DeploymentConfig
**Template java-app-sample**
```
kind: Template
apiVersion: v1
metadata:
labels:
app: java-app-sample
name: java-app-sample
annotations:
description: >-
This example shows how to create a simple Java application in openshift
tags: java
parameters:
- name: APP_NAME
description: application name
value: app-sample
required: true
objects:
- kind: ImageStream
apiVersion: v1
metadata:
name: "${APP_NAME}"
spec:
tags:
- from:
kind: DockerImage
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
name: latest
- kind: BuildConfig
apiVersion: v1
metadata:
name: "${APP_NAME}"
labels:
name: "${APP_NAME}"
spec:
source:
binary: {}
type: Binary
strategy:
type: Docker
output:
to:
kind: DockerImage
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
postCommit: {}
resources: {}
- kind: DeploymentConfig
apiVersion: v1
metadata:
name: "${APP_NAME}"
spec:
strategy:
type: Rolling
rollingParams:
updatePeriodSeconds: 1
intervalSeconds: 1
timeoutSeconds: 120
resources: {}
replicas: 1
selector:
app: "${APP_NAME}"
template:
metadata:
labels:
app: "${APP_NAME}"
spec:
containers:
- name: "${APP_NAME}"
image: 172.30.1.1:5000/myproject/${APP_NAME}:latest
ports:
- containerPort: 8080
protocol: TCP
- containerPort: 5005
protocol: TCP
env:
- name: TZ
value: Europe/Moscow
resources:
limits:
cpu: '0.5'
memory: 1000Mi
requests:
cpu: '0.2'
memory: 500Mi
imagePullPolicy: Always
restartPolicy: Always
dnsPolicy: ClusterFirst
triggers:
- type: ConfigChange
imageChangeParams:
automatic: true
containerNames:
- "${APP_NAME}"
from:
kind: ImageStreamTag
name: 172.30.1.1:5000/myproject/${APP_NAME}:latest
- type: ImageChange
status: {}
```
В шаблоне указаны как пример некоторые параметры контейнера, указаны например ресурсы/лимиты, перемененная окружения TZ, указан один параметр шаблона — имя приложения (APP\_NAME). Адрес docker реестра указан для версии minishift (172.30.1.1:5000/myproject/ ее использую локально для разработки) и др.
Но для моего сценария самое главное указано здесь
```
- kind: BuildConfig
spec:
source:
binary: {}
type: Binary
strategy:
type: Docker
```
В BuildConfig сказано что источником будет являться бинарный файл(ы), а управлять стратегией подготовки docker image — Dockerfile (type: Docker)
Создадим этот шаблон в OpenShift
```
oc create -f template.yaml
```
Этот шаблон появится в каталоге шаблонов (можно будет организовать процесс и из web UI консоли, но не здесь).
По этому шаблону далее создадим приложение (по факту это только имя и не более)
```
oc new-app java-app-sample -p APP_NAME=app-sample
```
укажем имя шаблона и параметр имя приложения
Создались три мои конфигурации.
Запускаем сам процесс сборки и развертывания приложения в контейнере.
```
>oc start-build app-sample --from-dir . --follow
```
Важно выполнять из папки где указан бинарный файл и Dockerfile, как раз параметр --from-dir указывает на это, что будет подготовлена вся папка для загрузки в OpenShift для построения и развертывания image в docker реестре. Есть и другие параметры этой команды, например из архива.
Видим, что содержимое папки было загружено в OpenShift, который запустил процесс Docker для подготовки Image по Dockerfile и в заключении поместил образ в docker registry.
В web консоли OpenShift видно стартовало приложение
Указанные в конфигурации параметры контейнера
Указанная в конфигурации переменная окружения
В логе
Таким образом без дополнительных плагинов, с максимальным контролем и свободой выбора удалось разместить приложение в OpenShift.
Материалы
[Installing Minishift](https://docs.okd.io/3.11/minishift/getting-started/installing.html)
для изучения темы OpenShift я бы посоветовал начать с Minishift | https://habr.com/ru/post/500076/ | null | ru | null |
# Подготовка к захвату мира
Спрашивается, о чём мой проект? А я сам не знаю. Планы меняются. Идей много. Но всегда есть общий базовый функционал. Вот я пока про это. Уже 5 месяцев. После весеннего обострения, в приступе одиночества, хочу поделиться некоторыми наработками.
Первым делом развернул Create React App. Его придётся дорабатывать напильником. Давно уже можно обойти страшную команду eject с помощью react-app-rewired. Грешен, [config-overrides.js](https://github.com/comerc/minsk4/blob/master/config-overrides.js) полностью мой; получилось коряво, хочется переписать на функциональных линзах. Но всё работает: yarn workspaces, babel-плагины, less-loader (для кастомизации Ant-Design), абсолютные пути импорта.
Prettier настроил таким образом, что в проекте один конфиг и для VSCode и для коммитов (в корне лежит .prettierrc). В какой-то момент перестал удовлетворять lint-staged, уже не помню — почему. Ему на замену пришел pretty-quick (как подключить, смотрите в package.json). И очень раздражало, что prettier переформатировал служебные json-файлы. Добавил исключения в .prettierignore для package.json и для tsconfig.json — немного меньше мусора в коммитах.
Пару слов про утилиту nvm. В корне лежит .nvmrc с указанной версией связки node + npm, в моём случае "stable". Достаточно выполнить `$ nvm use`, чтобы переключить окружение. Очень удобно.
Lerna когда-то казалась страшным чудищем. А в результате я использую явно всего лишь одну команду `$ lerna publish`. Пакеты в моём монорепозитории публикуются на npmjs.com с обновлением собственной версии, которую выбираешь в диалоговом режиме. В сочетании с yarn workspaces, есть возможность разложить проект на пакеты и разрабатывать их одновременно (hot-reload работает для всего кода). Практическое воплощение связности и связанности. Нагуглите, если не знаете, что это такое; очень помогает управлять сложностью кода. А ещё прикрутил rollup для сборки пакетов, и он использует общие настройки typescript хост-приложения монорепозитория.
Про Ant-Design. Удивительно, как много менеджеров и разработчиков не понимают преимуществ собирать дом из готовых кирпичей, и бросаются производить свои собственные кирпичи. Разве обязательно переизобретать реализацию модального окна? Научиться кастомизировать и композировать — это повторно применимая практика, это следующий уровень абстракции в наращивании технологической сложности. Только нужно немного поменять подход к дизайну, учитывая накладываемые ограничения. Плясать придётся от печки, вместо привычного "я так вижу". Но выгода мне представляется очевидной и существенной.
Внутри Ant-Design используется less — препроцессор css. Доступно около 700 переменных. Кастомизируй — не хочу. Однако, мой выбор — css-in-js. Тогда надо вытащить требуемые переменные в javascript — внутри less-loader есть опция modifyVars. Чтобы переиспользовать один и тот же theme.js в NodeJS и ES, использовал esm: `const requireForES = require('esm')(module /*, options*/)`. Но многие переменные — производные от других, например `@primary-color: @blue-6`. Помог Proxy для полей объекта theme: `primaryColor: (theme) => theme.blue6`; если поле в theme — это функция, тогда вызвать функцию, и так рекурсивно к следующему полю, пока не дойдём до поля с конечным значением. А ещё есть less-миксины — это js-код упакованный в less; например, скопипастил обратно в javascript функцию colorPalette: `primaryColor5: (theme) => colorPalette(theme.primaryColor, 5)`. Исходики [theme.js](https://github.com/comerc/minsk4/blob/master/src/theme.js).
Ох, съел собаку на styled-components. Но не стоит тратить время на рассказы, потому как близится релиз reshadow (очень хочется верить). Весьма [вдохновляющая презентация](https://www.youtube.com/watch?v=SF0ovSvOcgE&t=6421) на React Russia 2019. В предвкушении праздника — это будет другой уровень удобства разработки. А пока лишь об одном общем моменте, включил в настройках VSCode `"editor.foldingStrategy": "indentation"`, чтобы нормально сворачивать css-код внутри шаблонной строки. Раздражает, что редактор не запоминает свернутое. Надо бы поискать плагин.
Проекты в моих планах разные, но неизменно, что проекты для активных участников. Тогда нужен функционал авторизации. Желательно без паролей. Ответ: Facebook Account Kit. Короткий цифровой код для логина приходит письмом, или SMS (бесплатно), или сообщением в WhatsApp. Написал свой враппер поверх API, пока живёт внутри проекта, как react-компонент. Прекрасно работает. Теперь хочется вынести в npm-пакет, на тот момент я не умел пользоваться lerna + yarn workspaces.
Многие проекты про текстовый контент. Нужен редактор текста. Просто markdown — маловато будет. Да, внутри формата markdown можно добавлять вставки из HTML, но это уже редактор не для массового потребителя, а для хакеров. Выход — блочный редактор. И для блоков необходимо хранить мета-данные. Например, виджет галереи картинок — пару кликов мышкой и всё готово. А ещё хочется переставлять блоки, тоже мышкой. Нравится [koenig-editor](https://forum.ghost.org/t/koenig-editor-beta-release/1284) внутри Ghost и ещё отечественный [EditorJS](https://editorjs.io/). Понятно, что medium.com — прародитель. Но меня не устраивает функционал, чтобы на 100%. И это всё не про React. Может взять DraftJS by Facebook? К сожалению, подзаброшен. Вдохновлённый им SlateJS сравнительно выигрывает в моменте. Но SlateJS — это конструктор из плагинов. Должны быть готовые сборки на его основе. Под спойлером длинный список плюсов-минусов некоторых.
**Скрытый текст****canner-slate-editor**
[+] не показывает Hovering Menu при выделении мышкой заголовка, или текста внутри блока с кодом
[-] при завершении операции drag'n'drop для картинки, наблюдается непрорисованный курсор
[+] плюсик с контекстным меню, когда курсор находится в пустой строке вне блока кода (как в Ghost, но там еще плюсик, когда подвести мышку к концу текста)
[+] плюсик с контекстным меню появляется в конце строки (но если строка декорирована, как "H2", то плюсик уже не появляется — это не бага, а фича)
[+] анимация плюсика с контекстным меню (в Ghost такого нет); и плюсик превращается в крестик, когда меню открыто
[-] в контекстном меню присутствуют кнопки форматирования текста (в Ghost там только виджеты)
[+] применение antd-компонентов для инструментов внутри редактора
[+] богатый функционал для загрузки картинки: drag'n'drop, url, open file
[-] картинки можно загружать только по одной (нет виджета галереи)
[+] есть выравнивания картинок и других блоков
[+] редактирование размера картинки (но проще бы, как в Ghost режимы regular-white-full)
[+] применение форматирования markdown
[-] отсутствует drag'n'drop для cards (в терминологии Ghost)
[+] виджет таблицы, как в старом-добром MS Word
[-] по урл можно вставить только видео (в Ghost это виджет "Other...", который поддерживает много другого — "embedded content")
[-] виджет ссылки не позволяет ее редактировать (в Ghost это можно)
[-] одновременно всплывает Hovering Menu и url-popup ссылки (в Ghost выделение текста скрывает url-popup ссылки)
[-] Hovering Menu залезает за край редактируемой области (в Ghost выравнивается по краю)
**react-page (ory-editor)**
[+] режим изменения композиции блоков через drag'n'drop
[+] режим изменения размеров картинок и других блоков, если их несколько в одном ряду (но только через drag'n'drop)
[+] режим добавления виджетов (но только через drag'n'drop)
[+] режим "preview result" изменяет поведение виджетов (например: картинка становится кликабельной)
[+] в режиме изменения композиции блоков, блок с картинкой можно вставить в блок с текстом через drag'n'drop — чтобы текст обрамлял картинку; плюс есть "защита от дурака": так можно вставить только одну картинку
[-] без мышки функционал сильно ограничен
[-] нет растягивания размеров картинок (как в Ghost режимы regular-white-full)
[-] вообще нет форматирования markdown (в Ghost два режима: в тексте, в отдельном виджете)
[-] не очевидно, как удалить блок картинки (нужно перетащить в корзину через drag'n'drop) — нужно сместить иконку корзины за пределы текста
[-] нет рамки фокуса для виджета картинки в режиме редактирования свойств (хотя для виджета HTML5-видео — есть, вероятно индикацию фокуса задает сам браузер)
[+] панель инструментов редактирования текущего элемента (toolbar для текста, или диалог для картинки etc.) всплывает в подвале и закреплена там
[-] режим добавления виджетов возвращает в исходное состояние выбора виджетов после вставки какого-либо виджета, а хотелось бы перейти к редактированию добавленного виджета; вероятно так и задумано: сначала накидать блоки, а уж потом их редактировать по очереди
[-] url ссылки тупо удаляется при клике по кнопке, а хотелось бы popup с отображением url ссылки и диалог редактирования ссылки (в Ghost тоже нет редактирования, только пустое поле ввода для новой ссылки); понятно, что компромиссы из-за возможной коллизии добавления ссылки в ссылку — надо прорабатывать; в sanity один диалог служит для редактирования ссылки (и ее отображения) и для перехода по этой ссылке
[-] в инструменте редактирования картинки отсутствует drag'n'drop на добавление исходной картинки
[-] нет виджета для кода
[-] не реализован drag'n'drop для загрузки картинки
[-] системный диалог выбора файлов для загрузки картинок не фильтрует допустимые файлы (надо отображать только картинки)
[-] в Ghost, в режиме drag'n'drop, анимировано смещаются другие элементы для полоски-указателя, куда будет выполнен drop
[-] в режиме изменения композиции блоков через drag'n'drop, дублировано отображается паразитная полоска-указатель (видимо из-за лишних div-элементов)
**netlify-cms-widget-markdown**
[+] можно подсмотреть, как поженить slate и remark (remarkSlate.js, slateRemark.js)
[+] встроены плагины slate-edit-list и slate-edit-table
[+] две реализации редактора: RawEditor & VisualEditor
**sanity**
[+] выбор кропа для картинок (см. вложение) — не относится к slate-js
[+] paste markdown (?)
Ладно, придётся мастерить свою, самую-самую лучшую сборку на SlateJS. Тогда и habr.com её себе прикрутит. Одумайтесь, зачем вам VueJS (шутка). Итак, сначала нужна композиция контролов для управления редактором: для добавления новых блоков, для управления выбранным блоком, для изменения настроек блока, для форматирования выделенного текста. Переписывал несколько раз, вроде устоялось, пока нравится. Контролы на базе Ant-Design. Опубликовал npm-пакет slate-controls. Не судите строго — это же любимое дитя.
**Стильные фотки на телефон**
[Исходники будущего проекта](https://github.com/comerc/minsk4). | https://habr.com/ru/post/456020/ | null | ru | null |
# PubSub в браузере с помощью вебсокетов и протокола WAMP
Изучая методы реализации real-time обновления данных в браузере, я обнаружил "[WAMP](http://wamp.ws/)" — протокол прикладного уровня для обмена сообщениями, основанный на вебсокетах.
Протокол реализует два распространенных высокоуровневых шаблона для обмена данными: PubSub и RPC (Remote Procedure Call).
Эти шаблоны многим известны и широко применяются в различных областях программирования и межпроцессного взаимодействия:
* RPC — удаленный вызов процедур. В процессе принимают участие клиент и сервер. Первый отправляет запросы на вызов процедуры на сервере, а второй их выполняет и отправляет результат клиенту. В типичном веб-приложении это может быть, например, запрос на создание комментария или на добавление поста в избранное
* Publish/Subscribe (PubSub) — метод обмена сообщениями, в котором клиенты «подписываются» на интересующие их события и могут сами генерировать подобные события. Рассылкой информации подписчикам занимается третья сторона — «брокер». В WAMP шаблон PubSub реализован на основе «топиков», или каналов. Например, на сайте такими каналами могут быть «комментарии», «новости», «личные сообщения».
В контексте веб-разработки наиболее интересным вариантом применения протокола WAMP является использование шаблона PubSub. С его помощью можно легко решить задачу обновления информации на открытой у пользователя странице сайта: например, чтобы отобразить только что добавленный комментарий или показать уведомление о получении нового сообщения.
Реализация WAMP существует в виде библиотек [под множество языков и платформ](http://wamp.ws/implementations/), включая, конечно, javascript в виде проекта [autobahn](http://autobahn.ws/js/).
В качестве примера использования протокола попробуем разработать абстрактное веб-приложение, в котором браузер будет подписываться на канал с новыми комментариями, а сервер — их рассылать. На сервере будет работать PHP с замечательной библиотекой [Ratchet](http://socketo.me/), которая помимо реализации собственно вебсокетов умеет работать с протоколом WAMP.
Планируя методы взаимодействия клиента и сервера на таком сайте следует помнить, что еще [существуют](http://caniuse.com/#feat=websockets) браузеры, не поддерживающие вебсокеты. И хотя часть проблем с ними могут решить [полифиллы](https://github.com/gimite/web-socket-js), 100% работы в любой среде (например, на андроиде) с их помощью добиться не удастся. Поэтому разумно, на мой взгляд, ограничить использование шаблона PubSub на клиенте лишь подпиской на события. Генерироваться же события будут сервером, получающим «олдскульные» ajax-запросы на создание нового комментария, от имени его автора. Таким образом все клиенты смогут добавлять комментарии (или, в общем случае, генерировать события), а вот получать обновления в реальном времени — только те, кто поддерживает вебсокеты.
##### Клиентская часть сайта.
Библиотека autobahn экспортирует в глобальную область видимости объект **ab**, полный список методов которого можно прочитать в [документации](http://autobahn.ws/js/reference/). Нас же интересует метод **connect**:
```
ab.connect(
//куда подключаемся
'ws://site.com:8080',
//коллбэк будет вызван после успешного подключения.
//внутрь будет передан объект session,
//содержащий информацию о соединении и методы для взаимодействия с сервером
function (session) {
//подпишемся на новые комментарии. вторым параметром передаем функцию-обраточик события,
//которая будет вызвана после получения комментария.
session.subscribe('comments', onNewComment);
},
//коллбэк будет вызван после потери соединения.
//библиотека сама попытается переподключиться, если указаны соответствующие опции,
//поэтому в обработчике события реализовывать эту логику не нужно.
function onClose() {
alert('Пропало соединение с сервером');
},
{
//опции для переподключения к серверу
'maxRetries': 100,
'retryDelay': 5000
}
);
//обработчик новых сообщений на канале comments
function onNewComment(topic, data) {
//topic - название канала, с которого пришло сообщение
//в data находятся данные, переданные сервером.
//в случае с комментариями это могут быть content и author.
console.log('новый комментарий', data.author, data.content);
}
```
Для простоты в качестве названия канала была выбрана строка 'comments', однако согласно спецификации протокола такое именование не является правильным. Каналы должны быть представлены в формате URI, то есть в нашем случае канал может называться `site.com/comments`. В свою очередь, URI каналов можно сокращать до «компактных URI» — CURIE. Более подробно эти детали описаны на странице [спецификации](http://wamp.ws/spec).
Логично, что на реальном сайте пользователю не нужны сразу все новые комментарии, а нужны только те, которые появляются на текущей странице. В таком случае можно создать к примеру такой канал: `site.com/comments/page/1`. Разумеется, никаких ограничений на формирование URI нет: можно динамически создавать каналы с любыми параметрами, в зависимости от поставленных задач.
##### Серверная часть сайта.
В примере с PHP, за доставку сообщений от http-сервера до сервера, отвечающего за рассылку сообщений вебсокетам, отвечает [ZMQ](http://zeromq.org/). При получении нового комментария сервер сохраняет его в базу данных и отправляет сообщение в очередь ZMQ, из которого он в свою очередь будет получен демоном при помощи упомянутой выше библиотеки Ratchet.
Вот как примерно выглядит реализация такой функции:
```
//комментарий от пользователя, полученный через ajax или обычной отправкой формы
$comment=array('author'=>'Ваня', 'content'=>'Привет, хабрахабр!');
//обрабатываем и сохраняем его...
$commentModel->save($comment);
//передаем комментарий для последующей рассылки подписанным пользователям
$loop = React\EventLoop\Factory::create();
$context = new React\ZMQ\Context($loop);
$push = $context->getSocket(\ZMQ::SOCKET_PUSH);
//для передачи сообщений ZMQ используется другой порт, отличный от того, который используют клиенты
$push->connect('tcp://127.0.0.1:8081');
//сообщение передается в виде строки json
$push->send(json_encode($comment));
//tick выполняет первую операцию в очереди.
//операция у нас только одна - отправка сообщения.
$loop->tick();
```
Для обработки подключений клиентов и событий от сервера ZMQ нам понадобится процесс, который будет принимать сообщения и обрабатывать их. В документации к библиотеке Ratchet уже содержатся [подробные примеры](http://socketo.me/docs/push). В частности, нужно обратить внимание на класс Pusher (в нашем примере я назвал его WampProcessor, что кажется более релевантным) — именно он содержит бизнес-логику приложения и отправляет сообщения подписанным на соответствующие каналы клиентам.
Код для запуска такого процесса будет примерно таким:
```
//websocket-сервер из библиотеки React
$loop = React\EventLoop\Factory::create();
//processor - пользовательский обработчик подключений по WAMP, который должны написать мы сами.
//он должен реализовывать интерфейс WampServerInterface.
//в нашем примере помимо обработки клиентских подключений
//этот класс будет также принимать сообщения от нашего http-сервера.
$processor = new WampProcessor();
//будем слушать сообщения от http-сервера через ZMQ на порту 8081...
$context = new React\ZMQ\Context($loop);
$pull = $context->getSocket(ZMQ::SOCKET_PULL);
$pull->bind('tcp://127.0.0.1:8081');
//при получении собщений они будут переданы в метод 'onComment' объекта 'processor'
$pull->on('message', array($processor, 'onComment'));
//будем принимать подключения от клиентов - браузеров на порт 8080 с любого IP
$app = new \components\SocketServer\App('site.com', 8080, '0.0.0.0', $loop);
//при желании одним демоном можно обслуживать несколько приложений или сайтов сразу,
//для этого запросы можно маршрутизировать (Ratchet использует роутер из Symfony).
//в нашем примере будет один сайт, поэтому маршрутизация не понадобится.
//в качестве "контроллера" будет выступать наш класс WampProcessor.
$app->route('/', $processor, array('*'));
//...
$app->run();
```
Все методы класса WampProcessor будут практически идентичны тем, что можно увидеть в документации Ratchet; из них стоит выделить только обработчик события — метод "**onComment**":
```
/**
* @param string строка в JSON, полученная от ZeroMQ
*/
public function onComment($json) {
$comment = json_decode($json, true);
//ничего не делаем, если нет ни одного подписчика на новые комментарии
if (!array_key_exists('comments', $this->subscribedTopics)) {
return;
}
$topic = $this->subscribedTopics['comments'];
//иначе отправляем комментарий всем подписанным клиентам.
$topic->broadcast($comment);
}
```
Таким образом при создании нового комментария все подключенные браузеры будут получать объект с полями author и content, который и ожидает получить javascript-обработчик.
За процессом обмена сообщениями можно наблюдать в консоли chrome (фильтр «websocket» во вкладке «network») или другого браузера. Видно, что при подключении к серверу браузер отправляет приветственное сообщение, а потом — список каналов для подписки.
##### Заключение.
Вот так, применив технологию WebSockets и протокол WAMP, можно реализовать обновление информации на веб-странице в реальном времени методом PubSub.
Можно возразить, что используя nodejs и библиотеку socket.io сделать это было бы проще, но в нашей реальности, где PHP является доминирующей серверной платформой, описанный вариант вполне жизнеспособен и даже более удобен чем другие, более «костыльные» методы (как, например, периодический опрос сервера с помощью ajax). Также его относительно легко можно внедрить на существующий сайт: изменения потребуется внести только в те части, где происходит генерация каких-либо событий, а сам демон-обработчик от сайта может быть совершенно независим.
Ключевые ссылки:
* [Wamp](http://wamp.ws/) — websocket application messaging protocol.
* [Authobahn](http://autobahn.ws/) — реализация WAMP на javascript.
* [Ratchet](http://socketo.me/) — реализация вебсокетов и WAMP на PHP. | https://habr.com/ru/post/201658/ | null | ru | null |
# Как избавиться от размытых фотографий с помощью Python
*Когда мы делаем большую серию снимков, часть из них получается нечеткими. С такой же проблемой столкнулась крупная автомобильная компания. Часть фотографий при осмотре авто получались размытой, что могло негативно влиять на продажи.
Некачественные снимки напрямую снижают прибыль.*
* Как приложению распознавать нечеткие фотографии на уровне алгоритма?
* Как измерить четкость RGB-изображения?
### Постановка задачи
Работаю аналитиком в крупной автомобильной компании. Инспекторы компании при осмотре автомобиля делают через специальное приложение много фотографии, которые сразу отправляются в базу данных. Некоторые снимки получаются нечеткими, что плохо сказывается на продажах.
Отсюда возникает задача: «как на уровне алгоритма распознавать нечеткие снимки?»
Разрабатывал алгоритм на основе выборки в 1200 фотографий разных элементов автомобилей. Особенностью выборки является то, что она не размечена, т.к. трудно точно определить какие снимки четкие, какие нет.
Получается, обучение ML-модели «с учителем» к решению не применимо.
В ходе работы использовал инструменты:
* **Python**. Библиотеки: numpy, matplotlib, cv2;
* **Jupyter** notebook.
В статье опишу решение задачи, к которому пришел.
### Описание подхода к решению задачи
#### Этап 1. Определение границ
*Какая фотография может называться четкой?*
Та, у которой границы объектов ярко выражены. У нечетких снимков границы объектов размыты.
*Как определить границы объектов на снимке?*
Границы там, где видим наибольший перепад цвета.
Получается, для определения четкости снимка вначале нужно определить границы объектов фотографий, потом оценить их величину, толщину, количество и т.д.
Фотография состоит из трехмерного массива чисел от 0 до 255: (ширина, высота, 3 цвета).
Границы определил наложением фильтра как в создании глубокой нейросети: перемножением трехмерного массива на матрицы (по каждому цвету):
```
│ 1 -1 │
│ 1 -1 │
```
При перепаде цвета результирующий массив будет выдавать высокое по модулю число.
Так определим вертикальные и горизонтальные границы. Среднеарифметическое значений показывает общие границы фотографии.
#### Этап 2. Анализ границ на предмет четкости
Границы определили.
*Как отличить границу нечеткого изображения от границы четкого?*
Перебирая разные варианты, нашел следующий подход:
1. определяем границы оригинальной фотографии (описано в этапе 1);
2. размываем оригинальное изображение;
3. определяем границы размытого снимка (описано в этапе 1);
4. считаем отношение средних арифметических пункта 1 и пункта 2;
5. полученный коэффициент характеризует четкость снимка.
Логика проста: у четких фотографий изменение границ будет происходить существеннее, чем у нечетких, а значит, коэффициент будет выше.
### Реализация алгоритма в Python
Непосредственно для решения задачи используем следующие библиотеки:
```
import numpy as np
import matplotlib.pyplot as plt
import cv2
```
Для параметров определения границ зададим функцию определения матрицы:
```
def edges(n, orient):
edges = np.ones((2*n, 2*n, 3))
if orient == 'vert':
for i in range(0, 2*n):
edges[i][n: 2*n] *= -1
elif orient == 'horiz':
edges[n: 2*n] *= -1
return edges
```
Под параметром n задаем количество пикселей, которые включаем в оценку границ. Ориентация матрицы может быть горизонтальной или вертикальной.
Дальнейшие функции аналогичны слою глубокой нейросети:
```
# Apply one filter defined by parameters W and single slice
def conv_single_step(a_slice_prev, W):
s = W * a_slice_prev
Z = np.sum(s)
Z = np.abs(Z)
return Z
# Full edge filter
def conv_forward(A_prev, W, hparameters):
m = len(A_prev)
(f, f, n_C) = W.shape
stride = hparameters['stride']
pad = hparameters['pad']
Z = list()
flag = 0
z_max = hparameters['z_max']
if len(z_max) == 0:
z_max = list()
flag = 1
for i in range(m):
(x0, x1, x2) = A_prev[i].shape
A_prev_pad = A_prev[i][
int(x0 / 4) : int(x0 * 3 / 4),
int(x1 / 4) : int(x1 * 3 / 4),
:]
(n_H_prev, n_W_prev, n_C_prev) = A_prev_pad.shape
n_H = int((n_H_prev - f + 2*pad) / stride) + 1
n_W = int((n_W_prev - f + 2*pad) / stride) + 1
z = np.zeros((n_H, n_W))
a_prev_pad = A_prev_pad
for h in range(n_H):
vert_start = h * stride
vert_end = h * stride + f
for w in range(n_W):
horiz_start = w * stride
horiz_end = w * stride + f
a_slice_prev = a_prev_pad[vert_start: vert_end, horiz_start: horiz_end, :]
weights = W[:, :, :]
z[h, w] = conv_single_step(a_slice_prev, weights)
if flag == 1:
z_max.append(np.max(z))
Z.append(z / z_max[i])
cache = (A_prev, W, hparameters)
return Z, z_max, cache
# pooling
def pool_forward(A_prev, hparameters, mode = 'max'):
m = len(A_prev)
f = hparameters['f']
stride = hparameters['stride']
A = list()
for i in range(m):
(n_H_prev, n_W_prev) = A_prev[i].shape
n_H = int(1 + (n_H_prev - f) / stride)
n_W = int(1 + (n_W_prev - f) / stride)
a = np.zeros((n_H, n_W))
for h in range(n_H):
vert_start = h * stride
vert_end = h * stride + f
for w in range(n_W):
horiz_start = w * stride
horiz_end = w * stride + f
a_prev_slice = A_prev[i][vert_start: vert_end, horiz_start: horiz_end]
if mode == 'max':
a[h, w] = np.max(a_prev_slice)
elif mode == 'avg':
a[h, w] = np.mean(a_prev_slice)
A.append(a)
cache = (A_prev, hparameters)
return A, cache
```
conv\_single\_step — одно перемножение цветов картинки на матрицы, выявляющую границу.
conv\_forward — полное определение границ на всей фотографии.
pool\_forward — уменьшаем размер полученного массива.
Отдельно отмечу значение строчек в функции conv\_forward:
```
(x0, x1, x2) = A_prev[i].shape
A_prev_pad = A_prev[i][
int(x0 / 4) : int(x0 * 3 / 4),
int(x1 / 4) : int(x1 * 3 / 4),
:]
```
Для анализа используем не всё изображение, а только его центральную часть, т.к. фокус фотоаппарата чаще наводится на центр. Если снимок четкий, то и центр будет четкий.
Следующая функция определяет границы объектов на снимке, используя предыдущие функции:
```
# main layer
def borders(images, filter_size = 1, stride = 1, pool_stride = 2, pool_size = 2, z_max = []):
Wv = edges(filter_size, 'vert')
hparameters = {'pad': pad, 'stride': stride, 'pool_stride': pool_stride, 'f': pool_size, 'z_max': z_max}
Z, z_max_v, _ = conv_forward(images, Wv, hparameters)
print('edge filter applied')
hparameters_pool = {'stride': pool_stride, 'f': pool_size}
Av, _ = pool_forward(Z, hparameters_pool, mode = 'max')
print('vertical filter applied')
Wh = edges(filter_size, 'horiz')
hparameters = {'pad': pad, 'stride': stride, 'pool_stride': pool_stride, 'f': pool_size, 'z_max': z_max}
Z, z_max_h, _ = conv_forward(images, Wh, hparameters)
print('edge filter applied')
hparameters_pool = {'stride': pool_stride, 'f': pool_size}
Ah, _ = pool_forward(Z, hparameters_pool, mode = 'max')
print('horizontal filter applied')
return [(Av[i] + Ah[i]) / 2 for i in range(len(Av))], list(map(np.max, zip(z_max_v, z_max_h)))
```
Функция определяет вертикальные границы, затем горизонтальные, и возвращает среднее арифметическое обоих массивов.
И основная функция для выдачи параметра четкости:
```
# calculate borders of original and blurred images
def orig_blur(images, filter_size = 1, stride = 3, pool_stride = 2, pool_size = 2, blur = 57):
z_max = []
img, z_max = borders(images,
filter_size = filter_size,
stride = stride,
pool_stride = pool_stride,
pool_size = pool_size
)
print('original image borders is calculated')
blurred_img = [cv2.GaussianBlur(x, (blur, blur), 0) for x in images]
print('images blurred')
blurred, z_max = borders(blurred_img,
filter_size = filter_size,
stride = stride,
pool_stride = pool_stride,
pool_size = pool_size,
z_max = z_max
)
print('blurred image borders is calculated')
return [np.mean(orig) / np.mean(blurred) for (orig, blurred) in zip(img, blurred)], img, blurred
```
Вначале определяем границы оригинального изображения, затем размываем снимок, потом определяем границы размытой фотографии, и, наконец, считаем отношение средних арифметических границ оригинального изображения и размытого.
Функция возвращает список коэффициентов четкости, массив границ оригинального снимка и массив границ размытого.
### Пример работы алгоритма
Для анализа взял снимки с фотостока freepik.com.
Определяем границы первого снимка до и после размытия:
Второго:
Третьего:
Четвертого:
На изображениях видно, что изменение границ у четких снимков (3й и 4й) происходит сильнее, чем у нечетких (1й и 2й).
После расчетов получаем коэффициенты:
[5.92918651681958,
2.672756123184502,
10.695051017699232,
11.901115749698139]
Коэффициенты подтверждают выводы: чем больше коэффициент, тем четче фото.
Причем, второй снимок менее четких, чем первый, что и отражается на коэффициентах.
### Особенности подхода
* чем снимок четче, тем сильнее изменяется граница, а значит, тем выше будет параметр;
* для разных нужд необходима разная четкость. Поэтому необходимо определять границы четкости самостоятельно: где-то коэффициент достаточной четких фотографий будет выше 7, где-то только выше 10;
* коэффициент зависит от яркости фотографии. Границы темных фотографий будут изменяться слабее, а значит, и коэффициент будет меньше. Получается, границы четкости нужно определять с учетом освещения, то есть для типовых фотографий;
Работающий алгоритм можно найти на моем аккаунте в [github](http://github.com/dmitry-data-science/clarity). | https://habr.com/ru/post/496134/ | null | ru | null |
# Как убрать из Git-репозитория файлы с конфиденциальной информацией
Файлы проиндексированы, написано сообщение коммита, данные отправлены на сервер… И вдруг хочется повернуть время вспять. В коммит попал файл, которого там быть не должно. Когда такое случается, приходит время обращаться к поисковику.
Каждый разработчик когда-то по ошибке коммитил в общедоступный репозиторий файлы с конфиденциальной информацией. Как справиться с такой проблемой? Как сделать так, чтобы ничего подобного больше не случилось бы?
В этой статье я расскажу о том, что делать в том случае, если в репозиторий случайно попал файл, которому там совершенно нечего делать. Здесь же я приведу команды Git, которые позволят подправить историю, и поделюсь некоторыми рекомендациями по организации безопасной работы с конфиденциальной информацией.
[](https://habr.com/ru/company/ruvds/blog/519138/)
*Удаление файлов с конфиденциальной информацией из Git-репозитория (*[*изображение большого размера*](https://www.freecodecamp.org/news/content/images/2020/08/illustration.png)*)*
Минимизация ущерба
------------------
Итак, вы случайно закоммитили файл с конфиденциальной информацией. Назовём этот файл `.env`. Сразу после того, как это случилось, надо задать себе пару вопросов:
* Отправлен ли коммит в удалённый репозиторий?
* Является ли удалённый репозиторий общедоступным?
### ▍Коммит пока не отправлен в удалённый репозиторий
Если вы пока не отправили коммит в репозиторий, то, в общем-то, возникшая ситуация никакой угрозы не несёт. Для того чтобы всё исправить, достаточно просто вернуться к предыдущему коммиту:
```
git reset HEAD^ --soft
```
Файлы останутся в рабочей копии репозитория, вы сможете внести в проект необходимые изменения.
Если же вы хотите сохранить коммит и вам нужно просто удалить из него определённые файлы, тогда поступите так:
```
git rm .env --cached
git commit --amend
```
Параметр `--amend` можно использовать только для работы с самым свежим коммитом. Если вы, после неудачного коммита, добавили ещё несколько, воспользуйтесь такой командой:
```
git rebase -i HEAD~{на сколько коммитов нужно вернуться?}
```
Это позволит исправить неправильный коммит и поможет не потерять изменения, внесённые в проект остальными коммитами.
### ▍Коммит отправлен в удалённый репозиторий
Если вы уже отправили коммит в удалённый репозиторий, то, в первую очередь, вам нужно знать о том, чем отличаются публичные и приватные репозитории.
Если ваш репозиторий является приватным, и при этом он не доступен ботам или людям, которым вы не доверяете, вы можете просто внести поправки в последний коммит, воспользовавшись парой вышеприведённых команд.
Если вы отправили в репозиторий, после проблемного коммита, и другие коммиты, это не помешает вам убрать файлы с конфиденциальными данными из истории Git, воспользовавшись командой [git filter-branch](https://git-scm.com/docs/git-filter-branch) или инструментом [BFG Repo-Cleaner](https://rtyley.github.io/bfg-repo-cleaner/).
Вот пример использования `git filter-branch`:
```
git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty --tag-name-filter cat -- --all
```
Но, делая это, учитывайте два важных аспекта подобных изменений, вносимых в репозиторий:
* Вы меняете историю Git. Если на текущее состояние репозитория полагаются другие люди, если от этого состояния зависят какие-то ветки того же репозитория, его форки, открытые PR, то это нарушит их работу. В подобных случаях относитесь к репозиторию как к общедоступному и постарайтесь не вносить изменения в его историю.
* Вам нужно будет очистить кеш. Вам понадобится обратиться в службу поддержки платформы, на которой хранится ваш репозиторий, и попросить очистить его кеш. Несмотря на то, что вы исправили проблемный коммит или переписали историю репозитория, старый коммит, содержащий конфиденциальные данные, останется в кеше. Для того чтобы к нему обратиться, нужно будет знать его ID, но к нему можно будет получить доступ до тех пор, пока кеш не очистят.
Нужно ли создавать новые секретные ключи в том случае, если их актуальные версии попали в публичный репозиторий?
----------------------------------------------------------------------------------------------------------------
Если кратко ответить на вопрос, вынесенный в заголовок, то — нужно. Если ваш репозиторий общедоступен, или если вы, по любой причине, полагаете, что он — не место для хранения секретных данных, вам необходимо будет счесть попавшие в него конфиденциальные данные скомпрометированными.
Даже если вы удалили эти данные из репозитория, вы ничего не сможете сделать с ботами и с форками репозитория. Как же поступить?
* Деактивируйте все ключи или пароли. Это надо сделать в первую очередь. После того, как вы деактивируете ключи, конфиденциальные сведения, ушедшие в общий доступ, оказываются бесполезными.
* Настройте файл `.gitignore`. Сделайте в `.gitignore` записи о файлах с конфиденциальной информацией для того чтобы Git не отслеживал бы состояние этих файлов.
* Подготовьте коммит, в котором нет файлов с конфиденциальной информацией.
* Отправьте изменения в репозиторий, снабдите коммит пояснениями о возникшей ситуации. Не пытайтесь скрыть ошибку. Все программисты, работающие над проектом, включая вас, по достоинству оценят наличие в репозитории коммита с разъяснениями ситуации и с описанием того, что именно было исправлено с помощью данного коммита.
Рекомендации по хранению конфиденциальных файлов в проектах, в которых для контроля версий применяется Git
----------------------------------------------------------------------------------------------------------
Для того чтобы не допустить утечек конфиденциальной информации стоит придерживаться следующих рекомендаций.
### ▍Храните секретные данные в файле .env (или в другом подобном файле)
Ключи к API и другие подобные сведения стоит хранить в единственном файле `.env`. При таком подходе, если Git не отслеживает состояние файла `.env`, вы, добавив в этот файл новый ключ, не отправите его случайно в репозиторий.
Ещё одно преимущество такого подхода заключается в том, что так у вас будет доступ ко всем ключам через глобальную переменную `process`.
### ▍Используйте, если это возможно, ключи API
Скомпрометированные ключи API легко деактивировать, такие ключи легко создать заново. Если это возможно — используйте именно их, а не нечто вроде логинов и паролей.
### ▍Храните ключи API, пользуясь средствами вашего инструмента для сборки проектов
Ключи API обычно нужны при сборке приложений. Инструменты для сборки проектов, вроде Netlify, позволяют держать ключи в защищённых хранилищах. Такие ключи автоматически внедряются в приложение с использованием глобальной переменной `process`.
*Управление переменными окружения*
### ▍Добавьте запись о файле .env в файл .gitignore
Сделайте так, чтобы Git не отслеживал бы файлы, содержащие конфиденциальную информацию.
### ▍Подготовьте шаблонный файл .env.template
Наличие подобного шаблонного файла помогает тем, кто работает над проектом, добавлять в проект ключи API, избавляя их от необходимости чтения документации.
### ▍Не меняйте историю Git в удалённых репозиториях
Постарайтесь строго придерживаться этого правила. Если вы следовали вышеприведённым рекомендациям, то историю Git вам менять и не потребуется.
Итоги
-----
Надеюсь, мой материал поможет вам в безопасной работе с конфиденциальными данными.
**А вам случалось отправлять в общедоступный репозиторий что-то такое, что туда попадать не должно?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=how-to-uncommit-sensitive-files-from-git)
[](https://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=perevod&utm_campaign=how-to-uncommit-sensitive-files-from-git) | https://habr.com/ru/post/519138/ | null | ru | null |
# Web интерфейс прослушивания записей звонков Asterisk
Поисковые системы выдают огромное количество результатов разной полезности на запрос вынесенный в заголовок.
На Хабрахабре такой статьи не нашел, а значит её нужно написать!
За основу [я](http://thecall.ru) взял проект [asterisk cdr viewer](https://code.google.com/p/asterisk-cdr-viewer/).
Перевел язык web интерфейса на великий могучий и «озвучил» его, т.е. добавил возможность прослушивать файлы записей разговоров в браузере, а так же скачивать их.
Количество полей фильтра сокращено до минимума, остались только самые необходимые.
Скриншоты, сорцы и подробное описание инсталляции уютно разместились под хабракатом.
**UPDATE\_2016**
Готов новый интерфейс.
Небольшой видео-гайд:
Подробнее [здесь](https://habrahabr.ru/post/322278/)
##### Скриншоты web интерфейса
Логотип и ссылка на донат разработчикам остались на своих местах.
Поля переведены все, если потребуется вывести какое-либо поле как в оригинале, просто раскомментируйте его в templates/form.tpl.php
А так выглядит результат поиска по фильтру.
Каждый разговор можно скачать, либо прослушать через flash плеер.
##### Готовим MySQL
CDR нашего Asterisk должны писаться в MySQL базу, о том как это настроить можно прочесть [здесь](http://blog.thecall.ru/page/asterisk-18-cdr-v-mysql-cdr_adaptive_odbc) например ;).
В конец файла cdr\_mysql.conf, в секцию [columns] добавим
```
alias realdst => realdst
alias filename => filename
```
Имя файла записи разговора пишется в поле file таблицы CDR.
Добавим его:
```
mysql -uroot -p -e "alter table `cdr` add column `filename` varchar(120) after `userfield`;" asterisk
```
##### Диалплан
Для настройки диалплана Asterisk я пользуюсь extensions.ael.
**extensions.ael**
```
globals {
WAV=/records/wav; //Временный каталог с WAV
MP3=/records/mp3; //Куда выгружать mp3 файлы
RECORDING=1; // Запись, 1 - включена.
};
macro recording (calling,called) {
if ("${RECORDING}" = "1"){
Set(fname=${UNIQUEID}-${STRFTIME(${EPOCH},,%Y-%m-%d-%H_%M)}-${calling}-${called});
Set(monopt=nice -n 19 /usr/bin/lame -b 32 --silent "${WAV}/${fname}.wav" "${MP3}/${fname}.mp3" && rm -f "${WAV}/${fname}.wav" && chmod o+r "${MP3}/${fname}.mp3");
Set(CDR(filename)=${fname}.mp3);
Set(CDR(realdst)=${called});
MixMonitor(${WAV}/${fname}.wav,b,${monopt});
};
};
_XXXXXX => {
&recording(${CALLERID(number)},${EXTEN});
Dial(SIP/rtk/${EXTEN});
Hangup();
}
```
Глобальные переменные определяют пути к файлам, а так же позволяют включить/выключить запись разговора.
Макрос recording принимает в качестве параметров номер звонящего и номер куда происходит вызов. Если запись включена, то пишется временный wav файл, перекодируется в mp3, а в MySQL табличку CDR падает имя файла.
Имя файла состоит из uniqueid-дата\_время-ОтКогоВызов-КомуВызов, например:
```
1392597899.17572-2014-02-17-07_44-83843ZZZХХХ-32ХХZZ.mp3
```
mp3 файлы за текущий день складываются в /records/mp3/
Каждую ночь скрипт в кроне распределяет записи разговоров в соответствующие дате папки
```
1 0 * * * /root/sh/mvrecords.sh
```
```
#!/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
y=`date +%Y -d "-1 day"`
ym=`date +%Y-%m -d "-1 day"`
ymd=`date +%Y-%m-%d -d "-1 day"`
mkdir -p /records/$y/$ym/$ymd/
mv /records/mp3/*$ymd* /records/mp3/$y/$ym/$ymd/
```
В папке, где размещены файлы web интерфейса, необходимо создать симлинк на папку /records/mp3/
```
/var/www# ls -l
total 60
-rw-r--r-- 1 fessae fessae 182 Nov 19 2011 callrates.csv
drwxr-xr-x 3 fessae fessae 4096 Sep 26 2012 contrib
-rw-r--r-- 1 fessae fessae 1986 Dec 22 2012 download.php
-rw-r--r-- 1 fessae fessae 246 Sep 6 2013 downloads.php
drwxr-xr-x 4 fessae fessae 4096 Apr 15 20:48 include
-rw-r--r-- 1 fessae fessae 30384 Dec 2 20:21 index.php
lrwxrwxrwx 1 root root 13 Apr 15 20:48 records -> /records/mp3/
drwxr-xr-x 2 fessae fessae 4096 Feb 13 2013 style
drwxr-xr-x 3 fessae fessae 4096 Feb 18 21:07 templates
```
Скриншоты структуры папок.
##### PHP
В файле include/functions.php прописана логика вывода кнопочки «скачать файл с разговором» и flash плеера в поле «Файл».
**часть include/functions.php**
```
$recorded_file = $row['filename'];
$mycalldate = substr("$calldate",0,10);
$mycalldate_ym = substr("$calldate",0,7);
$mydate = date("Y-m-d");
if ($mycalldate<$mydate){
if (file_exists("records/$mycalldate_ym/$mycalldate/$recorded_file")) {
echo " |\n";
}
else {echo " запись отсутствует |\n"; }
}
else {
if (file_exists("records/$recorded_file")) {
echo " |\n";
}
else {echo " запись отсутствует |\n";}
}
}
```
В этом коде определяется в какой папке нужно искать файл записи разговора.
За текущий день ищем в /records/mp3, а за предыдущие в /records/mp3/ГОД-МЕСЯЦ/ГОД-МЕСЯЦ-ДЕНЬ/
Если файл найден не был, то мы увидим «запись отсутствует» в поле «Файл».
Так же не забываем указать реквизиты подключения к MySQL в `include/config.inc.php`
##### Занавес
На этом все!
Буду рад если мой труд окажется полезен.
ps
Сорцы доступны по ссылкам [1](http://sysadminz.ru/index.php?action=dlattach;topic=6592.0;attach=7589) и [2](https://drive.google.com/file/d/0B4tx5FFqCxYeTFktc2pHQ0ctWDg/edit?usp=sharing)
**UPD**
Если нет аккаунта на Хабре, могу помочь на форуме — [sysadminz.ru/index.php?topic=6592.0](http://sysadminz.ru/index.php?topic=6592.0)
**UPD 2**
Обнаружился небольшой глюк, если запись по каким-либо направлениям отключена(т.е. не пишется файл и не заполняется поле filename в базе), то флеш плеер все равно отображается, как-будто файл есть.
Для исправления нужно внести изменения в таблицу CDR, для поля filename выставить значение по умолчанию:
```
mysql -p
mysql> alter table cdr alter filename set default 'none';
mysql> describe cdr;
+-------------+-----------------+------+-----+---------------------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-----------------+------+-----+---------------------+----------------+
| id | int(9) unsigned | NO | PRI | NULL | auto_increment |
| calldate | datetime | NO | MUL | 0000-00-00 00:00:00 | |
| clid | varchar(80) | NO | | | |
| src | varchar(80) | NO | MUL | | |
| dst | varchar(80) | NO | MUL | | |
| dcontext | varchar(80) | NO | | | |
| channel | varchar(80) | NO | | | |
| dstchannel | varchar(80) | NO | | | |
| lastapp | varchar(80) | NO | | | |
| lastdata | varchar(80) | NO | | | |
| duration | int(11) | NO | | 0 | |
| billsec | int(11) | NO | | 0 | |
| disposition | varchar(45) | NO | | | |
| amaflags | int(11) | NO | | 0 | |
| accountcode | varchar(20) | NO | MUL | | |
| uniqueid | varchar(32) | NO | MUL | | |
| userfield | varchar(255) | NO | | | |
| filename | varchar(120) | YES | | none | |
+-------------+-----------------+------+-----+---------------------+----------------+
18 rows in set (0.00 sec)
mysql> \q
Bye
```
**UPD 3(из шапки поста)**
Камрад **profiton (aka prog-it)** существенно допилил тему.
Скрины:
 | https://habr.com/ru/post/212815/ | null | ru | null |
# Крах на финишной прямой, или как написать нетестируемый код
Это история о том, как потерпеть фиаско, имея хорошо написанный и протестированный в боевых условиях работающий код и даже написанную документацию. Изначально я собирался делать анонс своей библиотеки, но что-то пошло не так. Поэтому начнём за здравие -- постановка и формализация задачи, описание возможностей и батареек. А закончим за упокой -- вопросами, как всё это теперь тестировать?
Логотип systempyНеудавшийся анонс. SystemPY, в девичестве lifecycle
---------------------------------------------------
Начну с формализации проблемы. Современное `asyncio` приложение состоит из множества компонентов типа Redis, БД, брокера и прочих. Эти компоненты необходимо инициализовать и останавливать в правильном порядке. Также очень хочется из коробки работающий `reload`. Вишенкой же на торте будет точно так же инициализорованный REPL, а также простота написания одноразовых скриптов для разрешения косяков на проде. Читать статью я рекомендую, глядя одним глазом в [документацию](https://systempy.readthedocs.io/en/latest/). Согласитесь, нет смысла её просто переводить, вместо этого её стоит расширить
### Ещё раз и внимательно
Когда точка входа одна, добавление компонентов происходит постепенно и незаметно. Когда появляется вторая точка входа, будь то ещё один микросервис, REPL или скрипт -- вам приходится решать задачу запуска заново. Это особенно смешно в случае скрипта и остро напоминает проблему банана и гориллы -- вы хотели всего лишь банан, но для этого вам пришлось написать код для инициализации гориллы и всех джунглей, а после ещё для остановки
Я с ходу настаиваю на добавлении REPL -- ещё одной точки входа
Анализ проблемы и подхода
-------------------------
Я предлагаю смотреть на приложение как на конструктор компонентов. Идея в том, что каждый компонент может требовать для своего запуска и остановки исполнения некоторого кода. Этот *некоторый код* хорошо изолируется в собственные классы-миксины. Итоговое приложение является комбинацией этих миксинов. Создание новой точки входа сводится к импорту написанных ранее компонентов наследованию от них нового класса
### Этапы жизненного цикла приложения
Я выделил 6 основных этапов жизненного цикла приложения:
* `on_init` -- код исполняется единожды только в момент инициализации;
* `pre_startup` -- код исполняется до запуска event loop в том числе во время reload;
* `on_startup` -- код исполняется сразу после инициализации event loop;
* `on_shutdown` -- код исполняется, когда приложение приняло решение остановиться, но event loop ещё работает;
* `post_shutdown` -- код исполняется сразу после остановки / очистки event loop. В случае reload следующим этапом будет `pre_startup`;
* `on_exit` -- код исполняется единожды только в момент остановки приложения.
### Сценарии работы приложения
Я выделил 3 основных сценария:
* Ведомое приложение, запускаемое каким-то фреймворком;
* "Сам себе хозяин" -- демоны, скрипты и REPL;
* Ведущее приложение или фреймворк, запускающий клиентское приложение.
### Кастомные этапы жизненного цикла
Есть необходимость выполнить код прямо перед или прямо после какого-то существующего этапа жизненного цикла? Легко
что они там на самом деле все кастомные. Только тссДопустим, есть необходимость дважды вклиниться прямо перед `on_startup`. Для этого необходимо создать интерфейс:
```
@util.register_target
class MyCustomTarget(Target):
@util.register_hook_before(Target.on_startup)
@util.register_target_method("forward")
async def before_on_startup(self) -> None: ...
@util.register_hook_before(before_on_startup)
@util.register_target_method("gather")
async def before_2_on_startup(self) -> None: ...
```
После от этого интерфейса наследоваться. В результате методы будут выполнены в следующем порядке: `before_2_on_startup` -> `before_on_startup` -> `on_startup`
Естественно, вклинивать этапы можно пока не надоест
Хороший пример кастомных этапов жизненного цикла рассмотрен в [документации](https://systempy.readthedocs.io/en/latest/examples/self-hosted/daemon/)
### Боль, ненависть, REPL
Казалось бы, что может пойти не так, когда батарейки в комплекте? Пройдёмся по болевым точкам и откроем стандартный `asyncio` REPL:
```
python3 -m asyncio
asyncio REPL 3.9.2 (default, Feb 28 2021, 17:03:44)
[GCC 10.2.1 20210110] on linux
Use "await" directly instead of "asyncio.run()".
Type "help", "copyright", "credits" or "license" for more information.
>>> import asyncio
>>>
```
Номинально работает, но:
* меня бесит некорректная обработка `Ctrl+C`
* А что с автодополнениями по `Tab`? Почему не работают?
* Окей, как теперь инициализировать окружение? Правильно, ручками
### Так вот, требования к REPL
Ничего сверхестественного:
* Корректная обработка `Ctrl+C`
* Автодополнения должны работать, если есть `readline`
* Окружение должно инициализироваться компонентно и так же останавливаться
* Добавление собственных глобальных переменных (импортированных модулей) в неймспейс
Всё это тоже работает. Больше примеров в [документации](https://systempy.readthedocs.io/en/latest/examples/self-hosted/repl/). В процессе пришлось через `ctypes` лезть в недра `readline` и заниматься знаменитым брутфорс-программированием. Питонячий `readline` -- это стыдоба
Ну и как я умудрился зайти в тупик?
-----------------------------------
Согласитесь, тестировать своим продом не совсем правильно. Вопрос необходимо формализовать. С учётом возможностей, простейшая с виду задача превращается в рак мозга. Есть непроверенный функционал -- метод `reload`, вызов которого должен запустить процесс остановки и последующего перезапуска. Очевидно, он должен вести себя одинаково во всех сценариях, а все нюансы -- половые трудности уже `systempy`. А различий есть у меня! В REPL вместо штатного `reload` необходимо выполнять `reload_threadsafe` -- и это совсем не одно и то же. У меня ломается мозг, как проверить работу метода reload в других сценариях работы
В то же время есть казалось бы простые моменты, которые протестировать и можно. Например, регистрируется ли Target, и даже в каким порядке выполняются методы, где `systempy` кидает исключения, и так далее. Смех в том, что там отсутствуют оси изменений
А ещё очень неприятно ломается REPL, и в случае ошибок забирает за собой и терминал -- спасает только закрытие и открытие нового
Если ли у хабра идеи? Или воспользоваться запасным сценарием?
Запасной сценарий для тестовМожно и без тестов | https://habr.com/ru/post/684286/ | null | ru | null |
# Релиз Go 1.7
Сегодня, 16 августа 2016, вышел восьмой стабильный релиз языка программирования Go — [Go 1.7](https://golang.org/dl/). Как обычно, релиз выпущен по намеченному плану, через пол года после предыдущего, и в нём нет обратно несовместимых изменений. В тоже время, в Go 1.7 довольно много новых и важных изменений, уменьшены время компиляции и размеры бинарников, увеличена скорость работы и в стандартную библиотеку наконец-то добавлен пакет context. Под катом более подробный обзор новшеств и нововведений.
Новый SSA бекенд
================
Пожалуй, одним из важнейших изменений в этом релизе является использования нового бекенда компилятора, поддерживающего [SSA](https://en.m.wikipedia.org/wiki/Static_single_assignment_form)-форму (Static Single-Assigment). Переход на SSA-бекенд даёт новые возможности для оптимизации и генерации более эффективного кода, и это уже можно наблюдать в данном релизе.
Чтобы сравнить результат компиляции старого и нового бекенда, достаточно передать параметр команде go build:
```
go build -gcflags="-ssa=0"
```
и для нового (SSA включён по-умолчанию в Go 1.7).
```
go build
```
Переход на новый бекенд уже сейчас даёт прирост в скорости программ от 5 до 35%.
Также можно покопаться в коде, генерируемом бекендом, с помощью переменной GOSSAFUNC:
```
GOSSAFUNC=main go build && open ssa.html
```
Новый формат метаданных
=======================
Хотя это изменение абсолютно невидимо для простых пользователей, его стоит упомянуть. В Go 1.7 используется новый формат экспорта метаданных в бинарных файлах, более компактный и эффективный, чем предыдущий. Он исправляет некоторые залежавшиеся баги и генерирует бинарные файлы меньшего размера. Его можно отключить параметром -newexport=0
```
go build -newexport=0
```
Поддержка MacOS X 10.12 'Sierra'
================================
Хотя мы привычно ожидаем, что бинарники собранные с прыдыдущими версиями Go будут работать во всех будущих версиях различных OS — в случае с ещё не вышедшей MacOS X 10.12 это не так. В этом релизе MacOS была изменена реализация системного вызова gettimeofday(), а в Go, фактически используется копия её реализации, поэтому при её изменении в ядре, пришлось изменить код и в Go. Как это можно отразиться на практике — бинарники под MacOS X собранные с Go < 1.6.3 не будут корректно работать на MacOS X 10.12 'Sierra'. Если вы распространяете в бинарниках, убедитесь, что собираете их с Go 1.6.3 или 1.7, чтобы они корректно работали на MacOS X 10.12.
Оптимизация и ускорение компилятора и линкера
=============================================
Помимо вышеупомянутых пунктов, оптимизации подверглось много компонентов стандартной библиотеки, компилятора и линкера, в результате чего бинарники должны быть меньше в размере на 20-30%, а код должен работать гораздо быстрее (особенно на x86-64 платформах), чем Go 1.6. При этом, благодаря новому бэкенду, остается еще много пространства для запланированных оптимизаций на следующие релизы.
Также в некоторых пакетах стандартной библиотеки оптимизации добавили более чем 10% ускорение — crypto/sha1, crypto/sha256, encoding/binary, fmt, hash/adler32, hash/crc32, hash/crc64, image/color, math/big, strconv, strings, unicode и unicode/utf16.
Также в программах с большим количеством запущенных горутин паузы сборщика мусора должны намного меньше.
Context
=======
Одним из самых ожидаемых добавлений в стандартную библиотеку был перенос пакета golang.org/x/net/context в [context](https://golang.org/pkg/context/). Из имени было убрано слово "net" потому что, хотя context и используется чаще всего в коде, работающим с запросами из сети, но его функционал не ограничен только работой с сетью. К примеру, он может использоваться для os/exec и других вещей.
Почему это важно? В Go появилось немало http-фреймворков и пакетов, задача которых была обеспечить передачу контекста внутри обработчиков входящих запросов. net/context постепенно начал занимать эту нишу, но теперь, с context в стандартной библиотеке и с нативной его поддержкой в пакетах net, net/http и os/exec, писать код, работающий с контекстами запроса будет гораздо проще и унифицированней.
В пакете [net](https://golang.org/pkg/net) появился новый метод типа [Dialer](https://golang.org/pkg/net/#Dialer):
```
func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error)
```
Если таймаут контекста истекает раньше, чем произошло установление соединения, DialContext возвращает ошибку.
В [net/http](https://golang.org/pkg/net/http/) в типе [Request](https://golang.org/pkg/net/http/#Request) появились методы [Context()](https://golang.org/pkg/net/http/#Request.Context) и [WithContext()](https://golang.org/pkg/net/http/#Request.WithContext):
```
func (r *Request) Context() context.Context
```
```
func (r *Request) WithContext(ctx context.Context) *Request
```
Метод Context() используется для получение контекста запроса, для его изменения используйте WithContext(). В исходящих запросах context теперь управляет отменой запроса.
Vendoring
=========
В этом релизе переменная GO15VENDOREXPERIMENT больше не поддерживается, теперь вендоринг это стандартный функционал тулинга Go.
Testing
=======
В пакете testing, который используется для написания тестов, появилась поддержка вложенных иерархических тестов и бенчмарков. Это бывает очень удобно для BDD-тестирования, табличных тестов и для более компактной организации тестов в целом. Пример кода:
```
func TestTeardownParallel(t *testing.T) {
// This Run will not return until the parallel tests finish.
t.Run("group", func(t *testing.T) {
t.Run("Test1", parallelTest1)
t.Run("Test2", parallelTest2)
t.Run("Test3", parallelTest3)
})
//
}
```
Детали доступны в документации к пакету: <https://golang.org/pkg/testing/#hdr-Subtests_and_Sub_benchmarks>
Разное
======
* go tool trace теперь не требует бинарник для анализа трейса, и оверхед на трейсинг уменьшился с 400% до 20%
* в стандартную библиотеку включён простой zipkin-аналог инструмент httptrace — [net/http/httptrace/](https://golang.org/pkg/net/http/httptrace/)
* os/user.Current больше не требует cgo (таким образом, осталось 3 места, где cgo всё ещё используется в стандартной библиотеке)
Полный список изменений доступен тут: <https://golang.org/doc/go1.7>
Стоит ли мне обновляться?
=========================
Обычно никаких рисков с обновлением на новый релиз нет, и в Go коммьюнити свежая версия используется большинством. Но есть смысл первые пару недель подождать, потестировать билды на 1.7 в тестовом режиме. В последних двух релизах были минорные релизы (1.5.1 и 1.6.1) с исправлениями очень специфических багов, найденных в первые недели после основного релиза.
Ссылки
======
<https://golang.org/doc/go1.7>
<https://golang.org/dl/>
PS. В этом релизе приняли участие 170 человек, из которых 140 — не из Google, а из Go сообщества. | https://habr.com/ru/post/307864/ | null | ru | null |
# Поиск пакетов Go на PowerShell
Всем привет! Одним из моих любимых языков является Go, в результате чего я задумался о написании чего-то вроде Package Manager… Ну или хотя бы поисковика пакетов. Есть идея, пора бы сесть за разработку. Конечно же в первую очередь я подумал о Go как о инструменте для решения проблемы. Но, немного поразмыслив, решил дать шанс манящему меня PowerShell, за изучение которого я садился уже раза 3, но что-то меня постоянно останавливало (скорее всего лень и отсутствие проектов, которые можно было бы на нем реализовать). Что же, сказано – сделано. Данная статья рассчитана на людей, не знакомых с PowerShell, но имеющих опыт в программировании. Если вам стало интересно, то добро пожаловать под кат.
Для начала было бы неплохо узнать, что такое PS. Википедия говорит следующее:
**Wikipedia**Windows PowerShell — расширяемое средство автоматизации от Microsoft с открытым исходным кодом, состоящее из оболочки с интерфейсом командной строки и сопутствующего языка сценариев.
Теперь можно приступать к делу. Первая проблема, с которой столкнутся новички – это запрет на исполнение сторонних скриптов. Ребята из Microsoft пекутся о нашей с Вами безопасности, но мы же понимаем, что делаем ;). Так давайте исправим эту досадную заботу. Откройте окно PowerShell, которое выглядит примерно так:
И выполните следующую команду:
```
Set-ExecutionPolicy RemoteSigned
```
Система спросит у вас, осознаете ли Вы то, что делаете, отвечаем утвердительное Y.
Вообще основой PowerShell являются командлеты. Они имеют следующий синтаксис:
<Глагол>-<Существительное>
Это довольно удобно, так как вводит понимание того, что должно произойти. Помимо командлетов имеются так же Alias’ы для большинства стандартных команд, причет не только CMD, но и Bash. Например, Вы хотите очистить экран. Стандартный командлет для этого Clear-Host, но также можно воспользоваться алиасами для него: cls и clear. Со списком алиасов можно ознакомиться командой Get-Alias.
И так, мы произвели базовую настройку PowerShell и пришло время для написания скриптов. Расширением скриптов PowerShell является “\*.ps1”. Создадим файл для разработки наших командлетов командой:
```
New-Item -Path 'C:\work\goPS.ps1' -Type File -Force
```
Если с параметром -Path все понятно, то с остальными придется разобраться. -Type указывает тип создаваемого файла, так как нам нужен файл, мы явно указываем это. -Force же создает пути, если они не существуют.
Вопросом: откуда брать список модулей для Go? Ответ: нам в этом поможет ресурс [Go-Search](http://go-search.org/), который предоставляет очень удобное, а главное бесплатное API. Спасибо им за это.
Можно переходить в любимый редактор кода, но лично я могу посоветовать Вам использовать PowerShell ISE, любезно предустановленный в систему. Нужно создать каркас нашего модуля:
```
function Find-GoPackage {
}
```
Это наш будущий командлет. PS вещь не простая, в отличии от Bash и CMD оперирует объектами, а не строками, что очень удобно при работе с конвейером. Каркас есть, теперь займемся параметрами. Переменные в PS задаются аналогично PHP с помощью $my\_var. При этом они могут быть как нетипизированные, так и типизированные.
```
# Нетипизированная
$no_type
# Типизированная, строка
[string]$have_type
```
Объявим блок аргументов:
```
[CmdletBinding()]
Param (
[string]$Name = ""
)
```
Как видно, задать аргументы проще простого, да и еще значение по умолчанию есть.
Сама логика работы следующая. В первую очередь нам необходимо произвести запрос на сервер. Сделать это можно несколькими способами, но, как по мне, самый простой это использовать Invoke-WebRequest, который вернет нам объект с содержимым ответа.
Введем переменную:
```
$uri = "http://go-search.org/api?action=search&q=" + $Name
```
PowerShell поддерживает работу с конвейером. Ответ от сервера приходит в виде json, но спасибо добрым людям, которые уже подумали о нас. В PS есть стандартные сериализаторы и десериализаторы объектов. ConvertFrom-Json принимает в себя строку Json и возвращает “сырой” объект с полями нашего json. Хватит слов, больше кода, а кода будет мало.
```
$hits = $($(Invoke-WebRequest -Uri $uri).Content | ConvertFrom-Json).hits
```
Мы передаем нашу ссылку в инвокер, берем из него содержимое ответа из поля .Content и передаем по конвейеру (конвейер это “|”) в ConvertFrom-JSON. Нас же, в свою очередь, интересует поле .hits, которое содержит список найденных модулей. Всего одна строчка выполнила всю работу за нас!
Осталось только вернуть наш список, ну это уже совсем просто:
```
return $hits
```
Привожу полный листинг:
```
function Find-GoPackage {
[CmdletBinding()]
Param (
[string]$Name = ""
)
$uri = "http://go-search.org/api?action=search&q=" + $Name
$hits = $($(Invoke-WebRequest -Uri $uri).Content | ConvertFrom-Json).hits
return $hits
}
```
Теперь снова перейдем в PowerShell и импортируем наш модуль в сеанс:
```
PS C:\ >. “C:\work\goPS.ps1”
```
PowerShell проанализировал наш скрипт и готов к работе.
Выполните, например, команду “Find-GoPackage -Name json” и получите список найденных модулей для работы с json, ну а для красоты можно еще и форматирование добавить:
```
Find-GoPackage json | Format-Table -Wrap -AutoSize
```
Имеем на выходе аккуратную табличку.
Правда импортировать каждый раз модуль не удобно, поэтому можно сделать одну интересную вещь: в PS есть система профилей. Профиль – это файл, который исполняется каждый раз, когда вы открываете терминал.
Введите в PS следующее:
```
Test-Path $PROFILE
```
$PROFILE это переменная среды, содержащая путь до вашего файла профиля. Если команда выше вернула $false, значит ваш профиль не настроен. В таком случае выполните следующую команду:
```
New-Item -Path $PROFILE -Type File -Force
```
Откройте этот файл:
```
notepad $PROFILE
```
И скопируйте наш вышенаписанный код в файл, сохраните, перезапустите PowerShell и проверьте, что все работает.
На этом все, спасибо за внимание! | https://habr.com/ru/post/334720/ | null | ru | null |
# Добавляем свои подсказки к коду в Adobe Dreamweaver CS5
Всем доброе время суток.
Я давно пользуюсь *Adobe Dreamweaver CS5* в разработке своих скриптов, сайтов, порталов…
И вот в один прекрасный день я задался вопросом, а как добавить свои подсказки в Dreamweaver?
Начал как всегда с Googla, и не нашел там не чего подходящего и тогда решил разбираться самостоятельно ~~Метод научного тыка~~.
##### Что мне хотелось получить?
В Dreamweaver если ввести такую строчку **$cl = new** то появится набор классов заложенных в него программистами и после объявления класса введя **$cl->** появятся методы этого класса.
Я же хочу просто добавить туда свои методы и классы.
##### Если долго мучится что нибудь получится
После долгих поисков я нашел папку по адресу **C:\Program Files\Adobe\Adobe Dreamweaver CS5\configuration\CodeHints\BuiltinCode\**, в этой папки есть несколько файлов, но нам нужен **PHP\_CORE.php**.
Файлу нужно выставить права для редактирования.
Просмотрев его содержимое мне стало все предельно понятно, не буду показывать все содержимое этого файла покажу только часть.
```
//@php_CORE2.xml#PDO
class PDO {
// Constants
const PARAM_BOOL=5;
const PARAM_NULL=0;
const PARAM_INT=1;
const PARAM_STR=2;
const PARAM_LOB=3;
const PARAM_STMT=4;
const PARAM_INPUT_OUTPUT=-2147483648;
const PARAM_EVT_ALLOC=0;
const PARAM_EVT_FREE=1;
const PARAM_EVT_EXEC_PRE=2;
const PARAM_EVT_EXEC_POST=3;
const PARAM_EVT_FETCH_PRE=4;
const PARAM_EVT_FETCH_POST=5;
const PARAM_EVT_NORMALIZE=6;
const FETCH_LAZY=1;
const FETCH_ASSOC=2;
const FETCH_NUM=3;
const FETCH_BOTH=4;
const FETCH_OBJ=5;
const FETCH_BOUND=6;
const FETCH_COLUMN=7;
const FETCH_CLASS=8;
const FETCH_INTO=9;
const FETCH_FUNC=10;
const FETCH_GROUP=65536;
const FETCH_UNIQUE=196608;
const FETCH_KEY_PAIR=12;
const FETCH_CLASSTYPE=262144;
const FETCH_SERIALIZE=524288;
const FETCH_PROPS_LATE=1048576;
const FETCH_NAMED=11;
const ATTR_AUTOCOMMIT=0;
const ATTR_PREFETCH=1;
const ATTR_TIMEOUT=2;
const ATTR_ERRMODE=3;
const ATTR_SERVER_VERSION=4;
const ATTR_CLIENT_VERSION=5;
const ATTR_SERVER_INFO=6;
const ATTR_CONNECTION_STATUS=7;
const ATTR_CASE=8;
const ATTR_CURSOR_NAME=9;
const ATTR_CURSOR=10;
const ATTR_ORACLE_NULLS=11;
const ATTR_PERSISTENT=12;
const ATTR_STATEMENT_CLASS=13;
const ATTR_FETCH_TABLE_NAMES=14;
const ATTR_FETCH_CATALOG_NAMES=15;
const ATTR_DRIVER_NAME=16;
const ATTR_STRINGIFY_FETCHES=17;
const ATTR_MAX_COLUMN_LEN=18;
const ATTR_EMULATE_PREPARES=20;
const ATTR_DEFAULT_FETCH_MODE=19;
const ERRMODE_SILENT=0;
const ERRMODE_WARNING=1;
const ERRMODE_EXCEPTION=2;
const CASE_NATURAL=0;
const CASE_LOWER=2;
const CASE_UPPER=1;
const NULL_NATURAL=0;
const NULL_EMPTY_STRING=1;
const NULL_TO_STRING=2;
const ERR_NONE=00000;
const FETCH_ORI_NEXT=0;
const FETCH_ORI_PRIOR=1;
const FETCH_ORI_FIRST=2;
const FETCH_ORI_LAST=3;
const FETCH_ORI_ABS=4;
const FETCH_ORI_REL=5;
const CURSOR_FWDONLY=0;
const CURSOR_SCROLL=1;
const MYSQL_ATTR_USE_BUFFERED_QUERY=1000;
const MYSQL_ATTR_LOCAL_INFILE=1001;
const MYSQL_ATTR_INIT_COMMAND=1002;
const MYSQL_ATTR_READ_DEFAULT_FILE=1003;
const MYSQL_ATTR_READ_DEFAULT_GROUP=1004;
const MYSQL_ATTR_MAX_BUFFER_SIZE=1005;
const MYSQL_ATTR_DIRECT_QUERY=1006;
const PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT=1000;
// Properties
// Methods
//@php_CORE2.xml#PDO::__construct
public function __construct( $dsn , $username , $passwd , array $options ){ }
//@php_CORE2.xml#PDO::prepare
public function prepare( $statment , array $options ){ return new PDOStatement();}
//@php_CORE2.xml#PDO::beginTransaction
public function beginTransaction(){ }
//@php_CORE2.xml#PDO::commit
public function commit(){ }
//@php_CORE2.xml#PDO::rollBack
public function rollBack(){ }
//@php_CORE2.xml#PDO::setAttribute
public function setAttribute( $attribute , $value ){ }
//@php_CORE2.xml#PDO::exec
public function exec( $query ){ }
//@php_CORE2.xml#PDO::query
public function query(){ return new PDOStatement();}
//@php_CORE2.xml#PDO::lastInsertId
public function lastInsertId( $seqname ){ }
//@php_CORE2.xml#PDO::errorCode
public function errorCode(){ }
//@php_CORE2.xml#PDO::errorInfo
public function errorInfo(){ return array();}
//@php_CORE2.xml#PDO::getAttribute
public function getAttribute( $attribute ){ }
//@php_CORE2.xml#PDO::quote
public function quote( $string , $paramtype ){ }
//@php_CORE2.xml#PDO::getAvailableDrivers
public static function getAvailableDrivers(){ return array();}
}
```
Кому не понятно объясняю:
1. Объявляем класс
2. Вписываем в тело класса нужные поля, методы, константы...
Вот небольшой пример:
```
class InformationSystem{
public function ShowAddComment( string $xslname, array $param = array (
'confirm_comment' => false,
'status' => 0,
'comment_mail_type' => 1
) ) { }
public function ShowInformationSystem( mixed $InformationSystemIdArray, int $information_groups_id, string $xsl_name, int $items_on_page, int $items_begin, array $external_propertys = array(), array $property = array() ) { }
public function ShowInformationSystemItem( int $information_item_id, string $xsl_name, array $external_propertys = array(), array $property = array() ) { }
public function ShowInformationSystemPageConfig( int $InformationSystem_id, int $items_on_page, array $property = array()) { }
public function ShowInformationSystemPageContent( int $InformationSystem_id, string $xsl_list, string $xsl_item, array $property = array(), array $external_propertys = array(), array $infsys_property = array() ) { }
public function ShowInformationSystemRss( int $InformationSystem_id, mixed $information_groups_id, int $items_on_page = 10, int $items_begin = 0, array $property = array() ) { }
public function ShowTagsCloud( int $InformationSystemId, str $xsl_name, array $property = array(), array $external_propertys = array() ) { }
public function UserCanAddComment( string $date, $ip, array $param = array(), string $comment_ip ) { }
public function _CallbackSearch( array $row ) { }
}
```
##### Что получилось в итоге?
##### Итог
Теперь работать с СМС мне стало гораздо проще, так как нету нужды периодически заглядывать в **api**. | https://habr.com/ru/post/128023/ | null | ru | null |
# Руководство и шпаргалка по Wireshark
Даже поверхностное знание программы [Wireshark](https://wireshark.org/) и её фильтров на порядок сэкономит время при устранении проблем сетевого или прикладного уровня. Wireshark полезен для многих задач в работе сетевого инженера, специалиста по безопасности или системного администратора. Вот несколько примеров использования:
#### Устранение неполадок сетевого подключения
* Визуальное отображение потери пакетов
* Анализ ретрансляции TCP
* График по пакетам с большой задержкой ответа
#### Исследование сессий прикладного уровня (даже при шифровании с помощью SSL/TLS, см. ниже)
* Полный просмотр HTTP-сессий, включая все заголовки и данные для запросов и ответов
* Просмотр сеансов Telnet, просмотр паролей, введённых команд и ответов
* Просмотр трафика SMTP и POP3, чтение писем
#### Устранение неполадок DHCP с данными на уровне пакетов
* Изучение трансляций широковещательного DHCP
* Второй шаг обмена DHCP (DHCP Offer) с адресом и параметрами
* Клиентский запрос по предложенному адресу
* Ack от сервера, подтверждающего запрос
#### Извлечение файлов из сессий HTTP
* Экспорт объектов из HTTP, таких как JavaScript, изображения или даже исполняемые файлы
#### Извлечение файлов из сессий SMB
* Аналогично опции экспорта HTTP, но извлечение файлов, передаваемых по SMB, протоколу общего доступа к файлам в Windows
#### Обнаружение и проверка вредоносных программ
* Обнаружение аномального поведения, которое может указывать на вредоносное ПО
* Поиск необычных доменов или конечных IP
* Графики ввода-вывода для обнаружения постоянных соединений (маячков) с управляющими серверами
* Отфильтровка «нормальных» данных и выявление необычных
* Извлечение больших DNS-ответов и прочих аномалий, которые могут указывать на вредоносное ПО
#### Проверка сканирования портов и других типов сканирования на уязвимости
* Понимание, какой сетевой трафик поступает от сканеров
* Анализ процедур по проверке уязвимостей, чтобы различать ложноположительные и ложноотрицательные срабатывания
Эти примеры — только вершина айсберга. В руководстве мы расскажем, как использовать столь мощный инструмент.
Установка Wireshark
===================
Wireshark работает на различных операционных системах и его несложно установить. Упомянем только Ubuntu Linux, Centos и Windows.
### Установка на Ubuntu или Debian
```
#apt-get update
#apt-get install wireshark tshark
```
### Установка на Fedora или CentOS
```
#yum install wireshark-gnome
```
### Установка на Windows
На [странице загрузки](https://www.wireshark.org/download.html) лежит исполняемый файл для установки. Довольно просто ставится и драйвер захвата пакетов, с помощью которого сетевая карта переходит в «неразборчивый» режим (promiscuous mode позволяет принимать все пакеты независимо от того, кому они адресованы).
Начало работы с фильтрами
=========================
С первым перехватом вы увидите в интерфейсе Wireshark стандартный шаблон и подробности о пакете.
Как только захватили сессию HTTP, остановите запись и поиграйте с основными фильтрами и настройками **Analyze | Follow | HTTP Stream**.
Названия фильтров говорят сами за себя. Просто вводите соответствующие выражения в строку фильтра (или в командную строку, если используете tshark). Основное преимущество фильтров — в удалении шума (трафик, который нам не интерестен). Можно фильтровать трафик по MAC-адресу, IP-адресу, подсети или протоколу. Самый простой фильтр — ввести `http`, так что будет отображаться только **трафик HTTP (порт tcp 80)**.
### Примеры фильтров по IP-адресам
```
ip.addr == 192.168.0.5
!(ip.addr == 192.168.0.0/24)
```
### Примеры фильтров по протоколу
```
tcp
udp
tcp.port == 80 || udp.port == 80
http
not arp and not (udp.port == 53)
```
Попробуйте сделать комбинацию фильтров, которая показывает весь исходящий трафик, кроме HTTP и HTTPS, который направляется за пределы **локальной сети**. Это хороший способ обнаружить программное обеспечение (даже вредоносное), которое взаимодействует с интернетом по необычным протоколам.
Следуйте за потоком
===================
Как только вы захватили несколько HTTP-пакетов, можно применить на одном из них пункт меню **Analyze | Follow | HTTP Stream**. Он покажет целиком сессию HTTP. В этом новом окне вы увидите HTTP-запрос от браузера и HTTP-ответ от сервера.
Резолвинг DNS в Wireshark
=========================
По умолчанию Wireshark не резолвит сетевые адреса в консоли. Это можно изменить в настройках.
**Edit | Preferences | Name Resolution | Enable Network Name Resolution**
Как и в случае `tcpdump`, процедура резолвинга замедлит отображение пакетов. Также важно понимать, что при оперативном захвате пакетов DNS-запросы с вашего хоста станут дополнительным трафиком, который могут перехватить.
Tshark для командной строки
===========================
Если вы ещё не баловались с `tshark`, взгляните на наше [руководство с примерами фильтров](https://hackertarget.com/tshark-tutorial-and-filter-examples/). Эту программу часто игнорируют, хотя она отлично подходит для захвата сессий на удалённой системе. В отличие от `tcpdump`, она позволяет на лету захватывать и просматривать сессии прикладного уровня: декодеры протоколов Wireshark также доступны для tshark.
Составление правил для файрвола
===============================
Вот быстрый способ создания правил из командной строки, чтобы не искать в интернете конкретный синтаксис. Выберите подходящее правило — и перейдите в **Tools | Firewall ACL Rules**. Поддерживаются различные файрволы, такие как Cisco IOS, `ipfilter`, `ipfw`, `iptables`, `pf` и даже файрвол Windows через `netsh`.
Работа с географической базой GeoIP
===================================
Если Wireshark скомпилирован с поддержкой GeoIP и у вас есть бесплатные базы Maxmind, то программа может определять местоположение компьютеров по их IP-адресам. Проверьте в **About | Wireshark**, что программа скомпилирована с той версией, какая у вас в наличии. Если GeoIP присутствует в списке, то проверьте наличие на диске баз GeoLite City, Country и ASNum. Укажите расположение баз в меню **Edit | Preferences | Name Resolution**.
Проверьте систему на дампе трафика, выбрав опцию **Statistics | Endpoints | IPv4**. В колонках справа должна появиться информация о местоположении и ASN для IP-адреса.
Другая функция GeoIP — фильтрация трафика по местоположению с помощью фильтра `ip.geoip`. Например, так можно исключить трафик из конкретной ASN. Нижеуказанная команда исключает пакеты от сетевого блока ASN 63949 (Linode).
```
ip and not ip.geoip.asnum == 63949
```
Конечно, тот же фильтр можно применить [к отдельным городам и странам](https://www.wireshark.org/docs/dfref/i/ip.html). Удалите шум и оставьте только действительно интересный трафик.
Расшифровка сессий SSL/TLS
==========================
Один из способов расшифровки сессий SSL/TLS — использовать закрытый ключ с сервера, к которому подключен клиент.
Конечно, у вас не всегда есть доступ к приватному ключу. Но есть другой вариант простого просмотра трафика SSL/TLS на локальной системе. Если Firefox или Chrome загружаются с помощью специальной переменной среды, то симметричные ключи отдельных сеансов SSL/TLS записаны в файл, который Wireshark может прочитать. С помощью этих ключей Wireshark покажет полностью расшифрованную сессию!
### 1. Настройка переменной среды
**Linux / Mac**
```
export SSLKEYLOGFILE=~/sslkeylogfile.log
```
**Windows**
На вкладке **System Properties | Advanced** нажмите кнопку **Environment Variables** и добавьте имя переменной (SSLKEYLOGFILE), а в качестве значения — путь к файлу.
### 2. Настройка Wireshark
Из выпадающего меню выберите **Edit | Preferences | Protocols | SSL | (Pre)-Master-Secret Log Filename — Browse**, указав файл, который вы указали в переменную среды.
Начинайте захват трафика в локальной системе.
### 3. Перезапуск Firefox или Chrome
После перехода на сайт HTTPS лог-файл начнёт увеличиваться в размере, поскольку записывает симметричные ключи сессии.
Взгляните на ранее запущенную сессию Wireshark. Вы должны увидеть что-то похожее на скриншот внизу с расшифрованными сессиями. Расшифрованные пакеты — на вкладке в нижней панели.
Другой способ просмотра сеанса — через выпадающее меню **Analysis | Follow | Stream | SSL**. Если сеанс успешно расшифрован, вы увидите опцию для SSL.
Разумеется, будьте осторожны при записи этих ключей и пакетов. Если посторонний получит доступ к лог-файлу, то легко найдёт там ваши пароли и куки аутентификации.
Ещё один вариант выхода на базовый HTTP-трафика — использовать инструмент [Burp Suite](https://portswigger.net/burp) с загруженным сертификатом CA в браузере. В этом случае прокси расшифровывает соединение на стороне клиента, а затем устанавливает новый сеанс SSL/TLS на сервере. Есть много способов проведения такой MiTM-атаки на себя, это два самых простых.
Извлечение файлов из пакетов с помощью функции экспорта (HTTP или SMB)
======================================================================
Файлы легко извлекаются через меню экспорта.
**File | Export Objects | HTTP**
Все найденные файлы отобразятся в новом окне. Отсюда же можно сохранить отдельные файлы или сразу все. Аналогичный метод применяется для извлечения файлов из сессий SMB. Как мы уже упоминали, это протокол Microsoft Server Message Block, который используется для общего доступа к файлам под Windows.
Строка состояния
================
Строка состояния в правой части окна позволяет быстро перейти в нужное место сетевого дампа, щёлкнув по цветовому индикатору. Например, красным цветом в строке состояния помечены пакеты с ошибками.
Образец PCAP
============
Когда только начинаете работу с Wireshark, хочется посмотреть на какие-нибудь интересные дампы с пакетами. Их можно найти на странице [Wireshark Samples](https://wiki.wireshark.org/SampleCaptures). Примеров с разными протоколами там хватит вам на несколько месяцев анализа, есть даже образцы трафика червей и эксплоитов.
Настройка окружения
===================
Внешний вид консоли по умолчанию всячески настраивается. Можно добавлять или удалять столбцы, добавляя даже такие простые вещи как столбец времени UTC, что сразу повышает информативность логов, если анализировать историю пакетов.
Столбцы настраиваются в меню **Edit | Preferences | Appearance | Columns**. Там же изменяется общий шаблон, шрифт и цвета.
На видео — полезные советы по настройке окружения, в том числе выявление неполадок по порядковым номерам последовательности TCP.
capinfos
========
В комплекте с Wireshark поставляется удобный инструмент командной строки `capinfos`. Эта утилита генерирует статистику пакетного дампа, с временем начала/окончания записи и другими подробностями. С опцией `-T` она выдаёт текст с табуляцией — он подходит для импорта в электронные таблицы или анализа в консоли.
```
test@ubuntu:~$ capinfos test.pcap
File name: test.pcap
File type: Wireshark/tcpdump/... - pcap
File encapsulation: Ethernet
File timestamp precision: microseconds (6)
Packet size limit: file hdr: 262144 bytes
Number of packets: 341 k
File size: 449 MB
Data size: 444 MB
Capture duration: 3673.413779 seconds
First packet time: 2018-12-01 11:26:53.521929
Last packet time: 2018-12-01 12:28:06.935708
Data byte rate: 120 kBps
Data bit rate: 967 kbps
Average packet size: 1300.72 bytes
Average packet rate: 93 packets/s
SHA256: 989388128d676c329ccdbdec4ed221ab8ecffad81910a16f473ec2c2f54c5d6e
RIPEMD160: 0742b6bbc79735e57904008d6064cce7eb95abc9
SHA1: d725b389bea044d6520470c8dab0de1598b01d89
Strict time order: True
Number of interfaces in file: 1
```
Заключение
==========
Эта статья изначально была опубликована в 2011 году, затем серьёзно обновилась. Если у вас есть какие-либо комментарии, улучшения или советы для шпаргалки, [пишите мне](https://hackertarget.com/contact/). Wireshark — один из тех незаменимых инструментов, который многие используют, но мало кто владеет в совершенстве. Тут можно углубляться всё дальше и дальше. | https://habr.com/ru/post/436226/ | null | ru | null |
# Модели глубоких нейронных сетей sequence-to-sequence на PyTorch (Часть 2)
2 - Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
-------------------------------------------------------------------------------------------------
Во втором разделе туториола о моделях sequence-to-sequence с использованием PyTorch и TorchText мы будем реализовывать модель из работы [Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation](https://arxiv.org/abs/1406.1078). Эта нейронная сеть позволит достичь лучшей точности при использовании только однослойной RNN как в кодере, так и в декодере.
Как и ранее, если визуальный формат поста вас не удовлетворяет, то ниже ссылки на английскую и русскую версию jupyter notebook:
[Исходная версия](https://github.com/bentrevett/pytorch-seq2seq/blob/master/2%20-%20Learning%20Phrase%20Representations%20using%20RNN%20Encoder-Decoder%20for%20Statistical%20Machine%20Translation.ipynb) ([Open jupyter notebook In Colab](https://colab.research.google.com/github/bentrevett/pytorch-seq2seq/blob/master/2%20-%20Learning%20Phrase%20Representations%20using%20RNN%20Encoder-Decoder%20for%20Statistical%20Machine%20Translation.ipynb))
[Русская версия](https://github.com/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/2%20-%20Learning%20Phrase%20Representations%20using%20RNN%20Encoder-Decoder%20for%20Statistical%20Machine%20Translation.ipynb) ([Open jupyter notebook In Colab](https://colab.research.google.com/github/vasiliyeskin/bentrevett-pytorch-seq2seq_ru/blob/master/2%20-%20Learning%20Phrase%20Representations%20using%20RNN%20Encoder-Decoder%20for%20Statistical%20Machine%20Translation.ipynb))
### Введение
Напомним общую модель кодера-декодера.
Мы используем наш кодировщик (зеленый) поверх исходной последовательности, прошедшей слой эмбеддинга (желтый), чтобы создать вектор контекста (красный). Затем мы передаём этот вектор контекста в декодер (синий) с линейным слоем (фиолетовый) для генерации целевого предложения.
[В предыдущей модели](https://habr.com/ru/post/567142/) мы использовали многослойную LSTM сеть в качестве кодера и декодера.
Одним из недостатков модели в прошлой части является то, что декодер пытается втиснуть большое количество информации в скрытые состояния. Во время декодирования скрытое состояние должно содержать информацию обо всей исходной последовательности, а также обо всех токенах, которые были декодированы на данный момент. Улучшив сжатие этой информации, мы сможем создать улучшенную модель!
Мы будем использовать сеть GRU (Gated Recurrent Unit) вместо LSTM (Long Short-Term Memory). Почему? В основном потому, что так авторы сделали в статье (в этой же статье была представлена GRU сеть), а также потому, что в прошлый раз мы использовали LSTM. Отличия GRU (и LSTM) от стандартных RNN подробно рассмотрены [здесь](https://colah.github.io/posts/2015-08-Understanding-LSTMs/). Резонный вопрос, GRU лучше LSTM? [Исследование](https://arxiv.org/abs/1412.3555) показало, что они почти одинаковы и одновременно, чем стандартные RNN.
### Подготовка данных
Вся подготовка данных будет почти такой же, как и в прошлый раз, поэтому мы очень кратко опишем, что делает каждый блок кода. Более развётнутое описание смотрите в предыдущей части.
Мы импортируем PyTorch, TorchText, spaCy и несколько стандартных модулей.
```
import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.legacy.datasets import Multi30k
from torchtext.legacy.data import Field, BucketIterator
import spacy
import numpy as np
import random
import math
import time
```
Затем установите случайное начальное число для детерминированной воспроизводимости результатов.
```
SEED = 1234
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
```
Для Google Colab используем следующие команды (После загрузки не забывайте перезапустите colab runtime! Наибыстрейший способ через короткую комаду： **Ctrl + M + .**):
```
!pip install -U spacy==3.0
!python -m spacy download en_core_web_sm
!python -m spacy download de_core_news_sm
```
Создаём экземпляры наших немецких и английских spaCy моделей.
```
spacy_de = spacy.load('de_core_news_sm')
spacy_en = spacy.load('en_core_web_sm')
```
Ранее мы поменяли местами исходное (немецкое) предложение, однако в статье, которую мы реализуем, они этого не делают, и мы не будем.
```
def tokenize_de(text):
"""
Tokenizes German text from a string into a list of strings
"""
return [tok.text for tok in spacy_de.tokenizer(text)]
def tokenize_en(text):
"""
Tokenizes English text from a string into a list of strings
"""
return [tok.text for tok in spacy_en.tokenizer(text)]
```
Далее мы создаем токенизирующие функции. Они могут быть переданы в torchtext и будут принимать предложение в виде строки, а возвращать предложение в виде списка токенов.
```
SRC = Field(tokenize=tokenize_de,
init_token='',
eos\_token='',
lower=True)
TRG = Field(tokenize = tokenize\_en,
init\_token='',
eos\_token='',
lower=True)
```
Загрузка наших данных.
```
train_data, valid_data, test_data = Multi30k.splits(exts = ('.de', '.en'),
fields = (SRC, TRG))
```
Мы распечатаем пример, чтобы проверить, не перевернут ли он.
```
print(vars(train_data.examples[0]))
```
Затем создаём наш словарь, преобразовав все токены, встречающиеся менее двух раз, в токены.
```
SRC.build_vocab(train_data, min_freq = 2)
TRG.build_vocab(train_data, min_freq = 2)
```
Наконец, определим `device` и создаём наши итераторы.
```
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
```
```
BATCH_SIZE = 128
train_iterator, valid_iterator, test_iterator = BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size = BATCH_SIZE,
device = device)
```
### Создание Seq2Seq модели
#### Кодер
Кодер аналогичен предыдущему, но многослойный LSTM заменен на однослойный GRU. Кроме того, мы не передаем дропаут в качестве аргумента GRU, поскольку этот дропаут используется между слоями многослойной RNN. Поскольку у нас есть только один слой, PyTorch отобразит предупреждение, если мы попытаемся передать ему значение дропаута.
Еще одна вещь, которую следует отметить в отношении GRU, заключается в том, что он требует и возвращает только скрытое состояние, не нуждаясь в состоянии ячейки, как в LSTM.
Из приведенных выше уравнений видно, что RNN и GRU идентичны. Однако внутри GRU есть несколько *запорных механизмовs*, которые контролируют поток информации в скрытое состояние и из него (похожий на LSTM). Опять же, для получения дополнительной информации обращайтесь [сюда](https://colah.github.io/posts/2015-08-Understanding-LSTMs/).
Он идентичен кодировщику общей модели seq2seq, со всей "магией", происходящей внутри GRU (зеленый).
```
class Encoder(nn.Module):
def __init__(self, input_dim, emb_dim, hid_dim, dropout):
super().__init__()
self.hid_dim = hid_dim
self.embedding = nn.Embedding(input_dim, emb_dim) #no dropout as only one layer!
self.rnn = nn.GRU(emb_dim, hid_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, src):
#src = [src len, batch size]
embedded = self.dropout(self.embedding(src))
#embedded = [src len, batch size, emb dim]
outputs, hidden = self.rnn(embedded) #no cell state!
#outputs = [src len, batch size, hid dim * n directions]
#hidden = [n layers * n directions, batch size, hid dim]
#outputs are always from the top hidden layer
return hidden
```
### Декодер
Реализация данного декодер значительно отличается от декодера предыдущей модели, и в текущем декодере мы усилили сжатие некоторой информации.
GRU в декодере принимает не только целевой токен из эмбеддинга  и предыдущее скрытое состояние в качестве входных данных, но также и вектор контекста .
Обратите внимание, как этот вектор контекста не имеет индекса , это означает, что мы повторно используем один и тот же вектор контекста, возвращаемый кодировщиком, для каждого временного шага в декодере.
Раньше мы предсказывали следующий токен *с линейным слоем , используя только выход декодер верхнего уровня, скрытый на этом временном шаге как *. Теперь мы также передаем текущий токен эмбеддинга и вектор контекста в линейный слой.
Таким образом, наш декодер теперь выглядит примерно так:
Обратите внимание, начальное скрытое состояние  по-прежнему является вектором контекста , поэтому при генерации первого токена мы фактически вводим два идентичных вектора контекста в GRU.
Как эти два изменения уменьшают сжатие информации? Гипотетически скрытым состояниям декодер  больше нет необходимости содержать информацию об исходной последовательности, поскольку она всегда доступна в качестве входных данных. Таким образом, они должены содержать только информацию о том, какие токены они уже сгенерировали. Передача в линейный уровень (через эмбеддинг ) означает, что этот уровень может напрямую видеть входной токен, без необходимости получать информацию о нём из скрытого состояния.
Однако эта гипотеза — всего лишь гипотеза, невозможно определить, как модель на самом деле использует предоставленную ей информацию (не слушайте никого, кто говорит иначе). Тем не менее это хорошая догадка, и результаты, кажется, указывают на то, что эта модификации является хорошей идеей!
В рамках реализации мы передадим и в GRU объединив их вместе, так что входные размеры в GRU были `emb_dim + hid_dim` (поскольку вектор контекста будет иметь размер `hid_dim`). Линейный слой принимает , и объединения их вместе, поэтому входные размеры теперь `emb_dim + hid_dim*2`. Мы также не передаем значение дропаута в GRU, поскольку оно используется только на входном уровене.
```
class Decoder(nn.Module):
def __init__(self, output_dim, emb_dim, hid_dim, dropout):
super().__init__()
self.hid_dim = hid_dim
self.output_dim = output_dim
self.embedding = nn.Embedding(output_dim, emb_dim)
self.rnn = nn.GRU(emb_dim + hid_dim, hid_dim)
self.fc_out = nn.Linear(emb_dim + hid_dim * 2, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, input, hidden, context):
#input = [batch size]
#hidden = [n layers * n directions, batch size, hid dim]
#context = [n layers * n directions, batch size, hid dim]
#n layers and n directions in the decoder will both always be 1, therefore:
#hidden = [1, batch size, hid dim]
#context = [1, batch size, hid dim]
input = input.unsqueeze(0)
#input = [1, batch size]
embedded = self.dropout(self.embedding(input))
#embedded = [1, batch size, emb dim]
emb_con = torch.cat((embedded, context), dim = 2)
#emb_con = [1, batch size, emb dim + hid dim]
output, hidden = self.rnn(emb_con, hidden)
#output = [seq len, batch size, hid dim * n directions]
#hidden = [n layers * n directions, batch size, hid dim]
#seq len, n layers and n directions will always be 1 in the decoder, therefore:
#output = [1, batch size, hid dim]
#hidden = [1, batch size, hid dim]
output = torch.cat((embedded.squeeze(0), hidden.squeeze(0), context.squeeze(0)),
dim = 1)
#output = [batch size, emb dim + hid dim * 2]
prediction = self.fc_out(output)
#prediction = [batch size, output dim]
return prediction, hidden
```
### Seq2Seq модель
Соединяя кодировщик и декодер, получаем:
Снова, в этой реализации нам нужно обеспечить одинаковые скрытые размеры в кодировщике и декодере.
Кратко пройдемся по всем этапам:
* тензор `outputs` создан для хранения всех прогнозов 
* исходная последовательность подается в кодировщик для получения вектора контекста `context`
* начальное скрытое состояние декодера установлено как вектор `context` 
* мы используем в качестве входных токенов `input` 
* затем декодируем в цикле:
+ передача входного токена , предыдущего скрытого состояния , и вектора контекста в декодер
+ получение прогноза и нового скрытого состояния 
+ Затем мы решаем, собираемся ли мы использовать обучение с принуждением или нет, устанавливая следующий вход соответствующим образом (либо следующий истинный токен в целевой последовательности, либо самый вероятный следующий токен)
```
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, device):
super().__init__()
self.encoder = encoder
self.decoder = decoder
self.device = device
assert encoder.hid_dim == decoder.hid_dim, \
"Hidden dimensions of encoder and decoder must be equal!"
def forward(self, src, trg, teacher_forcing_ratio = 0.5):
#src = [src len, batch size]
#trg = [trg len, batch size]
#teacher_forcing_ratio is probability to use teacher forcing
#e.g. if teacher_forcing_ratio is 0.75 we use ground-truth inputs 75% of the time
batch_size = trg.shape[1]
trg_len = trg.shape[0]
trg_vocab_size = self.decoder.output_dim
#tensor to store decoder outputs
outputs = torch.zeros(trg_len, batch_size, trg_vocab_size).to(self.device)
#last hidden state of the encoder is the context
context = self.encoder(src)
#context also used as the initial hidden state of the decoder
hidden = context
#first input to the decoder is the tokens
input = trg[0,:]
for t in range(1, trg\_len):
#insert input token embedding, previous hidden state and the context state
#receive output tensor (predictions) and new hidden state
output, hidden = self.decoder(input, hidden, context)
#place predictions in a tensor holding predictions for each token
outputs[t] = output
#decide if we are going to use teacher forcing or not
teacher\_force = random.random() < teacher\_forcing\_ratio
#get the highest predicted token from our predictions
top1 = output.argmax(1)
#if teacher forcing, use actual next token as next input
#if not, use predicted token
input = trg[t] if teacher\_force else top1
return outputs
```
Обучение модели Seq2Seq
-----------------------
Остальная часть этого раздела очень похожа на аналогичную часть из предыдущей части.
Мы инициализируем наш кодер, декодер и модель seq2seq (поместив его на графический процессор, если он у нас есть). Как и раньше, размеры эмбеддинга и величина дропаута могут быть разными для кодера и декодера, но скрытые размеры должны оставаться такими же.
```
INPUT_DIM = len(SRC.vocab)
OUTPUT_DIM = len(TRG.vocab)
ENC_EMB_DIM = 256
DEC_EMB_DIM = 256
HID_DIM = 512
ENC_DROPOUT = 0.5
DEC_DROPOUT = 0.5
enc = Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, ENC_DROPOUT)
dec = Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, DEC_DROPOUT)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Seq2Seq(enc, dec, device).to(device)
```
Затем мы инициализируем наши параметры. В исходной статье говорится, что параметры инициализируются из нормального распределения со средним значением 0 и стандартным отклонением0 .01, т.е. .
В ней также говорится, что мы должны инициализировать повторяющиеся параметры специальным образом, однако для простоты мы инициализируем их в виде .
```
def init_weights(m):
for name, param in m.named_parameters():
nn.init.normal_(param.data, mean=0, std=0.01)
model.apply(init_weights)
```
Распечатываем количество параметров.
Несмотря на то, что у нас есть только однослойная RNN для нашего кодера и декодера, на самом деле у нас есть **больше** параметры, чем в предыдущей модели. Это связано с увеличенным размером входов в GRU и линейный слой. Однако это незначительное увеличение параметров не приводит увеличению времени обучения (~3 секунд на дополнительную эпоху).
```
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'The model has {count_parameters(model):,} trainable parameters')
```
Мы инициализируем наш оптимизатор.
```
optimizer = optim.Adam(model.parameters())
```
Мы также инициализируем функцию потерь, игнорируя потерю на токенах .
```
TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token]
criterion = nn.CrossEntropyLoss(ignore_index = TRG_PAD_IDX)
```
Затем мы создаем цикл обучения ...
```
def train(model, iterator, optimizer, criterion, clip):
model.train()
epoch_loss = 0
for i, batch in enumerate(iterator):
src = batch.src
trg = batch.trg
optimizer.zero_grad()
output = model(src, trg)
#trg = [trg len, batch size]
#output = [trg len, batch size, output dim]
output_dim = output.shape[-1]
output = output[1:].view(-1, output_dim)
trg = trg[1:].view(-1)
#trg = [(trg len - 1) * batch size]
#output = [(trg len - 1) * batch size, output dim]
loss = criterion(output, trg)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
optimizer.step()
epoch_loss += loss.item()
return epoch_loss / len(iterator)
```
...и цикл оценки, не забывая установить модель в режим `eval` и выключить обучение с принуждением.
```
def evaluate(model, iterator, criterion):
model.eval()
epoch_loss = 0
with torch.no_grad():
for i, batch in enumerate(iterator):
src = batch.src
trg = batch.trg
output = model(src, trg, 0) #turn off teacher forcing
#trg = [trg len, batch size]
#output = [trg len, batch size, output dim]
output_dim = output.shape[-1]
output = output[1:].view(-1, output_dim)
trg = trg[1:].view(-1)
#trg = [(trg len - 1) * batch size]
#output = [(trg len - 1) * batch size, output dim]
loss = criterion(output, trg)
epoch_loss += loss.item()
return epoch_loss / len(iterator)
```
Мы также определим функцию, которая вычисляет, сколько времени занимает эпоха.
```
def epoch_time(start_time, end_time):
elapsed_time = end_time - start_time
elapsed_mins = int(elapsed_time / 60)
elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
return elapsed_mins, elapsed_secs
```
Затем мы обучаем нашу модель, сохраняя параметры, которые дают нам наименьшие потери при проверке.
```
N_EPOCHS = 10
CLIP = 1
best_valid_loss = float('inf')
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss = train(model, train_iterator, optimizer, criterion, CLIP)
valid_loss = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'tut2-model.pt')
print(f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}')
```
Наконец, мы тестируем модель на тестовой выборке, используя эти «лучшие» параметры.
```
model.load_state_dict(torch.load('tut2-model.pt'))
test_loss = evaluate(model, test_iterator, criterion)
print(f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |')
```
Если посмотреть на выигрыш в тесте, то видно улучшение производительность по сравнению с предыдущей моделью. Это довольно хороший признак того, что эта архитектура модели что-то делает лучше! Ослабление сжатия информации кажется неплохим подходом, и в следующем разделе мы пойдём по этому пути еще дальше с помощью *внимания*. | https://habr.com/ru/post/567610/ | null | ru | null |
# Создание плагина для Joomla 1.5
С проблемой создания расширений для Joomla 1.5 я столкнулся (и продолжаю сталкиваться) при переводе одного сайта с 1.0-версии на 1.5-ю и с удивлением обнаружил, что ветка 1.5 документирована из рук вон плохо. Более-менее нормально документирован сам API, который теперь называется Joomla Framework, но никаких вменяемых туториалов даже в официальном вики не наблюдается, поэтому мне пришлось использовать скудную информацию, почерпнутую из блогов в англоязычном Интернете, разбираться в коде Джумлы и в коде ее демо-примеров. Учитывая этот факт, а также факт практически полного отсутствия какой бы то ни было полезной информация по разработке на Джумле 1.5 в русскоязычном Интернете, я решился на эту скромную статью.
Здесь я опишу свой опыт создания простейшего плагина и доведения его до рабочего состояния, поэтому, если какие-то мои решения покажуться кому-то неправильными или неоптимальными, просьба дать знать, т.к. иначе добыть «правильную» информацию по этому вопросу исключительно трудно.
### Постановка задачи
Требуется создать «родной» плагин, который позволял бы вставить в нужное месте статьи содержимое категории в виде списка ссылок на статьи этой категории. Очевидно, в терминологии Joomla — это контентный (content) плагин. Joomla 1.5 позволяет подключать расширения, написанные по-старому (как это принято в ветке 1.0) в режиме совместимости (legacy), для этого необходимо опубликовать системный плагин Legacy и включить Режим совместимости (Legacy Mode). Тем не менее было принято решение делать все «по-новому», т.е. в «родном» режиме. Плагин мы назовем ItemList. Для использования плагина необходимо в нужном месте содержимого статьи указать специальный тег в виде *{itemlist: id\_категории}*.
### Реализация
Для создания своего плагина необходимо создать класс, унаследованный от *JPlugin* и реализовать в нем требуемый функционал. Для успешного функционирования плагина в среде Joomla, в классе плагина должны быть реализованы некоторые методы с предопределенными именами – именно эти методы Joomla будет вызывать в процессе работы. Для контентных плагинов (согласно [статье](http://developer.joomla.org/tutorials/184-how-to-create-a-joomla-plugin.html) Andrew Eddie) таких методов предопределено 5 штук:
* *onPrepareContent*
* *onAfterDisplayTitle*
* *onBeforeDisplayContent*
* *onBeforeContentSave*
* *onAfterContentSave*
Для создания нашего простейшего плагина нам понадобится только первый из методов, т.е. *onPrepareContent*, который имеет три параметра:
* *&$article* – ссылка на объект статьи
* *&$params* – ссылка на объект параметров статьи
* *$limitstart* – номер страницы (я так понимаю, используется при «пагинации»)
В теле этого метода будет собственно реализован весь функционал нашего плагина, для чего необходимо:
1. Найти в теле статьи тег, обозначающий плагин,
2. Вычислить из него id категории, содержание которой необходимо вывести,
3. Замена тега плагина на список ссылок на статьи категории.
Наш плагин состоит всего из двух файлов.
```
itemlist.php
```
> `php</font
>
> defined('\_JEXEC') or die('Доступ запрещен.');
>
>
>
> jimport( 'joomla.plugin.plugin' );
>
>
>
> class plgContentItemList extends JPlugin {
>
> function plgContentItemList(&$subject, $params) {
>
> parent::\_\_construct($subject, $params);
>
> $this->\_plugin = JPluginHelper::getPlugin('content', 'itemlist');
>
> }
>
>
>
> function onPrepareContent(&$article, &$params, $limitstart) {
>
> $content = $article->text;
>
>
>
> if(preg\_match\_all("/{itemlist:.+?}/", $content, $matches, PREG\_PATTERN\_ORDER) > 0) {
>
> foreach ($matches as $match) {
>
> foreach ($match as $m) {
>
> $catid = intval(str\_replace('}', '', str\_replace('{itemlist:', '', $m)));
>
> $query = 'SELECT id, title FROM #\_\_content WHERE catid = ' . $catid . ' AND state=1';
>
>
>
> $database = JFactory::getDBO();
>
> $database->setQuery($query);
>
> $items = $database->loadObjectList();
>
>
>
> $output = '';
>
> for($i = 0; $i < count($items); $i++) {
>
> $link = 'index.php?option=com\_content&task=view&id='. $items[$i]->id;
>
> $output .= '- [.]('</font><font color=)
> $link . '">' . $items[$i]->title . '';
>
> }
>
> $output .= '';
>
>
>
> $content = preg\_replace('/{itemlist:.+?}/', $output, $content, 1);
>
> }
>
> }
>
> }
>
>
>
> $article->text = $content;
>
> return true;
>
> }
>
> }
>
> ?>`
>
>
В этом файле реализован весь функционал нашего плагина. Класс *plgContentItemList* имеет конструктор, который, в целях совместимости с PHP4 реализован именно в старом стиле. Инициализация сводится лишь к тому, что необходимо загрузить информацию о плагине, что производится вызовом метода *getPlugin* класса *JPluginHelper*. В методе *onPrepareContent* с помощью регулярных выражений реализуются шаги, описанные выше.
Для установки плагина в Joomla, еще нам понадобится *xml*-файл с описанием плагина.
```
itemlist.xml
```
> `xml</font version="1.0" encoding="utf-8"?>
>
> version="1.5" type="plugin" group="content">
>
> >Content - ItemList>
>
> >>
>
> >>
>
> >Copyright (C) 2009. All rights reserved.>
>
> >www.gnu.org/licenses/gpl-2.0.html GNU/GPL>
>
> >>
>
> >>
>
> >1.0>
>
> >
>
> A category items list plugin. /> />
>
> Usage: {itemlist:category\_id}
>
> >
>
> >
>
> plugin="itemlist">itemlist.php>
>
> >
>
> >`
>
>
Теперь архивируем zip-ом эти два файла в один архив, устанавливаем плагин через админпанель Joomla и не забываем его опубликовать. Для просмотра результатов его работы в теле статьи используем тег *{itemlist: id\_категории}*. | https://habr.com/ru/post/54221/ | null | ru | null |
# PostgreSQL в «Тензоре» — публикации за год (#2)
Добро пожаловать под кат, если вдруг вы пропустили какие-то из наших статей за прошедший год **об интересных и полезных возможностях PostgreSQL**, которые мы узнаем при разработке нашей системы полного цикла управления бизнесом [СБИС](https://sbis.ru/) — от кадрового учета, бухгалтерии, делопроизводства и налоговой отчетности, до таск-менеджмента, корпоративного портала и видеокоммуникаций.
Если не видели [дайджест за первый год](https://habr.com/ru/company/tensor/blog/529624/) — время наверстать упущенное!
---
### Анализ запросов в PostgreSQL
**Как мы анализируем планы запросов, чтобы сделать их максимально быстрыми*.***
07.12 — [One Tool to Analyze Them All](https://habr.com/ru/post/531620/) (+18, ^13)
[explain.tensor.ru](https://explain.tensor.ru/) поддерживает планы специфичных *PostgreSQL-совместимых решений*: [Timescale](https://www.timescale.com/), [Citus](https://www.citusdata.com/), [Greenplum](https://greenplum.org/) и [Redshift](https://aws.amazon.com/ru/redshift/).
15.06 — [Анализируем «слона» вместе с коллегами](https://habr.com/ru/post/562796/) (+7, ^20)
Теперь на [explain.tensor.ru](https://explain.tensor.ru/) можно пригласить коллегу-иностранца, оперативно *поделившись ссылкой* в мессенджере, — ведь теперь *на английский переведен весь интерфейс*, включая *подсказки по оптимизации плана*.
13.09 — [Кластеризуем миллионы планов PostgreSQL](https://habr.com/ru/post/577646/) (+9, ^44)
Некоторые подходы, которые позволяют нам сводить *миллионы планов в сутки* всего лишь в десятки объектов, которые надо анализировать.
---
### SQL Antipatterns и оптимизация SQL
**Как поправить наиболее частые ошибки разработчиков при работе с базой.**
14.12 — [скованные одной цепью EXISTS](https://habr.com/ru/post/532852/) (+10, ^39)
Разные варианты, как можно оптимизировать *запросы с несколькими* `EXISTS`.
13.07 — [борем deadlock при пакетном UPDATE](https://habr.com/ru/post/567514/) (+25, ^45)
Почему тривиальный запрос `UPDATE tbl SET val = val + 1 WHERE id IN (1, 2, 3);` приводит к `deadlock`, и как этого можно избежать.
17.08 — [«слишком много золота»](https://habr.com/ru/post/573214/) (+27, ^81)
Как получается, что между клиентским приложением и БД начинают летать мегабайты трафика: автогенерируемые запросы, `INSERT` вместо `COPY`, дублирующиеся параметры - все об этом.
24.08 — [«где-то я тебя уже видел...»](https://habr.com/ru/post/574330/) (+16, ^60)
Откуда в плане запроса возникают *повторяющиеся блоки*? `LATERAL` поможет улучшить производительность!
---
### SQL HowTo
**Учимся писать нетривиальные SQL-запросы для решения прикладных задач.**
17.12 — [префиксный FTS-поиск с релевантностью по дате](https://habr.com/ru/post/533506/) (+8, ^29)
Как можно быстро найти записи *по ключевым словам*, если пользователь хочет видеть результаты *с сортировкой по дате*.
11.01 — [рейтинг-за-интервал](https://habr.com/ru/post/536696/) (+13, ^54)
Учимся *строить "топ"* товаров (или продавцов) "за текущий месяц".
20.04 — [решаем головоломку «Небоскрёбы» почти без перебора](https://habr.com/ru/post/552790/) (+32, ^61)
Разрабатываем *сложный SQL-запрос* на примере решения простой логической игры.
08.09 — [три WHERE в одном запросе](https://habr.com/ru/post/576894/) (+8, ^48)
Почему это может пригодиться для базы мониторинга?
16.11 — [делаем из мухи слона (алгоритм Ли)](https://habr.com/ru/post/589467/) (+20, ^52)
Используем *волновой алгоритм* для классической задачи Льюиса Кэррола.
22.11 — [генерируем лабиринты (алгоритм Прима и геометрические типы)](https://habr.com/ru/post/590179/) (+33, ^52)
*Планарный граф* укладываем на плоскость, и пошагали.
---
### DBA
**О базе надо заботиться, и делать это предельно аккуратно.**
18.01 — [Ночной Дозор](https://habr.com/ru/post/537812/) (+19, ^39)
Как оптимизировать многогигабайтные *посуточные секции append-only данных*.
12.02 — [«Кто-то слишком много ест!»](https://habr.com/ru/post/542058/) (+29, ^68)
Находим *слишком "раздувшиеся" таблицы*, которым не может помочь autovacuum.
24.03 — [когда почти закончился serial](https://habr.com/ru/post/547740/) (+40, ^73)
С *минимальными блокировками* превращаем `int4-PK` в `int8`, пока база еще не "встала".
05.04 — [меняем «слонов» на переправе](https://habr.com/ru/post/550730/) (+10, ^22)
Как мы мигрировали базу мониторинга между версиями PostreSQL *с помощью FDW*.
12.05 — [прибираем «мертвые души»](https://habr.com/ru/post/556896/) (+17, ^39)
Если серверу PG внезапно стало плохо, на диске могут остаться "хвосты". Найдем и зачистим их.
---
### Решения для PostgreSQL
**Как можно решить разные возникающие "в энтерпрайзе" бизнес-задачи.**
25.01 — [Агрегаты в БД — зачем, как, а стоит ли?](https://habr.com/ru/post/539016/) (+13, ^48)
Как и почему иногда *агрегаты стоит оставить в базе*, а не вытаскивать "наружу".
28.01 — [Агрегаты в БД — эффективная обработка потока «фактов»](https://habr.com/ru/post/539638/) (+13, ^41)
Собираем *входящие данные для агрегирования* так, чтобы не "лечь" под нагрузкой.
03.02 — [Агрегаты в БД — многомерные суперагрегаты](https://habr.com/ru/post/540572/) (+14, ^31)
Строим агрегаты *сразу для разных разрезов*.
08.02 — [Агрегаты в БД — прокси-таблицы](https://habr.com/ru/post/541374/) (+12, ^48)
Как можно *снизить суммарные задержки* на вставку множества изменений в таблицы агрегатов за счет использования промежуточных таблиц и внешней обработки.
15.03 — [Случайности не случайны](https://habr.com/ru/post/547108/) (+19, ^32)
Можно ли достоверно *предсказать будущее* хоть на немного вперед? Иногда - вполне, надо только много везения... или немного знаний.
25.05 — [Множественные источники данных в интерфейсе — client-side «SQL»](https://habr.com/ru/post/559088/) (+10, ^18)
Как сделать быстрый индексный *выбор данных из нескольких источников* в общий таймлайн.
19.08 — [КЛАДРируем адреса произвольной формы (ч.1 — импорт)](https://habr.com/ru/post/565850/) (+9, ^31)
Эффективно *импортируем адресный справочник* в свою базу. КЛАДР умирает, но дело его живет!
02.09 — [КЛАДРируем адреса произвольной формы (ч.2 — подстрочный поиск)](https://habr.com/ru/post/575704/) (+7, ^39)
Учимся быстро подсказывать адреса с помощью *"двухмерного" LIKE*.
---
Дайджесты и обзоры
------------------
26.11 — [PostgreSQL в «Тензоре» — публикации за год](https://habr.com/ru/post/529624/) (+23, ^60)
Путеводитель по статьям первого года.
01.04 — [Энтерпрайз-домино. 0x13 вредных советов для ниндзя-разработчика](https://habr.com/ru/post/549908/) (+21, ^39)
*"Выращиваем" архитектуру бизнес-приложения*, отбиваясь от вражеских агентов, тыкающих во все слабые места.
26.04 — [Чего «энтерпрайзу» в PostgreSQL не хватает](https://habr.com/ru/post/553754/) (+31, ^75)
Чего, по нашему опыту использования PostgreSQL в "кровавом энтерпрайзе" ["Тензора"](https://tensor.ru/), *не хватает в этой СУБД*. | https://habr.com/ru/post/590977/ | null | ru | null |
# Deep Linking для мобильных приложений
На WWDC 2015 инженеры компании Apple заявили, что пересмотрели подход к Deep Linking, в прошлом году компания Google анонсировала App Index — как новый взгляд на глубинные ссылки, в начале 2015 года в мире мобильной разработки заговорили о контекстных Deep Links. Что это за инструмент и как с ним работать применительно к iOS — расскажу в этой статье.
#### Что это?
Один из способов увеличения конверсии при продвижении IT-продукта — уменьшение барьеров для достижения пользователями искомой цели. В мобильной разработке эта проблема еще актуальней. При использовании e-mail, push или sms-рассылок с информацией о промо-акциях упрощение доступа к функционалу приложения просто необходимо. В такой ситуации просто запуск приложения из внешнего источника — не решение, ведь промо-акция — это конкретное спец.предложение в конкретном разделе. Чтобы после запуска приложения пользователю не пришлось по нему бродить, искать и раздражаться, нужен дополнительный инструмент, предопределяющий навигацию. И такой инструмент есть.
**Deep Linking** (глубинное связывание) — технология, благодаря которой пользователь может перемещаться между приложениями в заранее определенные разделы.
#### Как это работает?
Представим, что пиццерия решила провести рекламную кампанию, в рамках которой предлагает всем желающим купить пиццу «Маргарита» с 50% скидкой. У пиццерии есть веб-сайт и мобильное приложение (последнее, конечно, предпочтительнее для работы с клиентом по маркетинговым соображениям, да и операции с банковской картой в приложении гораздо удобнее, чем в браузере). Компания делает sms-рассылку по своей клиентской базе с информацией о спец.предложении и дает ссылку на нужный раздел сайта. Если на смартфоне клиента установлено приложение пиццерии, то при переходе по ссылке сервер сайта отправит клиента сразу в нужный раздел аппа для оформления заказа (это и есть механизм Deep Linking), если приложения на смартфоне нет, клиенту предложат установить его в сторе и затем повторно перейти по ссылке в sms (или продолжить пользоваться веб-версией).
В концепции всемирного Web механизм Deep Linking был заложен в HTTP и URL, как возможность перемещения между любыми документами в сети, а не только корневыми страницами. В мобильных операционных системах данный механизм реализуется разными способами.
#### Как это сделать в iOS
Принцип работы Deep Linking заключается в следующем: пользователь инициирует переход по URL, ресурс, находящийся по этой URL, определяет операционную систему и соответствующим образом осуществляет переход в приложение в заранее определенный раздел.
*URL — ссылка, указывающая на местонахождение какого-либо ресурса. Используется преимущественно для адресации в сети, но может быть использована для указания местоположения в файловой системе.*
У этой технологии есть несколько способов реализации:
* Классический подход
* Сторонние решения
* Новые веянья с IT-полей
#### Классическая реализация в iOS
Общепринятая реализация состоит из следующих этапов:
1. Перевод запроса в URL-схему, её исполнение с возможностью обработки отсутствия схемы.
2. Обработка схемы и навигация внутри приложения к заданному разделу/экрану.
URL-схема (URL scheme) — часть URL до ://, ответственная за схему взаимодействия с ресурсом, на который ведет сама ссылка, в большинстве случаев имеется ввиду протокол.
Существует ряд зарегистрированных схем, к примеру `http, ftp, tel, mailto`, и т.д.
###### Создание, выполнение и обработка результата выполнения URL-схемы
Для правильной конвертации HTTP-запроса в URL-схему необходимо хранить на сервере таблицу соответствия и/или заданное правило перевода.
Способов правильно выполнить URL-схему и обработать результат существует несколько. Все зависит от того, из какой среды URL-схема выполняется. Если это происходит в iOS приложении, то существуют стандартные способы проверить, зарегистрирована ли URL-схема в системе:
```
[[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@”myapp://”]];
```
Если же схема выполняется из веб-среды, то оптимально использовать JS-скрипт, который либо запустит приложение, либо отправит на нужный ресурс.
Пример:
```
$(function(){
window.location = 'myapp://';
setTimeout(function(){
window.location = 'fallback.html';
}, 500);
});
```
Если через 500 мс не выполнится переход по схеме “myapp://" (ранее сгенерированная схема), то будет осуществлен переход на “fallback.html”.
Данный скрипт необходимо встроить в ресурс, ответственный за переход.
На GitHub есть несколько более или менее удачных реализаций подобных решений.
###### Обработка полученной URL-схемы и навигация внутри приложения
Эта часть реализации механизма Deep Linking относится исключительно к приложению, которое должно обработать запрос пользователя и перевести его в нужный раздел.
Для этого, в первую очередь, необходимо зарегистрировать собственную URL-схему, которая будет проассоциирована с приложением.
В настройках основного таргета проекта в разделе Info необходимо добавить в пункте URL Types —URL тип вашей схемы (рис 2.)
В поле Identifier необходимо указать bundleID приложения, а в поле URL Schemes — схему, с которой будет связано ваше приложение. Дальше необходимо реализовать механизм навигации в приложении. Для этого надо обработать возможную передачу в приложение URL. Передать её можно многими способами, мы рассмотрим непосредственное исполнение схемы в системе.
Для того чтобы обработать запуск приложения через URL, надо в AppDelegate приложения в методе:
```
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
```
Из словаря `lauchOptions` достать объект по ключу `UIApplicationLaunchOptionsURLKey`. Если объект существует, это означает, что приложение запущено посредством URL-схемы и данную схему можно обработать. Если же приложение запущено в момент исполнения схемы, то URL надо извлекать в том же AppDelegate в методе:
```
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation
```
Здесь необходимо использовать параметр url для дальнейшей навигации. Навигация в приложении — *выбор исключительно личный, но я рекомендовал бы использовать шаблон Router. Во-первых, это не нарушает принцип Single Responsibility, во-вторых, позволит инкапсулировать и в дальнейшем эту навигацию использовать из любого места. Роутер должен принимать в себя URL (как ключ) и выдавать ViewController или же эту навигацию осуществлять.*
#### Сторонние решения
Из сторонних решений можно рассмотреть *Mobile Deeplinking (AppURL, AppLinks, UrbanAirShip и т.д.)*, данные фреймворки являются полноценными решениями для реализации всех компонент технологии Deep Linking. Содержат отдельные библиотеки со своими обработчиками внешних URL и механизмом навигации в приложении. Соответственно, подобные решения требуют интеграции своих SDK в проект.
Отдельно стоит рассмотреть решение, которое не требует интеграции: [*Deep Link Me*](https://deeplink.me) сервис предоставляющий возможность запускать приложение с определенной ссылкой, при этом в случае, если приложение не установлено, совершить редирект в магазин. Все настройки происходят непосредственно на сайте, из возможных опций:
* добавление правил соответствия «HTTP-запрос — URL-схема»;
* переход на альтернативный ресурс, включая магазин приложений;
* поддержка iOS/Android.
Единственное неудобство данного решения в том, что весь транзит происходит через deeplink.me, что несомненно увидит пользователь.
Для использования этого инструмента необходимо реализовать поддержку URL-схем и навигацию в приложении самостоятельно.
#### Новый взгляд на Deep Linking
*Что нам предлагает Google в технологии глубокого связывания.*
Совсем недавно Google стартовал новое направление App Indexing. Конечно, по большей части оно нацелено на Android-разработку и реализовано максимально удобно именно для нее, но и iOS осталась не забыта, правда в ограниченой beta-версии.
Итак:
Помимо работоспособного Deep Linking появилось еще и индексирование приложения в поисковой системе Google. В результате поиска во всемирной сети будут отображаться ссылки на разделы приложения.
Для реализации необходимо:
1. Зарегистрировать еще одну URL-схему в проекте в формате:
`gsd-{scheme}`
где, “scheme” — ваша схема, зарегистрированная выше.
2. Подключить фреймворк GoogleAppIndexing (можно через CocoaPods)
3. В вышеуказанных методах вашего приложения обработать переход следующим образом:
```
NSURL *sanitizedURL = [GSDDeepLink handleDeepLink:url];
```
Это поможет связать ваше приложение c Google App Indexing и создаст панель для возврата в поиск.
4. Необходимо настроить ваш сайт, на который совершается переход. Для этого в хедер сайта надо добавить:
```
...
...
…
```
Также можно дать доступ GoogleBot к вашему сайту для полноценного индексирования.
Все эти способы основаны на работе с URL-схемами. Она давно известна и практикуется. Известны и проблемы, которые могут возникнуть с ними. К примеру, совершенно не определенно поведение, если два разных приложения зарегистрируют одну схему. Также надо обработать альтернативное поведение, если ваше приложение не установлено. В подобных ситуациях вся ответственность ложится на разработчика и ошибки реализации, к сожалению, становятся общей практикой.
*Как избежать подобных ситуаций?*
И вновь Apple нас не разочаровывает — начиная с iOS 9 добавлена поддержка HTTP и HTTPS с прямым переходом в приложение.
В июне 2015 года на WWDC “парни из Купертино” рассказали нам о новом подходе к реализации такого удобного механизма промоутинга мобильного приложения.
Назвали они его Seamless Linking, что можно перевести как “бесшовные ссылки”. Данный механизм позволяет использовать те же самые веб URL, что и при переходе по разделам вашего сайта, кроме того, связь между приложением и веб ресурсом происходит через Bundle ID приложения, что дает этой связи уникальность, также вы можете указать те разделы сайта, которые представлены в вашем мобильном приложении, и Deep Linking будет работать только для них. Ну круто же!!!
#### Как это работает?
Ссылка обрабатывается в системе и из нее извлекается домен (или хост) и непосредственно путь, через который вы можете управлять навигацией в приложении:
`https://n-pizza.com/margarita_new`
n-pizza и является в данном случае доменом. Домен должен быть проассоциирован с приложением посредством специального файла, защищенного SSL-сертификатом, который хранится на сервере сайта. Называться он должен `apple-app-site-association` и содержать специальную JSON структуру.
```
{
"applinks": {
"apps" :[],
"details":{
“123456.npizza.com” :{
"paths": ["*"]
}
}
}
```
Где `123456.npizza.com - app_bundle_id`
`“path” : [“*”]` — говорит о том, что ваше приложение поддерживает все разделы веб-ресурса, в противном случае, вы можете указать, определенные пути:
```
{
"applinks": {
"apps" :[],
"details":{
“123456.npizza.com" :{
"paths": ["/margarita_new",
"/old/greate_pizza/*"]
}
}
}
```
Далее созданный JSON необходимо подписать тем сертификатом, который используется на вашем веб-ресурсе, либо сгенерировать новый (допустимо использовать WildCard сертификат) подписать им JSON и добавить его на сервер. Сертификат, которым подписывается приложение в данном случае не используется.
Важно понимать, что для каждого домена должен быть уникальный `apple-app-site-association` файл
[n-pizza.com/apple-app-site-association](https://n-pizza.com/apple-app-site-association)
В приложении необходимо установить ассоциации с доменами, которые вы поддерживаете в пункте “Associated Domains”, в настройках проекта. А универсальные ссылки необходимо обрабатывать в методе AppDelegate:
```
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray *))restorationHandler
```
Где, тип активности для универсальных ссылок будет:
```
NSUserActivityTypeBrowsingWeb
```
Декомпозировать URL можно будет с помощью нативных средств, таких как: класс
```
NSURLComponents
```
или сторонних фреймворков, как Bolts от Facebook. Далее навигация должна происходить по уже известной схеме, изложенной выше.
В результате пользователь, переходя по ссылке, или оказывается на том ресурсе, куда эта ссылка вела, или в приложении. Огромный плюс этого решения в том, что URL-схемы не используются. Но не меньший минус, что решение только для iOS и только с 9 версии.
#### Контекстные Deep Linking
Все, что написано выше, прекрасно работает и дает необходимый эффект проникновения в приложение, только если приложение уже установлено. Если задуматься, то реальная польза будет для крупных компаний, чьи приложения установлены у большинства пользователей смартфонов, а их не больше 40-50 штук.
Если же приложение не установлено, а таких большинство в AppStore или Google Play, то пользователь окажется на странице сайта, либо в магазине приложений, что тоже не очень хорошо, т.к. после установки и запуска приложения будет показан главный экран. Любой из сценариев равносилен не работающему Deep Linking.
Для достижения полного эффекта работы Deep Linking существуют контекстные глубокие ссылки. Суть их работы заключается в том, что условие перехода в приложение (параметры в URL-схеме), по которому строится дальнейшая навигация, и идентификатор устройства сохраняются на серверной стороне. После установки и запуска приложения, это условие запрашивается и строится навигация. Для пользователя все выглядит аккуратно и бесшовно.
Можно реализовать данный подход совместно с любым вышеуказанным методом. Или воспользоваться готовым решением, встроив SDK. | https://habr.com/ru/post/267587/ | null | ru | null |
# Первые шаги к Web SCADA-системе. Оживляем мнемосхему в браузере с помощью AngularJS
Сегодня мы поговорим об отображении мнемосхем технологических объектов в браузере посредством таких технологий как SVG, JavaScript и т.д.
Опишем, что мы хотим получить:
* Мнемосхема открывается в браузере. Графика – SVG.
* Вверху мнемосхемы кнопки переходов на другие мнемосхемы.
* Данные обновляются раз в секунду.
* По клику на изображение выключателя появляется окно, из которого его можно включить или отключить.
[SCADA-система](http://opc-servers.ru/program/108-soloscada) (точнее её серверная часть) позволяет добавлять пользовательские html-страницы. Я не буду вручную набирать код страницы, а нарисую простую схему в [редакторе](https://habrahabr.ru/post/325640/), потом покажу, что получилось и как это работает.
Вот мнемосхема:
Мощность и ток будут привязаны к переменным `P_10_111` и `I_10_111` соответственно. Включенное состояние выключателя привязано к красному прямоугольнику (он спрятан под зеленый прямоугольник), отключенное к зеленому.
Сохраним схему, перезапустим сервис, откроем в браузере [127.0.0.1](http://127.0.0.1/), получим следующее:
Нажмем Сtrl+u в браузере, увидим исходный код страницы (непривязанные линии опущены):
**Исходный код страницы**
```
SoloSCADA Пример мнемосхемы
var countryApp = angular.module('countryApp', []);
countryApp.controller('CountryCtrl', function ($scope, $http, $interval){
$http.get('all.json').success(function(data) {
$scope.val = data.val;
});
$interval(function(){
$http.get('all.json').success(function(data) {
$scope.val = data.val;
$( "#label\_err" ).text( "" );
}).error(function(data, status) {
console.error('Error occurred:', data, status);
$( "#label\_err" ).text( 'Нет связи с сервером!' );
});
},1000);
});
countryApp.filter('format\_off', function(){
return function(text){
if(text.indexOf("0")===0){
return "1";
}
else{
return "0";
}
}
});
countryApp.filter('format\_on', function(){
return function(text){
if(text.indexOf("1")===0){
return "1";
}
else{
return "0";
}
}
});
444VG
Главная
10 кВ
Пример мнемосхемы
Created with Fabric.js 1.7.3
Мощность:
Ток:
{{val.P\_10\_111}}
{{val.I\_10\_111}}
```
Разберем по порядку:
```
```
подключаем jquery:
подключаем jquery-ui для диалога включить/отключить:
подключаем angularjs:
```
```
подключаем вспомогательный скрипт.
Далее создаём контроллер. Значения переменных берем из файла all.json, его мы запрашиваем с сервера при загрузке страницы и с периодичностью раз в секунду с помощью
```
$interval(function(){ },1000);
```
Если файл all.json запрошен успешно, выполняется:
**Код**
```
$http.get('all.json').success(function(data) {
$scope.val = data.val;
$( "#label_err" ).text( "" );
}).
```
Обновляем данные. Если не успешно, вверху выводим сообщение **Нет связи с сервером!** на `label_err`.
**этим скриптом**
```
.error(function(data, status) {
console.error('Error occurred:', data, status);
$( "#label_err" ).text( 'Нет связи с сервером!' );
});
```
Json-файл должен быть такого формата:
```
{
"val":{
"V_10_111": "0",
"I_10_111": "55.88",
"P_10_111": "9.11"
}
}
```
SVG-файл встраиваем непосредственно в тело страницы:
```
```
В текстовое поле выводим значение переменной I\_10\_111 так:
**спойлер**
```
{{val.I\_10\_111}}
```
Главное здесь это запись `{{val.I_10_111}}.` Angularjs сам ищет такие записи и заменяет их на значение I\_10\_111.
Включенное состояние отображаем красным прямоугольником:
**Включенное состояние**
Свойство opacity зависит от переменной V\_10\_111 с примененным фильтром format\_on. Когда значение равно 1, прямоугольник виден (opacity: 1). Когда значение равно 0, прямоугольник невиден (opacity: 0). Когда состояние неопределённо (это передаётся знаками вопросов в Json-файле «V\_10\_111»: "??") применение фильтра format\_on даёт 0, т.е. прямоугольник невиден.
Отключенное состояние отображаем зеленым прямоугольником:
**Отключенное состояние**
Свойство opacity зависит от переменной `V_10_111` с примененным фильтром `format_off`. Когда значение переменной равно 0, прямоугольник виден (`opacity: 1`). Когда значение равно 1, прямоугольник невиден (`opacity: 0`).
При клике мышкой на прямоугольнике запускается скрипт `tmcontrol('V_10_111','В-10-111')`. Он описан в файле scada.js.
**tmcontrol**
```
function tmcontrol(perem,rusname) {
elem = perem;
$( "#label2" ).text( rusname );
dialog.dialog( "open" );
};
```
`$( "#label2" ).text( rusname );` — текстовая метка на диалоге отображает название элемента, над которым выполняется команда.
`dialog.dialog( "open" );` — показываем диалоговое окно.
**Функция диалогового окна:**
```
$( function() {
dialog = $( "#dialog-confirm" ).dialog({
autoOpen: false,
resizable: false,
height: "auto",
width: 400,
modal: true,
buttons: {
"Включить": function() {
$.post("control.php", elem+'&1');
$( this ).dialog( "close" );
},
"Отключить": function() {
$.post("control.php", elem+'&0');
$( this ).dialog( "close" );
},
"Отмена": function() {
$( this ).dialog( "close" );
}
}
});
$( "#create-user" ).button().on( "click", function() {
dialog.dialog( "open" );
});
} );
```
Для окна используется библиотека jquery-ui. Команду включить передаём на сервер методом post:
```
$.post("control.php", elem+'&1');
```
Команда отключить:
```
$.post("control.php", elem+'&0');
```
Диалоговое окно подключаем в html-файле:
```
```
Пробуем в разных браузерах!
Firefox:
И так:
SVG автоматически масштабируется под разные разрешения экранов и разные размеры экранов браузеров.
Opera:
Internet explorer как обычно преподнёс сюрприз.
Почему так пока не разобрался. Чтобы самостоятельно пощупать пример нужно скачать [SCADA-систему](http://opc-servers.ru/program/108-soloscada), установить её, затем подключить html-файл в конфигураторе. Сам файл положить в папку web\_main. | https://habr.com/ru/post/326330/ | null | ru | null |
# Численные методы решения уравнений эллиптического типа
### Введение
Наиболее распространённым уравнением эллиптического типа является уравнение Пуассона.
К решению этого уравнения сводятся многие задачи математической физики, например задачи о стационарном распределении температуры в твердом теле, задачи диффузии, задачи о распределении электростатического поля в непроводящей среде при наличии электрических зарядов и многие другие.
Для решения эллиптических уравнений в случае нескольких измерений используют численные методы, позволяющие преобразовать дифференциальные уравнения или их системы в системы алгебраических уравнений. Точность решения определяется шагом координатной сетки, количеством итераций и разрядной сеткой компьютера [1]
**Цель публикации** получить решение уравнения Пуассона для граничных условий Дирихле и Неймана, исследовать сходимость релаксационного метода решения на примерах.
Уравнение Пуассона относится к уравнениям эллиптического типа и в одномерном случае имеет вид [1]:
 (1)
где x – координата; u(x) – искомая функция; A(x), f(x) – некоторые непрерывные функции координаты.
Решим одномерное уравнение Пуассона для случая А = 1, которое при этом принимает вид:
 (2)
Зададим на отрезке [xmin, xmax] равномерную координатную сетку с шагом ∆х:
 (3)
Граничные условия первого рода (условия Дирихле) для рассматриваемой задачи могут быть представлены в виде:
 (4)
где х1, xn – координаты граничных точек области [xmin, xmax]; g1, g2 – некоторые
константы.
Граничные условия второго рода (условия Неймана) для рассматриваемой задачи могут быть представлены в виде:
 (5)
Проводя дискретизацию граничных условий Дирихле на равномерной координатной сетке (3) с использованием метода конечных разностей, получим:
 (6)
где u1, un – значения функции u(x) в точках x1, xn соответственно.
Проводя дискретизацию граничных условий Неймана на сетке (3), получим:
 (7)
Проводя дискретизацию уравнения (2) для внутренних точек сетки, получим:
 (8)
где ui, fi – значения функций u(x), f(x) в точке сетки с координатой xi.
Таким образом, в результате дискретизации получим систему линейных алгебраических уравнений размерностью n, содержащую n – 2 уравнения вида (8) для внутренних точек области и уравнения (6) и (7) для двух граничных точек [1].
Ниже приведен листинг на Python численного решения уравнения (2) с граничными условиями (4) – (5) на координатной сетке (3).
**Листинг решения**
```
from numpy import*
from numpy.linalg import solve
import matplotlib.pyplot as plt
x0=0#Начальная координата области решения
xn=5#Конечная координата области решения
n=100#Число точек координатной сетки
dx=(xn-x0)/(n-1)#Задание равномерной координатной сетки с шагом dx
x=[i*dx+x0 for i in arange(0,n,1)]#Задание равномерной координатной сетки с шагом dx
def f(i):#Функция правой части уравнения
return 2*sin(x[i]**2)+cos(x[i]**2)
v1=1.0#Вид ГУ на левой границе (1 - Дирихле, 2 - Неймана)
g1=0.0#Значение ГУ на левой границе
v2=2.0#'Вид ГУ на правой границе (1 - Дирихле, 2 - Неймана)
g2=-0.5#Значение ГУ на правой границе
a=zeros([n,n])#Задание матрицы коэффициентов СЛАУ размерностью n x n
b=zeros([1,n])# Задание матрицы-строки свободных членов СЛАУ размерностью 1 x n
#Определение коэффициентов и свободных членов СЛАУ,
# соответствующих граничным условиям и проверка корректности
#значений параметров v1, v2
b[0,n-1]=g1;
if v1==1:
a[0,0]=1
elif v1==2:
a[0,0]=-1/dx
a[0,1]=1/dx;
else:
print('Параметр v1 имеет неправильное значение')
b[0,n-1]=g2;
if v2==1:
a[n-1,n-1]=1
elif v2==2:
a[n-1,n-1]=1/dx
a[n-1,n-2]=-1/dx;
else:
print('Параметр v2 имеет неправильное значение')
#Определение коэффициентов и свободных членов СЛАУ,
# соответствующих внутренним точкам области
for i in arange(1, n-1,1):
a[i,i]=-2/dx**2
a[i,i+1]=1/dx**2
a[i,i-1]=1/dx**2
b[0,i]=f(i)
u=linalg.solve(a,b.T).T#Решение СЛАУ
def viz(v1,v2):
if v1==v2==1:
return "ГУ Дирихле на левой и ГУ Дирихле на правой границе "
elif v1==1 and v2==2:
return "ГУ Дирихле на левой и ГУ Неймана на правой границе "
elif v2==1 and v2==1:
return "ГУ Неймана на левой и ГУ Дирихле на правой границе "
plt.figure()
plt.title("График функции правой части уравнения Пуассона")
y=[f(i) for i in arange(0,n,1)]
plt.plot(x,y)
plt.grid(True)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.figure()
plt.title("График искомой функции уравнения Пуассона")
plt.xlabel('x')
plt.ylabel('u(x)')
plt.plot(x,u[0,:],label='%s'%viz(v1,v2))
plt.legend(loc='best')
plt.grid(True)
plt.show()
```
Получим:
Разработанная мною на Python программа удобна для анализа граничных условий.Приведенный алгоритм решения на Python использует функцию Numpy — u=linalg.solve(a,b.T).T для решения системы алгебраических уравнений, что повышает быстродействие при квадратной матрице {a}. Однако при росте числа измерений необходимо переходить к использованию трех диагональной матрицы решение для которой усложняется даже для очень простой задачи, вот нашёл на форуме такой пример:
**Пример решения с трёх диагональной матрицей**
```
from __future__ import print_function
from __future__ import division
import numpy as np
import time
ti = time.clock()
m = 1000
A = np.zeros((m, m))
B = np.zeros((m, 1))
A[0, 0] = 1
A[0, 1] = 2
B[0, 0] = 1
for i in range(1, m-1):
A[i, i-1] = 7
A[i, i] = 8
A[i, i+1] = 9
B[i, 0] = 2
A[m-1, m-2] = 3
A[m-1, m-1] = 4
B[m-1, 0] = 3
print('A \n', A)
print('B \n', B)
x = np.linalg.solve(A, B) # solve A*x = B for x
print('x \n', x)
print('NUMPY time', time.clock()-ti, 'seconds')
```
### Программа численного решения на равномерной по каждому направлению сетки задачи Дирихле для уравнения конвекции-диффузии
[2]
 (9)
Используем аппроксимации центральными разностями для конвективного слагаемого и итерационный метод релаксации.для зависимость скорости сходимости от параметра релаксации при численном решении задачи с /(х) = 1 и 6(х) = 0,10. В сеточной задаче:
 (10)
Представим матрицу А в виде суммы диагональной, нижней треугольной и верхней треугольных матриц:
 (10)
**Метод релаксации соответствует использованию итерационного метода**:
 (11)
При \ говорят о верхней релаксации, при  — о нижней релаксации.
**Листинг програмы**
```
from numpy import *
""" Численное решение задачи Дирихле
для уравнения конвекции-диффузии в
прямоугольнике.Метод релаксации."""
def relaxation(b, f, I1, I2, n1, n2, omega, tol = 1.e-8):
h1 = I1 / n1
h2 = I2 / n2
d = 2. / h1**2 + 2. / h2**2
y = zeros([n1+1, n2+1])
ff = zeros([n1+1, n2+1])
bb = zeros([n1+1, n2+1])
for j in arange(1,n2,1):
for i in arange(1,n1,1):
ff [i,j] = f(i*h1, j*h2)
bb[i,j] = b(i*h1, j*h2)
#максимальное число итераций - 10000
for k in arange(1, 10001,1):
rn = 0.
for j in arange(1,n2,1):
for i in arange(1,n1,1):
rr = - (y[i-1,j] - 2.*y [i, j] + y[i+1,j]) / h1**2 \
- (y[i,j-1] - 2.*y [i,j] + y[i,j+1]) / h2**2 \
+ bb[i,j]*(y [i+1,j] - y [i-1,j]) / (2.*h1) - ff [i,j]
rn = rn + rr**2
y[i,j] = y[i,j] - omega * rr / d
rn = rn*h1*h2
if rn < tol**2: return y, k
print ('Метод релаксации не сходиться:')
print ('после 10000 итерации остаток=',sqrt(rn))
import matplotlib.pyplot as plt
bcList = [0., 10.]
sglist = ['-','--']
kk = 0
for bc in bcList:
I1 = 1.
I2 = 1.
def f(x,y):
return 1.
def b(x,y):
return bc
n1 = 25
n2 = 25
m = 20
om = linspace(1., 1.95, m)
it = zeros(([m]))
for k in arange(0,m,1):
omega = om[k]
y, iter = relaxation(b, f, I1, I2, n1, n2, omega, tol=1.e-6)
it[k] = iter
s1= 'b =' + str(bc)
sg = sglist[kk]
kk = kk+1
plt.plot( om,it, sg, label = s1)
plt.title("Число итераций метода релаксации\n для приближённого решения эллиптической задачи\n с использованием заданного параметра релаксации $\\omega$")
plt.xlabel('$\\omega$')
plt.ylabel('iterations')
plt.legend(loc=0)
plt.grid(True)
plt.show(
```
)
Получим:
На графике показана зависимость числа итераций от параметра релаксации для уравнения Пуассона (b(х) = 0) и уравнения конвекции-диффузии (b(х) = 10). Для сеточного уравнения Пуассона оптимальное значении параметра релаксации находится аналитически, а итерационный метод сходиться при .
Выводы:
1. Приведено решение эллиптической задачи на Python с гибкой системой установки граничных условий
2. Показано что метод релаксации имеет оптимальный диапазон () параметра релаксации.
Ссылки:
1. Рындин Е.А. Методы решения задач математической физики. – Таганрог:
Изд-во ТРТУ, 2003. – 120 с.
2. Вабищевич П.Н.Численные методы: Вычислительный практикум. — М.: Книжный дом
«ЛИБРОКОМ», 2010. — 320 с. | https://habr.com/ru/post/418981/ | null | ru | null |
# Антипаттерны деплоя в Kubernetes. Часть 3
Это третья и заключительная часть руководства по **антипаттернам деплоя в Kubernetes**. Советуем также ознакомиться с [первой](https://habr.com/ru/company/timeweb/blog/557320/) и [второй](https://habr.com/ru/company/timeweb/blog/560772/) частями статьи.
Список антипаттернов, которые мы рассмотрим:
1. Использование образов с тегом latest
2. Сохранение конфигурации внутри образов
3. Использование приложением компонентов Kubernetes без необходимости
4. Использование для деплоя приложений инструментов для развёртывания инфраструктуры
5. Изменение конфигурации вручную
6. Использование кubectl в качестве инструмента отладки
7. Непонимание сетевых концепций Kubernetes
8. Использование неизменяемых тестовых окружений вместо динамических сред
9. Смешивание кластеров Production и Non-Production
10. Развёртывание приложений без ограничения ресурсов
11. **Неправильное использование Health Probes**
12. **Вы не используете Helm**
13. **Вы не собираете метрики приложений, позволяющие оценить их работу**
14. **Отсутствие единого подхода к хранению конфиденциальных данных**
15. **Попытка перенести все ваши приложения в Kubernetes.**
11. Неправильное использование Health Probes
--------------------------------------------
В прошлом антипаттерне мы рассказали о необходимости ограничивать ресурсы (limits), доступные приложениям, которые вы переносите в Kubernetes. Также следует настраивать проверки работоспособности ([health probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/)).
По умолчанию приложения, развёрнутые в Kubernetes, не имеют health probes. По аналогии с лимитами вы должны рассматривать проверки работоспособности как неотъемлемую часть конфигурации ваших приложения в Kubernetes. Это означает, что все ваши приложения должны иметь лимиты и проверки работоспособности при развертывании в любом кластере Kubernetes.
Проверки работоспособности определяют, когда ваше приложение готово принимать трафик. Как разработчик, вы должны понимать, как работают health probes в Kubernetes (особенно, на что влияют тайм-ауты для каждой из них).
Типы проверок работоспособности:
1. **Startup probe** => Проверяет начальную загрузку вашего приложения. Запускается только один раз.
2. **Readiness probe** => Проверяет, способно ли ваше приложение принимать подключения. Работает постоянно. Если проверка вернёт ошибку, Kubernetes не будет больше направлять трафик в pod c этим приложением (и попробует выполнить повторную проверку позже).
3. **Liveness probe** => Проверяет работоспособность вашего приложения. Работает постоянно. Если проверка вернёт ошибку, Kubernetes перезапустит контейнер с приложением.
Стоит потратить время, чтобы разобраться, как работает каждый тип проверок доступности.
Несколько распространённых ошибок при использовании health probes:
* Не учитывается состояние внешних сервисов в readiness probe (например, баз данных)
* Используются одинаковые проверки для readiness и liveness probes
* Не учитываете, что приложение запускается в контейнере, а не в виртуальной машине
* Не используются средства проверки доступности вашего [programming framework](http://the%20best%20practices%20for%20your%20programming%20framework) (если они есть)
* Создание слишком сложных проверок работоспособности с неверными интервалами срабатывания (это может привести к отказу в обслуживании других приложений внутри кластера)
* Проверки работоспособности приводят к каскадным сбоям при проверке внешних служб
Появление каскадных сбоев — [очень распространенная проблема](https://blog.colinbreck.com/kubernetes-liveness-and-readiness-probes-how-to-avoid-shooting-yourself-in-the-foot/), которая разрушительна даже для виртуальных машин и балансировщиков нагрузки (т.е. не является специфической для Kubernetes)
Предположим, что у вас есть 3 службы, которые используют службу Auth в качестве зависимости. В идеале liveness probe для каждой службы должна проверять, может ли сама служба отвечать на запросы. Однако, если вы настроите liveness probe для проверки зависимостей, может произойти следующий сценарий:
1. Изначально все 4 сервиса работают корректно (включая Auth)
2. Служба аутентификации начинает работать некорректно
3. Все 3 сервиса определяют, что в работе службы аутентификации возникли проблемы
4. Несмотря на то, что все 3 сервиса работают корректно, результат проверки работоспособности зависит от состояния сервиса Auth
5. Kubernetes запускает liveness probe и решает, что все 4 сервиса не работают, и перезапускает их все (хотя на самом деле только у одного из них возникла проблема)
12. Вы не используете Helm
--------------------------
Сейчас для Kubernetes есть только один менеджер пакетов — Helm. Вы можете рассматривать Helm как аналог утилит apt / rpm для ваших кластеров Kubernetes.
К сожалению, люди часто неправильно понимают возможности Helm и выбирают «альтернативу». Helm — это менеджер пакетов, [который также включает возможности создания шаблонов](https://codefresh.io/docs/docs/new-helm/helm-best-practices/#helm-vs-k8s-templates). Но это не решение для создания шаблонов, и сравнение его с одним из специализированных приложений не совсем верно.
Все решения для шаблонизации имеют одну и ту же проблему. Они могут творить чудеса при развертывании приложений, но после деплоя у вас остаётся только набор манифестов. При этом концепция «приложения» теряется, и ее можно воссоздать, только имея под рукой исходные манифесты.
Helm, с другой стороны, знает обо всем приложении и хранит информацию о нём в кластере. Helm отслеживает ресурсы приложения ПОСЛЕ развертывания. Разница может показаться небольшой, но эти различия очень важны.
Допустим, вы получаете доступ к `kubectl` в кластере с 4 приложениями (каждое из которых состоит из нескольких объектов) в одном пространстве имен. Ваша задача — удалить одно из этих приложений.
Если вы использовали утилиту для создания шаблонов (например, Kustomize), вы не сможете легко понять структуру приложения, глядя на существующие ресурсы. Если у вас нет исходных шаблонов, вам потребуется вручную проверить все объекты с помощью `kubectl` и выполнить корреляцию между компонентами приложения.
Helm отслеживает приложение внутри кластера. Достаточно выполнить команды:
* `helm ls` (чтобы посмотреть список приложений в пространстве имен)
* `helm uninstall my-release` (удалить приложение)
Это удобно! Вам не нужны ни исходные шаблоны, ни доступ к системе CI.
Сравнение Helm с Kustomize / k8compt / kdeploy и другими инструментами для создания шаблонов несправедливо по отношению к Helm, поскольку Helm — это гораздо больше, чем просто решение для создания шаблонов.
Одной из отличных функций Helm является возможность отката к предыдущей версии приложения. Вас будят в 3 часа ночи, и вы хотите выполнить максимально быстрый откат в кластере Kubernetes, с которым вы раньше не работали. У вас просто нет времени на поиск предыдущих версий шаблонов в Git.
Решить эту задачу с Helm очень просто:
1. `helm ls` (вывести список релизов)
2. `helm history my-release` (отобразить историю версий)
3. `helm rollback my-release my-previous-version` (откат к предыдущей версии)
И все это прямо из кластера, потому что Helm знает, что такое приложение в отличие от приложений для шаблонизации, которые останавливают свою работу после завершения развертывания.
Другое заблуждение состоит в том, что пакеты Helm нужно хранить в Git-репозитории. Это не так, чарты Helm должны управляться с помощью [репозиториев Helm](https://helm.sh/docs/topics/chart_repository/). Но вы также можете хранить копию ваших чартов в Git. Главное, чтобы установка Helm-чарта в кластере происходило из репозитория Helm, а не Git.
Также стоит отметить, что, начиная с Helm 3, больше нет серверного компонента (печально известного Tiller), поэтому, если раньше вы сталкивались с проблемами безопасности, вам нужно по-новому взглянуть на Helm без Tiller.
13. Вы не собираете метрики приложений, позволяющие оценить их работу
---------------------------------------------------------------------
В предыдущих антипаттернах мы несколько раз упоминали метрики. Под метриками мы на самом деле подразумеваем:
* **логирование** — для изучения событий и деталей запросов (обычно после инцидента),
* **трассировка** — чтобы отследить маршрут каждого запроса (обычно после инцидента),
* **метрики** — для обнаружения инцидента (желательно проактивно).
Метрики в Kubernetes намного важнее, чем для традиционных виртуальных машинах из-за распределенного характера всех сервисов в кластере (микросервисы). Приложения Kubernetes эфемерны (в отличие от виртуальных машин количество экземпляров приложения в Kubernetes может меняться, отдельные реплики могут пересоздаваться), и вам необходимо контролировать каждое из этих приложений.
Какое решение вы выберете для сбора метрик, не так важно, если оно предоставляет достаточно информации:
* своевременное получение важной информации вместо использования kubectl (см. антипаттерн 6),
* понимание того, как трафик входит в ваш кластер и каково текущее узкое место (см. антипаттерн 7),
* проверка / актуализация ограничений ресурсов приложений (см. антипаттерн 10).
Однако наиболее важная задача — это понять, успешно ли выполнено развертывание. Тот факт, что контейнер запущен, не означает, что ваше приложение находится в рабочем состоянии и может принимать запросы (антипаттерн 11).
В идеале метрики не должны быть чем-то, на что вы смотрите время от времени. Метрики должны быть неотъемлемой частью вашего процесса развертывания. Некоторые организации придерживаются рабочего процесса, при котором показатели проверяются вручную после развертывания, но этот процесс неоптимален. Метрики должны обрабатываться автоматически:
1. Развёртывание приложения
2. Проверка метрик (и сравнение с целевым состоянием)
3. Деплой либо помечается как завершенный, либо выполняется откат. Обратите внимание, что эти действия не выполняются вручную.
Выбор правильных метрик для контроля развёртывания — непростая задача. Однако вы будете знать конечную цель и скоро поймёте, насколько важны метрики для деплоя в Kubernetes.
14. Отсутствие единого подхода к хранению конфиденциальных данных
-----------------------------------------------------------------
Во втором антипаттерне мы объяснили, почему запекание конфигурации в контейнерах — плохая практика. Это еще более актуально для секретов. Если вы используете специализированный сервис для изменения конфигурации, имеет смысл использовать тот же (или аналогичный) сервис для обработки секретов.
Существует несколько подходов к обработке секретов: начиная с хранения в git (в зашифрованном виде) и до внедрения специализированного решения такого, как хранилище Hashicorp Vault.
Некоторые распространенные ошибки:
* использование нескольких способов обработки секретов,
* смешивание runtime secrets и build secrets,
* использование сложных механизмов внедрения секретов, делающих локальную разработку и тестирование трудными или даже невозможными
Здесь важно выбрать стратегию и придерживаться ее. Все команды должны использовать один и тот же метод обработки секретов. Все секреты из всех сред следует хранить одинаково. Это упрощает отслеживание секретов (зная, когда и где был использован секрет).
Вы также должны передавать каждому приложению только те секреты, которые ему действительно нужны.
**Runtime secrets** — это секреты, которые нужны приложению ПОСЛЕ развертывания. Примерами могут служить пароли базы данных, сертификаты SSL и закрытые ключи.
**Build secrets** — это секреты, которые применяются ДО / ВО ВРЕМЯ развёртывания. Примером могут быть учетные данные для вашего репозитория артефактов (например, Artifactory или Nexus) или для хранения файлов в корзине S3. Эти секреты не нужны в производственной среде и никогда не должны отправляться в кластер Kubernetes. Каждое развернутое приложение должно получать только те секреты, которые ему необходимы (и это верно даже для непроизводственных кластеров).
Как мы также упоминали в антипаттерне 3, управление секретами должно осуществляться гибко, чтобы упростить тестирование и локальное развертывание вашего приложения. Это означает, что приложение не должно заботиться об источнике секретов и должно сосредоточиться только на их использовании.
Например, несмотря на то, что Hashicorp Vault имеет [гибкий API](https://www.vaultproject.io/api) для получения секретов и токенов, ваше приложение Kubernetes НЕ должно использовать этот API напрямую для получения необходимой информации. Если вы сделаете это, то тестирование приложения локально превратится в кошмар, поскольку разработчику потребуется локально настроить экземпляр хранилища или имитировать ответы хранилища только для запуска приложения.
15. Попытка перенести все ваши приложения в Kubernetes
------------------------------------------------------
Как и все предшествующие технологии, Kubernetes — это всего лишь инструмент, который решает определенный набор проблем. Если эти проблемы для вас актуальны, вы обнаружите, что внедрение Kubernetes значительно упрощает ваш рабочий процесс и предоставляет вам решение кластеризации, которое отлично спроектировано и поддерживается.
Однако важно понимать преимущества и недостатки внедрения Kubernetes. По крайней мере, сначала гораздо проще использовать Kubernetes для запуска сервисов без сохранения состояния (stateless services), которые будут использовать эластичность и масштабируемость кластера.
Хотя технически Kubernetes поддерживает сервисы с сохранением состояния (stateless services), в самом начале миграции лучше всего запускать такие сервисы вне кластера. Это нормально, если вы храните базы данных, решения для кеширования, репозитории артефактов и Docker образов вне кластера (либо на виртуальных машинах, либо в облачных сервисах).
Не останавливайтесь!
--------------------
Kubernetes — это комплексное решение, требующее особого подхода (сети, хранилище, деплой и т. д.). Процесс деплоя в кластере Kubernetes может значительно отличаться от деплоя на виртуальных машинах.
Вместо того, чтобы пытаться использовать существующие механизмы деплоя, вам следует потратить некоторое время на изучение особенностей деплоя приложений в Kubernetes и не попасть в ловушки, которые мы разобрали в этом руководстве.
Удачных релизов! | https://habr.com/ru/post/561570/ | null | ru | null |
# Использование async и await в C# — лучшие практики
Ключевые слова async и await, введённые в C# 5.0, значительно упрощают асинхронное программирование. Они также скрывают за собой некоторые сложности, которые, если вы потеряете бдительность, могут добавить проблем в ваш код. Описанные ниже практики пригодятся вам, если вы создаёте асинхронный код для .NET приложений.
**Используйте async /await только для тех мест, которые могут длиться «долго»**
Здесь всё просто. Создание `Task` и других структур для управления асинхронными операциями добавляет некоторые накладные расходы. Если ваша операция действительно продолжительна, например выполнение IO запроса, тогда эти расходы в основном не будут заметны. А в том случае, если ваша операция коротка или займёт несколько циклов процессора, тогда возможно будет лучше выполнять эту операцию синхронно.
В целом, команда, работавшая над .NET Framework, проделала неплохую работу по выбору функциональсти, которая должна быть асинхронной. Так, если метод фреймворка заканчивается на `Async` и возвращает задачу, тогда, скорее всего вы должны использовать его асинхронно.
**Предпочитайте async/await вместо Task**
Написание асинхронного кода, используя `async/await`, намного упрощает и сам процесс создания кода, и его чтение, нежели использование задач `Task`.
```
public Task GetDataAsync()
{
return MyWebService.FetchDataAsync()
.ContinueWith(t => new Data (t.Result));
}
```
```
public async Task GetDataAsync()
{
var result = await MyWebService.FetchDataAsync();
return new Data (result);
}
```
В терминах производительности, оба метода, представленные выше, имеют небольшие накладные расходы, но они несколько по-разному масштабируются при увеличении количества задач в них:
* `Task` строит цепочку продолжений, которая увеличивается в соответствии с количеством задач, связанных последовательно, и состояние системы управляется через замыкания, найденные компилятором.
* `Async/await` строит машину состояний, которая не использует дополнительных ресурсов при добавлении новых шагов. Однако компилятор может определить больше переменных для сохранение в стеки машины состояний, в зависимости от вашего кода (и компилятора). В [статье на MSDN](http://msdn.microsoft.com/en-us/magazine/hh456402.aspx) отлично расписаны детали происходящего.
В большинстве сценариев `async/await` будет использовать меньше ресурсов и выполняться быстрее, чем задачи `Task`.
**Используйте уже выполненную пустую статическую задачу для условного кода**
Иногда вы хотите запустить задачу только при каком-то условии. К сожалению, `await` вызовет `NullReferenceException`, если получит `null` вместо задачи, а обработка этого сделает ваш код менее читабельным.
```
public async Task GetDataAsync(bool getLatestData)
{
Task task = null;
if (getLatestData)
task = MyWebService.FetchDataAsync();
// здесь выполним другую работу
// и не забудем проверить на null
WebData result = null;
if (task != null)
result = await task;
return new Data (result);
}
```
Один из способов немного упростить код – использовать пустую задачу, которая уже выполнена. Полученный код будет чище:
```
public async Task GetDataAsync(bool getLatestData)
{
var task = getLatestData ? MyWebService.FetchDataAsync() : Empty.Task;
// здесь выполним другую работу
// task всегда не null
return new Data (await task);
}
```
Убедитесь, что задача является статической и создана как завершённая. Например:
```
public static class Empty
{
public static Task Task { get { return \_task; } }
private static readonly Task \_task = System.Threading.Tasks.Task.FromResult(default(T));
}
```
**Производительность: предпочитайте кэшировать сами задачи, нежели их данные**
Существую некоторые накладные расходы при создании задач. Если вы кэшируете ваши результаты, но потом конвертируете их обратно в задачи, вы, возможно, создаете дополнительные объекты задач.
```
public Task GetContentsOfUrl(string url)
{
byte[] bytes;
if (\_cache.TryGetValue(url, out bytes))
// дополнительная задача создаётся здесь
return Task.Factory.StartNew(() => bytes);
bytes = MyWebService.GetContentsAsync(url)
.ContinueWith(t => { \_cache.Add(url, t.Result); return t.Result; );
}
// это не потокобезоспасно (не копируйте себе этот код как есть)
private static Dictionary \_cache = new Dictionary();
```
Вместо этого будет лучше копировать в кэш сами задачи. В этом случае использующий их код может ждать уже выполненную задачу. В Task Parallel Library присутствуют оптимизации для того, чтобы код ожидающий выполнения уже завершённой задачи [выполнялся быстрее](http://blogs.msdn.com/b/lucian/archive/2011/04/15/async-ctp-refresh-design-changes.aspx).
```
public Task GetContentsOfUrl(string url)
{
Task bytes;
if (!\_cache.TryGetValue(url, out bytes))
{
bytes = MyWebService.GetContentsAsync(url);
\_cache.Add(url, bytes);
}
return bytes;
}
// это не потокобезоспасно (не копируйте себе этот код как есть)
private static Dictionary> \_cache = new Dictionary>();
```
**Производительность: понимайте, как await сохраняет состояние**
Когда вы используете `async/await`, компилятор создаёт машину состояний, которая хранит переменные и стек. Например:
```
public static async Task FooAsync()
{
var data = await MyWebService.GetDataAsync();
var otherData = await MyWebService.GetOtherDataAsync();
Console.WriteLine("{0} = "1", data, otherdata);
}
```
Это создаст объект состояния с несколькими переменными. Смотрите, как компилятор сохранит переменные метода:
```
[StructLayout(LayoutKind.Sequential), CompilerGenerated]
private struct d\_\_0 : <>t\_\_IStateMachine {
private int <>1\_\_state;
public AsyncTaskMethodBuilder <>t\_\_builder;
public Action <>t\_\_MoveNextDelegate;
public Data 5\_\_1;
public OtherData 5\_\_2;
private object <>t\_\_stack;
private object <>t\_\_awaiter;
public void MoveNext();
[DebuggerHidden]
public void <>t\_\_SetMoveNextDelegate(Action param0);
}
```
*Замечание 1.* Если вы декларируете переменную, она сохранится в объекте, хранящем состояние. Это может привести к тому, что объекты будут оставаться в памяти дольше, чем вы бы могли ожидать.
*Замечание 2.* Но если вы не станете декларировать переменную, а использовать значение `Async` вызова вместе с `await`, переменная попадёт во внутренний стек:
```
public static async Task FooAsync()
{
var data = MyWebService.GetDataAsync();
var otherData = MyWebService.GetOtherDataAsync();
// промежуточные результаты попадут во внутренний стек и
// добавятся дополнительные переключения контекстов между await-ами
Console.WriteLine("{0} = "1", await data, await otherdata);
}
```
Вы не должны слишком сильно волноваться по этому поводу до тех пор, пока вы не видите проблем производительности. Если вы всё-таки решили углубиться в оптимизацию, на MSDN есть хорошая статья по этому поводу: [Async Performance: Understanding the Costs of Async and Await](http://msdn.microsoft.com/en-us/magazine/hh456402.aspx).
**Стабильность: async/await – это не Task.Wait**
Машина состояний, генерируемая `async/await` – это не то же самое, что `Task.ContinueWith/Wait`. В общем случае вы можете заменить реализацию с `Task` на `await`, но могут возникнуть некоторые проблемы производительности и стабильности. Давайте посмотрим подробнее.
**Стабильность: знайте свой контекст синхронизации**
Код .NET всегда исполняется в некотором контексте. Этот контекст определяет текущего пользователя и другие значения, требуемые фреймворком. В некоторых контекстах выполнения, код работает в контексте синхронизации, который управляет выполнением задач и другой асинхронной работы.
По-умолчанию, после `await` код продолжит работать в контексте, в котором он был запущен. Это удобно, потому что в основном вы захотите, чтобы контекст безопасности был восстановлен, и вы хотите, чтобы ваш код после await имел доступ к объектам Windows UI, если он уже имел доступ к ним при старте. Заметим, что `Task.Factory.StartNew` – не осуществляет восстановление контекста.
Некоторые контексты синхронизации не поддерживают повторный вход в них и являются однопоточными. Это означает, что только одна единица работы может выполняться в этом контексте одновременно. Примером этого может быть поток Windows UI или контекст ASP.NET.
В таких однопоточных контекстах синхронизации довольно легко получить deadlock. Если вы создадите задачу в однопоточном контексте, и потом будете ждать в этом же контексте, ваш код, который ждёт, будет блокировать выполнение фоновой задачи.
```
public ActionResult ActionAsync()
{
// DEADLOCK: это блокирует асинхронную задачу
// которая ждёт, когда она сможет выполняться в этом контексте
var data = GetDataAsync().Result;
return View(data);
}
private async Task GetDataAsync()
{
// простой вызов асинхронного метода
var result = await MyWebService.GetDataAsync();
return result.ToString();
}
```
**Стабильность: не используйте `Wait`, чтобы дождаться окончания задачи прямо здесь**
Как основное правило – если вы создаёте асинхронный код, будьте осторожны c использованием `Wait`. (c `await` всё несколько лучше.)
Не используйте `Wait` для задач в однопоточных контекстах синхронизации, таких как:
* Потоки UI
* Контекст ASP.NET
Хорошая новость заключается в том, что фреймворк позволяет вам возвращать `Task` в определённых случаях, и сам фреймворк будет ожидать выполнения задачи. Доверье ему этот процесс:
```
public async Task ActionAsync()
{
// этот метод использует async/await и возвращает Task
var data = await GetDataAsync();
return View(data);
}
```
Если вы создаёте асинхронные библиотеки, ваши пользователи должны будут писать асинхронный код. Раньше это было проблемой, так как написание асинхронного кода было утомительным и уязвимым для ошибок, но с появлением `async/await` большая часть сложности теперь обрабатывается компилятором. А ваш код получает большую надёжность, и вы теперь с меньше вероятностью будете вынуждены бороться с нюансами `ThreadPool`.
**Стабильность: рассмотрите использование `ConfigureAwait`, если вы создаёте библиотеку**
Если вы *обязаны* ожидать выполнения задачи в одном из этих контекстов, вы можете использовать `ConfigureAwait`, чтобы сказать системе, что она не должна выполнять фоновую задачу в вашем контексте. Недостатком этого является то, что фоновая задача не будет иметь доступа к тому же самому контексту синхронизации, так что вы потеряете доступ к Windows UI или `HttpContext` (хотя ваш контекст безопасности всё равно будет у вас).
Если вы создаёте «библиотечную» функцию, которая возвращает `Task`, вы, скорее всего, не знаете, как она будет вызываться. Так что, возможно, будет безопаснее добавить `ConfigureAwait(false)` к вашей задаче перед тем как её вернуть.
```
private async Task GetDataAsync()
{
// ConfigureAwait(false) говорит системе, чтобы она
// позволила оставшемуся коду выполняться в любом контексте
var result = await MyWebService.GetDataAsync().ConfigureAwait(false);
return result.ToString();
}
```
**Стабильность: понимайте, как ведут себя исключения**
Когда смотришь на асинхронный код, тяжело иногда сказать, что же случается с исключениями. Будет ли оно передано вызывающей функции, или тому коду, который ждёт выполнения задачи?
Правила в этом случае довольно прямолинейны, но всё равно иногда трудно ответить на вопрос, просто глядя на код.
Некоторые примеры:
* Исключения, вызванные из самого async/await метода, будут отправлены коду, ожидающему выполнения задачи (awaiter).
```
public async Task GetContentsOfUrl(string url)
{
// это исключение будет вызвано на коде, ожидающем
// выполнения этой задачи
if (url == null) throw new ArgumentNullException();
var data = await MyWebService.GetContentsOfUrl();
return data.DoStuffToIt();
}
```
* Исключения, вызванные из делегата задачи `Task`, тоже будут отправлены коду, ожидающему выполнения задачи (awaiter).
```
public Task GetContentsOfUrl(string url)
{
return Task.Factory.StartNew(() =>
{
// это исключение будет вызвано на коде, ожидающем
// выполнения этой задачи
if (url == null) throw new ArgumentNullException();
var data = await MyWebService.GetContentsOfUrl();
return data.DoStuffToIt();
}
}
```
* Исключения, вызванные во время создания Task, будут отправлены коду, который вызывал этот метод (caller) (что, в общем, очевидно):
```
public Task GetContentsOfUrl(string url)
{
// это исключение будет вызвано на вызывающем коде
if (url == null) throw new ArgumentNullException();
return Task.Factory.StartNew(() =>
{
var data = await MyWebService.GetContentsOfUrl();
return data.DoStuffToIt();
}
}
```
Последний пример является одной из причин, почему я предпочитаю `async/await` вместо создания цепочек задач посредством `Task`.
**Дополнительные ссылки** (на английском)
* MSDN: [Async/Await FAQ](http://blogs.msdn.com/b/pfxteam/archive/2012/04/12/10293335.aspx)
* Об оптимизации await “[быстрый путь](http://blogs.msdn.com/b/lucian/archive/2011/04/15/async-ctp-refresh-design-changes.aspx)”
* MSDN: [Await, and UI, and deadlocks! Oh my!](http://blogs.msdn.com/b/pfxteam/archive/2011/01/13/10115163.aspx)
* MSDN: [Async Performance: Understanding the Costs of Async and Await](http://msdn.microsoft.com/en-us/magazine/hh456402.aspx) | https://habr.com/ru/post/162353/ | null | ru | null |
# Вконтакте и Мастер Банк преподнесли мошенникам на блюдечке великолепную уязвимость, связанную с оплатой банковскими картами
Многие знают, что Вконтакте есть возможность пополнять баланс банковскими картами. Прием платежей реализован через процессинг Мастер Банка, и на первый взгляд кажется вполне безопасным. Тут протоколы безопасности SSL и Verified by Visa/MasterCard SecureCode, и заявление, что «Любая информация, переданная на данную страницу, безопасна и защищена специальными средствами.» Но, убеждая нас в безопасности протоколов SSL и Visa/MasterCard, Мастер Банк совсем не позаботился о безопасности собственного протокола.
Протокол, посредством которого торговец формирует платежную транзакцию и отправляет ее на Мастер Банк, позволяет подменить параметры в POST запросе и подставить туда любую желаемую информацию. Пользуясь этим, потенциальный мошенник может создать сайт, на котором он предлагает некоторые услуги, возьмем например пополнение счета мобильного телефона. Мошенник заранее генерирует запросы на оплату картой из своего аккаунта Вконтакте, имея тем самым набор валидных значений ORDER.
Далее он на странице пополнения мобильного телефона своего сайта просит клиента ввести номер мобильного телефона, и перенаправляет его на платежную страницу Мастер Банка, подменяя название, описание мерчанта и сумму нужными значениями, чтобы у клиента не возникало сомнений. Пример подмененного POST запроса на платежную страницу Мастер Банка:
`input type='hidden' name='AMOUNT' value='любая_сумма'
input type='hidden' name='CURRENCY' value='RUB'
input type='hidden' name='ORDER' value='сгенерированное_предварительно_значение'
input type='hidden' name='DESC' value='Пополнение мобильного телефона'
input type='hidden' name='MERCH_NAME' value='Интернет магазин онлайн пополнения'
input type='hidden' name='MERCH_URL' value='http//popolni.mobilnik.online.ru'
input type='hidden' name='MERCHANT' value='710000000837464'
input type='hidden' name='TERMINAL' value='71837464'
input type='hidden' name='EMAIL' value=''
input type='hidden' name='TRTYPE' value='0'
input type='hidden' name='COUNTRY' value=''
input type='hidden' name='MERC_GMT' value='3'
input type='hidden' name='TIMESTAMP' value='текущая дата'
input type='hidden' name='BACKREF' value='vk'`
Таким образом, кардхолдер будет перенаправлен на страницу ввода реквизитов карты.
Надеясь, что раз он находится на доверенном сайте банка, значит и торговцу можно доверять. Средства, будут списаны со счета кардхолдера, а на счет мошенника Вконтакте будут зачислены голоса. Мошенник услугу пополнения мобильного телефона не предоставляет, голоса Вконтакте тратит на рекламу или другие сервисы.
Уязвимость протестирована, как видно, средства были зачислены на счет Вконтакте.
P.S. информация публикуется естественно, после того, как техподдержка Мастер Банка и Вконтакта были проинформированы об уязвимости. От Вконтакта даже получен комментарий, что факт уязвимости мало, но вероятен. | https://habr.com/ru/post/104205/ | null | ru | null |
# RedDwarf (бывший DarkStar) и Unity3D
Для тех кто хочет связать сервер на java RedDwarf (DarkStar):
Используется бесплатная версия Unity.
1. Скачать [плагин на Unity](http://sourceforge.net/apps/trac/reddwarf/attachment/wiki/CommunityClientImplementations/DarkstarSharp.unitypackage) (http://sourceforge.net/apps/trac/reddwarf/attachment/wiki/CommunityClientImplementations/DarkstarSharp.unitypackage). Импортировать в Unity. В ассетах должен появиться «DarkstarSharp».
2. В файле «SimpleSgsProtocol.cs» из папки со скриптами «DarkstarSharp», необходимо изменить версию протокола,
значение VERSION = 0x04; меняем на 0x05;
3. Создаем папку для наших скриптов и создаем в нем csharp скрипт «Messages.cs» следующего содержания:
```
using UnityEngine;
using System;
using System.Text;
using System.Collections;
public class Messages {
public static byte[] encodeString(String s) {
return Encoding.ASCII.GetBytes(s);
}
public static String decodeString(byte[] message) {
return ASCIIEncoding.ASCII.GetString(message);
}
}
```
4. Создаем csharp скрипт «ConnectToRedDwarf.cs» с таким содержимым:
```
using UnityEngine;
using System;
using System.Text;
using System.Collections;
using DarkstarSharp;
public class RedDwarfClient : SimpleClientListener {
private SimpleClient simpleClient;
private ConnectToRedDwarf connectRD;
private String host;
private String username;
public RedDwarfClient(String host, String username, ConnectToRedDwarf connectRD) {
this.host = host;
this.username = username;
this.connectRD = connectRD;
simpleClient = new SimpleClient(this);
}
public void LoggedIn(byte[] reconnectKey){
connectRD.loggedIn();
}
public void LoginFailed(String reason){
connectRD.setStatus("login failed " + username+": "+reason);
}
public void SendMessage(String s){
try {
simpleClient.WriteMessage(Messages.encodeString(s));
} catch (Exception e) {
connectRD.setStatus(e.Message.ToString());
}
}
public void ReceivedMessage(byte[] message){
connectRD.receivedMessage(Messages.decodeString(message));
}
public void Disconnected(bool forced, String message){
connectRD.disconnected(username, message);
}
public PasswordAuthentication GetPasswordAuthentication(){
return new PasswordAuthentication(username, "");
}
public ClientChannelListener JoinedChannel(ClientChannel channel){
return null;;
}
public Boolean login() {
Boolean result = true;
try {
simpleClient.login(host, 62964);
} catch (Exception e) {
connectRD.setStatus("cannot login" + username+": "+e.Message.ToString());
result = false;
}
return result;
}
public void LogOff(){
simpleClient.Logout(false);
}
}
public class ConnectToRedDwarf : MonoBehaviour {
private RedDwarfClient client;
Boolean onConnect = false;
String serverIP = "127.0.0.1";
String clientName = "Unity";
string status = "Not connection";
// Use this for initialization (Выполняется один раз, при запуске)
void Start () {
}
// Update is called once per frame (Выполняется регулярно, каждый раз при отрисовке кадра)
void Update () {
}
void OnGUI() {
if (!onConnect) {
//renderer.material.color = Color.blue;
GUI.BeginGroup(new Rect(Screen.width/2-150, Screen.height/2-200, 300, 400));
GUI.Box(new Rect(0, 0, 300, 400), "Connect to Server");
serverIP = GUI.TextField(new Rect(100,90,100,20), serverIP);
clientName = GUI.TextField(new Rect(100,120,100,20), clientName);
//Подключение к серверу
if (GUI.Button(new Rect(100, 150, 100, 20), "Connect")){
client = new RedDwarfClient(serverIP, clientName, this);
onConnect = client.login();
}
GUI.Label(new Rect(100,180,200,20), status);
//Закрыть окно
if (GUI.Button(new Rect(100, 360, 100, 20), "Close"))
{
}
GUI.EndGroup();
} else {
GUI.BeginGroup(new Rect(Screen.width/2-150, Screen.height/2-200, 300, 400));
GUI.Box(new Rect(0, 0, 300, 400), "Connection Status");
serverIP = GUI.TextField(new Rect(100,90,100,20), serverIP);
clientName = GUI.TextField(new Rect(100,120,100,20), clientName);
if (GUI.Button(new Rect(100, 150, 100, 20), "Drop connection")){
client.LogOff();
onConnect = false;
}
GUI.Label(new Rect(100,180,200,20), status);
//Закрыть окно
if (GUI.Button(new Rect(100, 360, 100, 20), "Close"))
{
}
GUI.EndGroup();
}
}
public void loggedIn(){ // делаем что-то при подключении к серверу
status = "Logined";
}
public void setStatus(String status){ // устанавливаем новое состояние (отображаем в GUI)
this.status = status;
}
public void move(String pos){} // перемещаем наш объект
public void endGame(String game){ // конец игры
status = game;
}
public void disconnected(String username, String message){ // обрыв соединения с сервером
this.setStatus("Lost connection: "+message);
onConnect = false;
}
public void receivedMessage(String msg){
if (msg.StartsWith("MOVE")) {
move(msg);
} else if (msg.StartsWith("END")) {
endGame(msg);
}
}
public void play(){ // логика игры
client.SendMessage("PLAY");
}
}
```
5. В нашей сцене создаем пустой объект и кидаем на него скрипт «ConnectToRedDwarf.cs». Запускаем на выполнение и наблюдем меню где нужно ввести адрес сервера логин. В общем разберетесь)
Послесловие:
Содержимое файла «Messages.cs» взято с официального сайта, и немного подретушировано под сишарп.
Содержимое файла «ConnectToRedDwarf.cs» вычленено с различных источников плюс плод моего воображения.
Спасибо пользователю [dvb](http://habrahabr.ru/users/dvb/) за великолепные статьи [habrahabr.ru/post/129174](http://habrahabr.ru/post/129174/), [habrahabr.ru/post/134812](http://habrahabr.ru/post/134812/)
Проверил, работает. (c#)
Обсуждение на [unity3d.ru/distribution/viewtopic.php?f=14&t=13799&p=100827#p100827](http://unity3d.ru/distribution/viewtopic.php?f=14&t=13799&p=100827#p100827) | https://habr.com/ru/post/170931/ | null | ru | null |
# Абсолютно бесплатный VPN с бесплатного VPS
Думаю про **VPN** слышали все, и многим приходилось им пользоваться. При этом использование готового **VPN**, которым руководит какой - то неизвестный человек, не является хорошей идей. Тем более в России на данный момент пытаются блокировать, как сами **VPN** провайдеры (Windscribe, Proton и другие известные сервисы), так и сами протоколы.
VPN через SSH
-------------
На данный момент **DPI** (Deep packet inspection) умеет блокировать не только конкретные ресурсы, но и протоколы обмена информацией. При этом есть протокол, который вряд ли заблокируют - **SSH**. Блокировка данного протокола невозможна без катастрофических последствий для всей инфраструктуры.
SSH**SSH** (secure shell) - протокол для удалённого управления операционной системы на основе **TCP**. Похож на **telnet**, но все пакеты шифруются, что делает его безопасным.
**SSH** "из коробки" работает с шифрованием, поэтому мы можем не беспокоиться за безопасность своего трафика.
Существуют разные инструменты для реализации **VPN** через **SSH**, я остановлюсь на [sshuttle](https://github.com/sshuttle/sshuttle). Преимущества **sshuttle**:
* не требует ничего от сервера (просто запущенный ssh сервер)
* Работает везде, в том числе **OpenWRT** и Windows (*должно работать*)
* Поддерживает тунелирование **DNS** запросов
VPS
---
Для того, чтобы поднять **VPN** для себя хватит любого самого дешёвого сервера с белым IP. Но мы хотим всё сделать бесплатно, поэтому отбрасываем этот вариант.
Есть Корейский [goorm.io](http://goorm.io), который позволяет внутри докера запускать свой код на различных языках программирования. По сути [repl.it](https://repl.it), но [goorm.io](http://goorm.io) позволяет **официально** запускать ssh сервер из их контейнера, а следовательно предоставляет белый IP адрес.
Goorm.io
--------
Проходим простую регистрацию.
*Кстати goorm.io пропускает для регистрации временные почты.*
РегистрацияДалее переходим в [IDE](https://ide-run.goorm.io), и создаём новый контейнер.
На выбор есть 4 региона расположения сервера (точнее расположения амазоновского инстанса на котором будет запущен ваш контейнер). Нам нужно выбрать ближайший к нам, чтобы пинг был меньше (если вам конечно не принципиально в какой стране у вас будет **VPN**).
Пресет контейнера выбираем "**blank**". Можно ещё выбрать версию убунты в контейнере, правда выбор слишком скромный. Либо *18.04*, либо *16.04*.
Почему только LTS убунтыArch is the best!
Жалко, что в пресете c PyTorch не выдаётся GPU...Остальные настройки оставляем дефолтными. Создаём контейнер и через несколько секунд оказываемся в **ide.**
IDEВ верхнем меню выбираем **Container -> SSH Configuration**
Откроется модал в котором будет команда для подключения по **SSH.**
Можно подключиться через терминал, чтобы автоматически добавить хост в доверенные.
*Состояние контейнера сохраняется после его выключения. Поэтому для себя я создал ещё одного пользователя с удобным для меня паролем и подключаюсь через него.*
SSHUTTLE
--------
В [GitHub репозитории](https://github.com/sshuttle/sshuttle/) есть команды для установки утилиты практически на любую операционную систему. Здесь приведу только пример для лучшего дистрибутива.
```
sudo pacman -S sshuttle
```
После установки выполним следующую команду:
```
sshuttle -r sshuser@IP:PORT -x IP 0/0 -v --dns
```
Вместо **IP** и **PORT** подставляете данные от своего контейнера. Сначала вам потребуется ввести пароль от вашего, локального *root* юзера, а затем пароль от пользователя запущенного контейнера.
Открываем любой определитель **IP** адреса и видим, то, что **IPv4** изменился, а **IPv6** - **нет**
Разработчики **sshuttle** утверждают, что **IPv6** поддерживается, но конкретно у меня - **IPv6 не поменялся**. К сожалению большинство сайтов определяют регион по **IPv6**, в том числе и **DPI** проверяет трафик, идущий через **IPv6**.
Но это можно исправить.
IPv6
----
Возможно есть более удобный способ исправить данную проблему. Моё решение - отключить **IPv6** на стороне браузера, т.е. запретить ему использовать **IPv6** в принципе.
Покажу, как это сделать на примере *Firefox.*Открываем страницу *about:config* и в поиске вводим: `network.dns.disableIPv6`и переключаем его на **"true"**.
После перезапуска браузера видим, что всё работает
Если всё ещё не работаетЕсли всё ещё не работает, то проверьте, не включен ли у вас **QUIC (HTTP/3)**. **QUIC** использует **UDP**, а **sshuttle** не умеет работать с таким трафиком.
И все сайты заблокированные со стороны РФ, так же работают.
Бенчмарк
--------
Контейнер может работать 24/7, если у вас открыта вкладка в браузере с его **ide**. А в платной подписке его можно заставить работать всегда при любых условиях.
Но я не думаю, что кому - то нужен **VPN**, который работает постоянно, даже когда вы не у компьютера.
Для бесплатного **VPN** скорость достаточная. Важно, что она стабильная.
В самом контейнере около 650 мб/cВыводы
------
К сожалению в текущих реалиях, даже платная подписка на *хороший* **VPN** не гарантирует, что он будет работать стабильно, так как его могут в любой момент заблокировать.
Меня полностью устраивает способ, который я изложил в этой статье (сейчас я только им и пользуюсь).
Касательно запуска **OpenVPN** и подобных. У *goorm* есть возможность пробрасывать порты.
Для теста пробросил 2 http портаВремени протестировать **OpenVPN** не было. Он должен запустится и работать, но я не знаю, как к этому отнесётся администрация *goorm.* В правилах про VPN через из контейнеры я ничего не нашёл.
Написано про прокси, но, как причина для блокировки *"высокая нагрузка".* Если будет время, то проверю *OpenVPN*.
Надеюсь, статья была интересная, а главное полезная. | https://habr.com/ru/post/710448/ | null | ru | null |
# Как мы написали сервис уведомлений
Привет, Habr.
В этой статье расскажу, как мы написали систему уведомлений, которая недавно вышла [в VMmanager](https://www.ispsystem.ru/software/vmmanager) (платформа управления виртуализацией серверов). Упор будет на архитектуру системы и детали реализации: какой стек технологий использовали, какие решения принимали и почему, что в итоге получилось. Также расскажу, как устроено динамические обновление данных в нашем [single-page application](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5).
Задача
------
Реализовать сервис уведомлений пользователей о различного рода событиях,
будь то невыполненная задача, превышение порога использования ресурсов или низкий баланс.
Основные требования к сервису:
* Простая интеграция с существующими продуктами компании;
* Умение работать с различными источниками событий;
* Отправка событий в различные каналы (email, интерфейс и мессенджеры).
В результате мы должны получить легкий в использовании фреймворк: достаточно втянуть его в свой проект и написать бизнес-логику необходимых обработчиков на любом удобном языке программирования.
Что мы имеем
------------
Чтобы у читателя возникало меньше вопросов, почему были приняты те или иные решения, немного познакомимся с архитектурой существующих продуктов ISPsystem. А именно — с той частью, которая отвечает за обмен обновлениями между Backend и Frontend.
Схема 1. Обмен обновлениями между BackEnd и FrontEnd
Все наши продукты представляют из себя [single-page application](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), где за динамическое обновление данных отвечает сервис под названием Notifier.
Схема работы следующая (схема 1):
* Пользователь открывает страницу сайта.
* Frontend (FE) через websocket (WS) подписывается на события определенных сущностей у Notifier. В нашем случае происходит подписка на все события виртуальных машин (VM).
* Пользователь создает VM.
* Backend (BE) запускает задачу по созданию VM.
* BE создает уведомление о создании виртуальной машины для Notifier.
* Frontend узнает о новой машине через WS.
* Пользователь в списке виртуальных машин видит новую VM, которая находится в статусе «Устанавливается».
Интересно, что Frontend не просто узнает о случившемся событии, но и получает полную информацию о сущности. Мы просто убрали лишнее звено из цепочки FE:
подписываемся → получаем обновление → д̶е̶р̶г̶а̶е̶м̶ ̶B̶E̶ → отрисовываем объект
При подписке Frontend сообщает Notifier endpoint, который необходимо дернуть при получении обновления. Таким образом, вместе с обновлением FE получает элемент целиком. В результате экономим время на выполнение запроса.
Результат
---------
Схема 2. Итоговый вариант сервиса уведомлений
На схеме 2 мы видим получившийся результат. Давайте разберем его.
### Сервис настроек (alert configurator)
Входная точка, именно сюда будут попадать настройки уведомлений. Это микросервис, в чьи функции входит:
* Принимать настройки, состоящие из ряда обязательных полей и дополнительной информации в произвольном формате.
* Отдавать список настроек по имени конечного алерта.
* И обрабатывать пару-тройку endpoints, отвечающих парадигме [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete).
Формат входных данных:
```
{
"name":"string",
"metric":{},
"channel":{},
"enabled":bool
}
```
**name** — имя конечного алерта для фильтрации.
**metric** — объект, который попадает в конечный алерт неизменным. Он содержит данные в произвольном формате, которые различаются от алерта к алерту.
**channel** — объект с каналами, в которые необходимо отправить уведомления. Каждый канал содержит в себе получателей, будь то chatID для Telegram или список идентификаторов для отправки по email.
**enabled** — поле, отвечающее за активность настройки.
### Обертка конечного алерта (alert wrapper)
Это исполняемый файл, который запускает конечный алерт, читает его поток вывода (stdout) и пишет в поток ввода (stdin). При этом он забирает на себя всю работу с конфигом и сущностями, необходимым для работы нашего алерта, а также отправку сообщений в notice-center.
Давайте рассмотрим основные принципы работы обертки на примере диаграммы последовательности.
Схема 3. Принцип работы alert wrapper
Для старта wrapper на необходим конфигурационный файл и конечный алерт. В конфиг файле описан путь до исполняемого файла алерта и сущности, с которыми он будет работать.
Обертка работает в трех основных потоках:
* **Main** — в нем при старте wrapper мы читаем конфигурационный файл. Запускаем алерт, получая его stdin и stdout. И также запускаем два следующих потока.
* **AlertWatcher** — поток, который получив stdout алерта, будет следить за ним. В случае получения данных они будут обработаны и отправлены в notice center.
* **NotifyWatcher** — поток следящий за обновлением информации в notifier. В случае получения обновлений они будут обработаны и отправлены на stdin алерта.
Зачем так усложнять, спросите вы. Дело в том, что wrapper призван облегчить работу человека или целой команды, которая будет внедрять сервис нотификаций. Тем самым мы решаем основную задачу — простота интеграции. Wrapper берет на себя:
* Отслеживание изменений данных, с которыми работает алерт. Тем самым он обеспечивает консистентность данных между сервисом настроек, панелью и алертом.
* Обработку и отправку сообщений.
Значимой будет возможность написания алерта на любом языке программирования, подходящим под конкретную задачу.Все что остается при написании конечного алерта это:
* Обработать конфиг присланный wrapper’ом stdin.
* Реализовать бизнес-логику самого алерта
* Отдавать на stdout данные в корректном формате
### Notifier
Как я уже рассказывал выше, Notifier выполняет роль поставщика данных, необходимых для полноценной работы обертки и конечного алерта.
Alert wrapper подписывается на обновления:
* Конфигурации (alert configurator);
* Сущности, которую будет обрабатывать алерт (panel);
* Получателей сообщений (panel).
Таким образом поддерживается консистентность данных как внутри wrapper, так и внутри конечного алерта.
### Сервис отправки сообщений (msg sender)
Готовый инструмент, благодаря которому наши панели рассылают почту на email пользователям. По первоначальной задумке его было необходимо научить отправлять сообщения не только по почте, но и в любой необходимый канал: telegram, slack или интерфейс панели. Но впоследствии было принято решение об обязательном уведомлении пользователя в интерфейсе, так между alert wrapper и msg sender появился центр уведомлений.
### Центр уведомлений (notice center)
Cервис, отвечающий за хранение, пересылку и показ уведомлений пользователю.
* **Хранение**. Полученные уведомления от wrapper сохраняются, чтобы пользователь имел возможность ознакомится с их историей.
* **Показ**. При получении уведомления notice center показывает его пользователю в виде push-сообщения. Если пользователь перешел по нему, мы помечаем уведомление как прочитанное.
* **Пересылка**. Если предыдущее условие не было выполнено, то через определенный интервал времени сообщение будет передано в msg sender и отправлено по необходимому каналу.
Получившийся сервис — это дополнительный канал связи с пользователем, единая точка хранения всех уведомлений и шлюз сообщений, частично разгрузгружающий msg sender.
Заключение
----------
В результате мы получили рабочий сервис отправки уведомления пользователям. При этом отдельные его части можно использовать вне контекста alert+wrapper, можно напрямую отправлять сообщения в центр нотификации. Msg sender можно и дальше расширять, добавляя поддержку различных каналов.
Буду рад обсудить архитектуру сервиса в комментах. | https://habr.com/ru/post/504934/ | null | ru | null |
# Путь от стажера до junior Data Scientist
Хочу сделать небольшую серию статей в первую очередь для начинающих специалистов в Data Science, к которому они смогли бы обращаться, когда необходимо что-то вспомнить при решении задач или подготовиться к собеседованию.
Начнем с того, какой минимум необходимо знать стажеру. Список может быть более широким, но все в первую очередь зависит от задач, которых вам будет ставить руководитель.
Постараюсь подытожить все темы, которые, как, мне кажется, необходимы специалисту для того, чтобы удачно начать выполнять работу и сделаю акцент на тех темах, в которых самой пришлось попотеть, чтобы разобраться.
Для того, чтобы показать, как работают функции и методы буду использовать всеми используемый [датасет на kaggle](https://www.kaggle.com/datasets/brendan45774/test-file).
Импорт и экспорт данных
-----------------------
Pandas — одна из самых популярных библиотек Python для аналитики и работы с Data Science. Первое с чего следует начать это импортировать данную библиотеку:
```
import pandas as pd
```
Считывать данные предстоит различных форматов и то, как это можно сделать существует множество способов, но часто хватает функции read\_csv с ее параметрами (sep - разделитель (по умолчанию ','), names - список имен столбцов):
```
df = pd.read_csv("titanic.csv")
df
```
Для того, чтобы выводить не весь DataFrame, а только часть, можно использовать следующие приемы:
```
Вывод первых 5 строк - df.head()
Вывод последних 5 строк - df.tail()
Вывод 5 случайных строк - df.sample(5)
```
Немного забегая вперед, посмотрим на то, как экспортировать обработанные данные в Excel:
```
df.to_excel('df_data.xlsx', sheet_name = 'sheet1', index = False)
```
Настроим вывод таблицы
----------------------
С помощью **pd.set\_option** настроим вывод DataFrame:
* количество строк в таблице было не больше 10;
* текст в ячейке отражался полностью вне зависимости от длины;
* все числа отражались с двумя знаками после запятой;
```
pd.set_option('max_rows', 10)
pd.set_option('display.max_colwidth', None)
pd.set_option('display.float_format', '{:.2f}'.format)
```
Если нужно вернуть настройки к изначальным, используем: **pd.reset\_option('all').**
Предпросмотр данных
-------------------
Полезные методы, которые вы можете использовать, для того, чтобы посмотреть на размер данных, названия признаков и их типы:
```
df.shape
df.columns
df.dtypes
df.info()
df.describe()
```
Метод info( ) - показывает информацию о наборе данных, индекс, столбцы и тип данных, ненулевые значения и использование памяти.
Метод describe() показывает количество строк в столбце, среднее значение столбца, столбец стандартное отклонение , минимальные (min) и максимальные (max) значения, а также границу каждого квартиля - 25%, 50% и 75%. Любые значения NaN автоматически пропускаются. По умолчанию, метод describe( ) пропускает строки и столбцы не содержащие чисел - категориальные признаки. Чтобы посмотреть статистику по нечисловым признакам, нужно явно указать интересующие нас типы в параметре **include**. Можно также задать **include = 'all'**, чтоб вывести статистику по всем имеющимся признакам.
Работа с пропущенными значениями
--------------------------------
Есть два метода обнаружения недостающих данных: isnull() и notnull().
Результатом является логическое значение, указывающее, действительно ли значение, переданное в аргумент, отсутствует. «Истина» означает, что значение является отсутствующим значением, а «Ложь» означает, что значение не является отсутствующим.
```
df.isnull().sum()
```
Пропущенные значения можно также заполнить средними значениями, медианами, нулями и т. д. в зависимости от вашей задачи:
```
df['Age'].fillna(df['Age'].mean(), inplace = True)
```
Если один из признаков при исследовании вам оказался незначим, его можно удалить следующим образом:
```
df.drop(['Cabin'], axis = 1, inplace = True)
```
Важно с какими видами данных работаете (категориальные, порядковые, числовые)
-----------------------------------------------------------------------------
1. Категориальные данные представляют собой характеристики (пол человека, язык и т.д.).
2. Порядковые данные представляют собой дискретные и упорядоченные единицы. Используются для измерения нечисловых характеристик, таких как счастье, удовлетворенность клиентов и так далее.
3. Числовые данные, которые делятся на:
3.1. Дискретные данные представляют собой различные и разделенные значения. Этот тип данных не может быть измерен, но он может быть подсчитан.
3.2. Непрерывные данные, также, как и дискретные данные представляют собой различные и разделенные значения. Но тип данных может быть измерен, но он не может быть подсчитан. Примером может служить рост человека.
3.3. Интервальные данные представляют упорядоченные единицы, которые имеют одинаковую разницу.
Работа с категориальными данными
--------------------------------
Кодирование категориальных признаков - процедура, которая представляет собой некоторое преобразование категориальных признаков в численное представление. Рассмотрим два самых распространенных способа кодирования.
**Label Encoder**
Данный тип представляет собой однозначное соответствие число и уникальное значение.
Первое значение кодируется нулем, второе единицей, и так далее.
```
from sklearn.preprocessing import LabelEncoder
labelencoder = LabelEncoder()
```
Для того, чтобы посмотреть на закодированные значения необходимо использовать метод classes\_.
**One-Hot Encoder**
Данный тип кодирования, основывается на создании бинарных признаков, которые показывают принадлежность к уникальному значению.
```
from sklearn.preprocessing import OneHotEncoder
onehotencoder = OneHotEncoder()
```
Нормализация, стандартизация, масштабирование
---------------------------------------------
MinMaxScaler, RobustScaler, StandardScaler, и Normalizer это методы, которые помогут нам подготовить данные для машинного обучения.
**MinMaxScaler**
Из каждого значения признака, MinMaxScaler вычитает минимальное значение признака и делит на диапазон. MinMaxScaler сохраняет форму исходного распределения. Он не меняет содержательно информацию содержащуюся в исходных данных. Диапазон значений после признака находится между 0 и 1. Если хотите легкого преобразования, используйте его.
```
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
```
**RobustScaler** преобразует вектор признака вычитая медиану и деля на межквартильный размах.
Используйте RobustScaler если вы хотите **уменьшить эффект от выбросов** по сравнению с MinMaxScaler.
```
from sklearn.preprocessing import RobustScaler
transformer = RobustScaler()
```
**StandardScaler** стандартизирует признак вычитая среднее и затем масштабируя к единичной дисперсии. В результате применения StandardScaler мы получаем распределение со стандартным отклонением равным 1.
```
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
```
**Normalizer** работает на строках, не на столбцах и к каждому наблюдению применяет L2 нормализацию, чтобы значения в строке имели единичную норму. Normalizer преобразует все признаки в значения между -1 и 1.
```
from sklearn.preprocessing import Normalizer
transformer = Normalizer()
```
Разделение датасета на обучающую, тестовую выборку
--------------------------------------------------
```
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.33, random_state=42)
```
Параметры:
1. test\_size - представляет долю набора данных для включения в тестовое разделение.
2. random\_state - управляет перетасовкой, применяемой к данным перед применением разделения. Передайте int для воспроизводимого вывода через несколько вызовов функций.
Замечания:
1. train\_test\_split по умолчанию автоматически перемешивает данные;
2. Стратификацию (равномерное распределение) классов мы можем задать при разделении с помощью параметра stratify. Стоит стратифицировать по классам c y;
3. Если вы хотите использовать датасеты для тестирования и валидации, разделяем весь набор данных один раз для выделения обучающей выборки. Затем еще раз, чтобы разбить оставшиеся данные на датасеты для тестирования и валидации.
Полностью раскрыть каждую тему довольно сложно в одной статье, но и этих знаний хватит для того, чтобы подготовиться к обучению первой модели :) | https://habr.com/ru/post/684998/ | null | ru | null |
# Использование лямбда-выражений в необобщённом коде C++
Появившиеся в C++11 лямбды стали одной из самых крутых фич нового стандарта языка, позволив сделать обобщённый код более простым и читабельным. Каждая новая версия стандарта C++ добавляет новые возможности лямбдам, делая обобщённый код ещё проще и читабельнее. Вы заметили, что слово «обобщённый» повторилось дважды? Это неспроста – лямбды действительно хорошо работают с кодом, построенным на шаблонах. Но при попытке использовать их в необобщённом, построенном на конкретных типах коде, мы сталкиваемся с рядом проблем. Статья о причинах и путях решения этих проблем.
Вместо введения
---------------
Для начала определимся с терминологией: *лямбдой* мы называем *lambda-expression* – это выражение C++, определяющее объект замыкания (*closure object*). Вот цитата из стандарта C++:
> [[expr.prim.lambda.general]](https://eel.is/c++draft/expr.prim.lambda#general-2)
> A *lambda-expression* is a prvalue whose result object is called the *closure object*.
> [*Note 1*: A closure object behaves like a function object. — *end note*]
>
>
Тип объекта замыкания – это уникальный безымянный класс.
> [[expr.prim.lambda.closure]](https://eel.is/c++draft/expr.prim.lambda#closure-1)
> The type of a lambda-expression (which is also the type of the closure object) is a unique, unnamed non-union class type, called the closure type, whose properties are described below.
>
>
«*Безымянный*» в данном случае означает, что тип замыкания нельзя явно указать в коде, но получить его можно, чем мы ниже будем активно пользоваться. «*Уникальный*» означает, что каждая лямбда порождает новый тип замыкания, т. е. две абсолютно одинаковые с синтаксической точки зрения лямбды (будем называть такие лямбды однородными) имеют разные типы:
```
auto l1 = [](int x) { return x; };
auto l2 = [](int x) { return x; };
static_assert(!std::is_same_v);
```
Аналогично этот принцип распространяется и на обобщённый код, зависящий от типов замыканий:
```
template
class LambdaDependent {
public:
explicit LambdaDependent(Func f) : f\_{f} {}
private:
Func f\_;
};
LambdaDependent ld1{l1};
LambdaDependent ld2{l2};
static\_assert(!std::is\_same\_v);
```
Это свойство не позволяет, например, складывать объекты замыканий в контейнеры (например, в **std::vector<>**).
Стандартные решения
-------------------
Стандарт языка предоставляет готовое решение этой проблемы в виде **std::function<>**. Действительно, объект **std::function<>** может оборачивать однородные лямбды:
```
std::function f1{l1};
std::function f2{l2};
static_assert(std::is_same_v);
```
Такое решение действительно решает большинство проблем, однако подходит далеко не во всех случаях. Из объекта **std::function<>** нельзя получить сырой указатель на функцию, чтобы передать его, например, в какое-нибудь legacy API. Допустим, у нас есть функция:
```
int api_func(int(*fp)(int), int value) {
return fp(value);
}
```
Интересно, что если мы попробуем передать в эту функцию любую из объявленных выше лямбд (**l1** или **l2**), то код замечательно скомпилируется и запустится:
```
std::cout << api_func(l1, 123) << '\n'; // 123
std::cout << api_func(l2, 234) << '\n'; // 234
```
Так получается потому, что лямбда с пустым замыканием (их ещё называют лямбды без состояния) по стандарту может быть неявно преобразована в указатель на функцию:
> [[expr.prim.lambda.closure]](https://eel.is/c++draft/expr.prim.lambda#closure-7)
> The closure type for a non-generic *lambda-expression* with no *lambda-capture* whose constraints (if any) are satisfied has a conversion function to pointer to function with C++ language linkage having the same parameter and return types as the closure type's function call operator. The conversion is to “pointer to noexcept function” if the function call operator has a non-throwing exception specification. The value returned by this conversion function is the address of a function *F* that, when invoked, has the same effect as invoking the closure type's function call operator on a default-constructed instance of the closure type. *F* is a constexpr function if the function call operator is a constexpr function and is an immediate function if the function call operator is an immediate function.
>
>
Для обобщённого кода можно применить явный **static\_cast<>**:
```
LambdaDependent lf1{static_cast(l1)};
LambdaDependent lf2{static\_cast(l2)};
static\_assert(std::is\_same\_v);
```
Есть простой синтаксический трюк, позволяющий не писать громоздкий **static\_cast<>** и не указывать явно сигнатуру функции:
```
LambdaDependent ls1{+l1};
LambdaDependent ls2{+l2};
static_assert(std::is_same_v);
```
Этот трюк работает из-за того, что унарный оператор + имеет встроенную перегрузку для любого типа.
> [[over.built]](https://eel.is/c++draft/over.built#9)
> For every type *T* there exist candidate operator functions of the form
> `T* operator+(T*);`
>
>
Такая перегрузка, применённая к объекту замыкания, вызывает неявное преобразование к указателю на функцию, что аналогично явному **static\_cast<>**.
Лямбды с состоянием
-------------------
Описанный выше трюк отлично работает для лямбд с пустыми замыканиями, но как быть, если нужно передать лямбду с состоянием? Классический приём из старого доброго C – передавать указатель на функцию и указатель на контекст типа **void\***. Функция получает этот указатель, преобразовывает его к указателю на нужный тип и получает доступ к контексту.
```
int api_func_ctx(int(*fp)(void*, int), void* ctx, int value) {
return fp(ctx, value);
}
```
Попробуем передать лямбду с состоянием в такую функцию:
```
int counter = 1;
auto const_lambda = [counter](int value) {
return value + counter;
};
std::cout << api_func_ctx([](void* ctx, int value) {
auto* lambda_ptr = static_cast(ctx);
return (\*lambda\_ptr)(value);
}, &const\_lambda, 123) << '\n'; // 124
```
Здесь мы задаём новую лямбду, уже без состояния, которая неявно преобразуется в указатель на функцию. Эта лямбда получает контекст типа **void\***, преобразует его к указателю на тип замыкания, разыменовывает и вызывает как обычный функциональный объект. Кстати, это работает и с **mutable** лямбдами:
```
auto mutable_lambda = [&counter](int value) mutable {
++counter;
return value * counter;
};
std::cout << api_func_ctx([](void* ctx, int value) {
auto* lambda_ptr = static_cast(ctx);
return (\*lambda\_ptr)(value);
}, &mutable\_lambda, 123) << ':' << counter << '\n'; // 246:2
```
Кажется, всё уже отлично работает. Но писать лямбду руками при каждом вызове **api\_func\_ctx** утомительно, хочется всё это обобщить и завернуть в красивую обёртку.
Наводим красоту
---------------
Технически для того, чтобы сохранить лямбду с состоянием, а потом восстановить её, достаточно 2х объектов:
* контекст типа **void\*** (это классический пример *type erasure*);
* указатель на функцию, принимающую контекст и все параметры лямбды и возвращающую такой же тип.
Назовём тип для хранения «разобранного» объекта замыкания **closure\_erasure**:
```
template
struct closure\_erasure {
Ret(\*func)(void\*, Args...);
void\* ctx;
};
```
Тут возникает проблема: как из типа замыкания выудить тип возвращаемого значения и параметров? На помощь нам приходит [CTAD](https://habr.com/en/post/461963/) – этот тип может выводиться из типа параметра конструктора. Но что такого можно передать в конструктор от лямбды, из чего можно вывести все необходимые типы? Компилятор определяет для типа замыкания **operator()**, позволяющий вызывать объект замыкания как функциональный объект. Сигнатура этого оператора как раз и содержит всю необходимую информацию:
```
template
explicit closure\_erasure(Ret(Lambda::\*)(Args...), void\* ctx) :
func{
[](void\* c, Args ...args) {
auto\* lambda\_ptr = static\_cast(c);
return (\*lambda\_ptr)(std::forward(args)...);
}
},
ctx{ctx} {}
template
explicit closure\_erasure(Ret(Lambda::\*)(Args...) const, void\* ctx) :
func{
[](void\* c, Args ...args) {
auto\* lambda\_ptr = static\_cast(c);
return (\*lambda\_ptr)(std::forward(args)...);
}
},
ctx{ctx} {}
```
Два конструктора отличаются только **const** в типе указателя на метод класса – это нужно для того, чтобы можно было оборачивать и обычные (константные), и **mutable** лямбды.
Остался последний шаг: обернуть создание обёртки в удобную функцию, чтобы не нужно было вручную извлекать указатель на **operator()** из типа замыкания:
```
auto make_closure_erasure = [](auto& lmb) {
return closure_erasure{
&std::remove_reference_t::operator(), &lmb};
};
```
Обратите внимание, что мы принимаем объект замыкания по неконстантной ссылке. Это важный момент, который намекает на важное ограничение применяемого механизма: мы несём ответственность за время жизни объекта замыкания!
Если мы ещё вспомним, что функция и лямбда может быть ещё **noexcept**, то финальная версия обёртки будет выглядеть так:
```
template
struct closure\_erasure {
Ret(\*func)(void\*, Args...) noexcept(NoExcept);
void\* ctx;
template
explicit closure\_erasure(Ret(Lambda::\*)(Args...) noexcept(NoExcept), void\* ctx) :
func{
[](void\* c, Args ...args) noexcept(NoExcept) {
auto\* lambda\_ptr = static\_cast(c);
return (\*lambda\_ptr)(std::forward(args)...);
}
},
ctx{ctx} {}
template
explicit closure\_erasure(Ret(Lambda::\*)(Args...) const noexcept(NoExcept), void\* ctx) :
func{
[](void\* c, Args ...args) noexcept(NoExcept) {
auto\* lambda\_ptr = static\_cast(c);
return (\*lambda\_ptr)(std::forward(args)...);
}
},
ctx{ctx} {}
};
auto make\_closure\_erasure = [](auto& lmb) {
return closure\_erasure{
&std::remove\_reference\_t::operator(), &lmb};
};
auto li = make\_closure\_erasure(const\_lambda);
std::cout << api\_func\_ctx(li.func, li.ctx, 123) << '\n'; // 124
li = make\_closure\_erasure(mutable\_lambda);
std::cout << counter << ':' <<
api\_func\_ctx(li.func, li.ctx, 123) << '\n'; // 2:369
std::cout << counter << ':' <<
api\_func\_ctx(li.func, li.ctx, 123) << '\n'; // 3:492
```
Интересные ссылки
-----------------
1. [Compiler Explorer с кодом из статьи](https://godbolt.org/z/hc4GYj5Ye)
2. [Книга про лямбды "C++ Lambda Story"](https://leanpub.com/cpplambda)
3. [Back to Basics: Lambdas from Scratch - Arthur O'Dwyer - CppCon 2019](https://www.youtube.com/watch?v=3jCOwajNch0)
4. [C++ Weekly - Ep 246 - (+[](){})() What Does It Mean?](https://www.youtube.com/watch?v=fYd84StM5OI)
5. [Текущий черновик стандарта C++](https://eel.is/c++draft/)
Большое спасибо [Валерию Артюхину](https://habr.com/ru/users/ikshot/) за корректуру. | https://habr.com/ru/post/548938/ | null | ru | null |
# Теория правильных скриптов
Чем различается скрипт и программа? Вовсе не используемым языком или наличием интерфейса.
Главная разница — в наличии у программы обширнейшей оболочки, не связанной «содержимым» программы. В зависимости от платформы, это могут быть страницы руководства, поддержка нескольких языков, наличие функционала по установке/удалению, исполнение соглашений об интерфейсе (командной строки, или иных средств взаимодействия), интерфейсы в общем реестре и т.д… Программа должна уметь работать в любой документированной среде, предусматривать различные ситуации (круче всего с этим у программ под unix, которые используют ./configure для определения, собственно, где они, что можно, а что нельзя на этой (очередной) платформе).
Скрипт же, в строго обратном смысле: он предназначен для решения конкретной проблемы «здесь и сейчас». Никто не ожидает от скрипта, который отсылает статистику, способности делать это одновременно на solaris'е, freeBSD и windows embedded standard с cygwin'ом на борту.
По математико-программистким представлениям, между скриптами администрирования и программами нет разницы. Они работают по одинаковым принципам, вообще говоря, выполняют почти одно и то же.
Разница между скриптом и программой — *административная*.
Практически любая программа имеет в себе ТРИ важные составляющие:
* Нетривиальный алгоритм.
* Техподдержку, наработанные лучшие практики использования, типовые схемы внедрения и готовые конфигурации.
* Правильную интеграцию в рабочую среду в любой разрешённой (документированной) конфигурации.
Давайте подробнее об этих составляющих…
1) Алгоритм. У любой программы есть во-первых некая идея (что, собственно, делает программа), во-вторых — обвязка. Чтение конфигов, вывод в сислог, оповещение по почте и ещё тысяча не связанных с основной задачей операций. Но программу используют не ради чтения конфигов и записи в лог, а ради того, что она ДЕЛАЕТ. Соответственно, обычно идея заключается в выполнении каких-то действий по какому-то алгоритму. Нетривиальная идея. В фактическом коде это может быть меньше, чем чтение xml-конфига, но при этом именно рабочий алгоритм — суть программы. Он может быть или «обрабатывающим данные» (вроде SQL'я), или математическим (вроде md5sum), или работающим с конкретными особенностями конкретной железки (формата файла) — но он всегда требует высокой квалификации в предметной области для адекватного понимания принципов работы. Понятно, что код OpenSSL может читать любой программист. Понятно, что алгоритм работы OpenSSL может понять только хороший математик.
Но мы пишем не о программах — о скриптах. Так вот, скрипт не должен реализовывать нетривиальные алгоритмы. Если вы у себя в скрипте пишите аналог base64 — это плохой скрипт. Если вы у себя в скрипте пишите отправку сообщений по smtp методом «открыли сокет, записали» — это омерзительный скрипт. Если вы у себя в скрипте ловите данные с ком-порта и пишите туда ответ (для управления УПСом) — это писец какой-то, а не скрипт.
Скрипт НЕ ДОЛЖЕН содержать в себе алгоритма в терминах «предметной области». У скрипта нет предметной области, скрипт — обвязка вокруг программ, которые уже работают с предметными областями. В некоторых случаях скриптовый язык может предоставлять весь инструментарий:
```
if md5.md5sum (open.($check).read() ) != url.openurl($control).read():
smtp.sendmail($from, $to, "data check failed", "md5sum of $check does not match control sum form $contol.").
```
Это скрипт. Просто скрипт. Не смотря на то, что он реализует офигенный объём работы. А вот если у вас md5 — класс, объявленный в скрипте 5 строчками выше с имплементацией md5 (или url, или open, или smtp, etc) — это уже потуга на программу. Но программа — это много сложнее, чем алгоритм, её составляющий — и подобное не должно реализовываться в скриптах. НИКОГДА.
2) Любая программа должна обладать известным поведением. Математики предлагают описывать поведение программы в всеобъемлющих терминах; практика же говорит, что обычно кроме алгоритма программа ещё содержит баги и фичи, которые влияют на её поведение, к которым надо адаптироваться. Адаптироваться к ним куда проще, когда есть некоторая практика использования программы.
«KDC has been valid once but invalid now» — если это сообщение от скрипта — всё, хоронить. Прямо тут, на месте. У программы это вполне разумное сообщение по которому можно гуглить и выяснять, что именно не так. Это прямое следствие наличия в программе некой предметной логики, специфичной и требующей от пользователей не изучать её насквозь, а принять бехивиористически. То бишь как набор утверждений о поведении программы. «Данная версия программы не понимает файлы больше 2Гб в размере». Это не укладывается в алгоритм (а если уложится — будет занимать этак с том дискретной математики) — но это нужно знать в практическом смысле. «Данная программа плохо себя ведёт в условиях симметричной нагрузки на аплоад/даунлоад, лучше запустить две копии, каждая из которых будет работать в свою сторону симметрично» — понимание \_ПОЧЕМУ\_ потребует титанических усилий, проще принять это как данность. Чем сложнее алгоритм, тем больше жизни нужно потратить на его исследование, адаптацию и глубокое изучение. На всё жизни не хватит, значит, проще принять как данное и сконцентрироваться на важном.
Скрипт же, обратно, должен быть кристально понятен каждому, кто его посмотрит (с поправками на знание скриптового языка). Никаких `(if every in self.__datarange__ is not in any map(__systable__.lang, __localtable__.map, lambda (a,b):[a in b or b in a for every __sys__.pair(a,b)])) raise "Missed i18n constitution".`
3) Скрипт решает задачу \_ЗДЕСЬ\_И\_СЕЙЧАС\_. Программа решает задачу \_ТАМ\_И\_ВСЕГДА\_ (с поправкой на опыт эксплуатации из п.2). Когда вы пишите скрипт, вы делаете так, чтобы оно работало в вашей системе. Оно не годится для свободного использования в других системах (хотя может быть ЛЕГКО (см п.1) адаптировано). Программа должна быть адаптируема к куче вариантов применения, реализация этой адаптации в скрипте приводит к потере его простоты и превращению его, собственно, в программу. Кроме того (увы и ах), но знание КАК ПРАВИЛЬНО писать программу не эквивалентно написанию правильного алгоритма. Вы можете написать потрясающую библиотеку, но если вы не сможете запустить её на машине, у которой понедельник первый день недели (или второй — кому как повезёт), то грош цена вашей библиотеке. Необходимость думать об этом — это уже написание программ — скрипту такое допустимо (хотя и не желательно).
Ну и ещё важное отличие между скриптами и программами. Программы (в форме библиотек) могут «наслаиваться» друг на друга. Этой программе нужен libYYY, которая использует libZZZ и libAAA, при этом libAAA использует libZZZ и libc. Это нормально.
Скрипты же НЕ ДОЛЖНЫ ЗАВИСЕТЬ ДРУГ ОТ ДРУГА. Ситуация, когда скрипт зависит от сервисов другого скрипта, который зависит от третьего — ненормальная.
Заметим, речь идёт о зависимости. Вполне можно представить себе скрипт, который вызывает другие скрипты и выдаёт обобщённый результат по ним, но это уже грань. Чуть сложнее (например, «запустить скрипт А если скрипт Б не отработал») — уже за гранью фола. Нехорошо. А если скрипт А не отработал но не сообщил об этом? Или чуть-чуть отработал, но потом отвалился так, что скрипту Б не получится доделать (а мы, как авторы скрипта А, и подумать не могли о подобном)?
Что же вообще должен делать хороший скрипт? Сращивать несколько программ в конкретную систему. Можете считать программы за детали конструктора. А сам конструктор — за скрипт. Вам НЕ СЛЕДУЕТ нарезать винтовую нарезку на шпинделе — возьмите шпиндель с нарезкой. Вам не следует делать эллиптический валик из этой резинки — оно всё равно будет плохо работать. Если у вас в конструкторе нет квадратной пластинки с дырками по краям, то это проблема нехватки деталек. Вы можете попытаться сделать квадратную пластину из пары прямоугольных, но не следует делать её и сотни длинных полосок.
Бывает так, что скрипты перерождаются в программы. Внезапно в скрипте появляется некая логика (алгоритм), которая становится нетривиальна (и полезна). В этот момент нужно поймать это — и не полениться потратить в три раза больше времени, но сделать её программой. Обеспечить её «мясом», которое отличает программу от скрипта. Добавить сотню проверок условий, заменить все константы на конфигурируемые переменные, приготовить её для работы в «непривычных» условиях. Желательно сделать её публичной (тогда может наработаться практика использования).
Обычный пайп представляет из себя практически идеальный инструмент для конструирования простых программ:
```
lssomething | grep "bla-bla"|sendmail root@host.ru -s "bla-bal for something".
```
Грань, в которой заканчивается скрипт найти сложно. Скажем так, цикл — ещё терпимо. Проверка условия — нормально. Но вот проверка условия в цикле (больше, чем выход из цикла) — это уже плохо. Если же у вас цикл, в котором по проверке условия запускается цикл — это 100% программа. Если у неё нет всего того, что должно быть у программы, значит это просто *очень плохая программа*. Но никак не скрипт.
Когда я смотрю на сборники «полезных скриптов» ([вот тут](http://forum.sysadmins.ru/topic79925.html) (forum.sysadmins.ru), например), я понимаю, что это программы. Ужасные программы без сопроводительной документации, процедуры установки, без проверки условий… Так нельзя.
Применение подобных скриптов — признак крайней куцести рабочей среды. Я одно время пробовал с ними ужиться, но пришёл к выводу, что это ошибка. Куда правильнее иметь набор тулкитов (т.е. полноценных программ, реализующих конкретные вещи полностью и хорошо), чем набор аналогичных скриптов (повторю ещё раз — программа может быть написана на том же скриптовом языке — разница между скриптом и программой в непрограммерской обвязке: документации и приспособленности к жизни в широком спектре систем).
Применение копипастнутых скриптов — подобие ранне-досового копирования на дискетках полезных программулин. Работает — радуемся, не работает — пофигу, сломало всё — злимся. В условиях выбора между копипастнутым скриптом и программой (и минимальной обвязкой) следует выбирать программы. Даже если внедрение программы потребует дополнительных усилий по изучению, налаживанию и т.д. Наладив программу, вы получите программу. Отладив скрипт вы получите лишь костыль, прочность и долговечностью которого не знает даже автор.
Каждый раз, когда возникает подобная ситуация: делать скрипт или искать программу, следует начать с поиска программы. Потому что программирование увлекает (да нафига нам nagios, мы и сами напишем пачку скриптов мониторинга), а изучение чужого — утомляет (ну хрена она работает не так как я ожидаю?). Но последствия «недопрограммирования» — отсутствие документации к тому «дымоходу», который вы сделали. А последствие внедрённого решения — система, которая умеет работать сама по себе. | https://habr.com/ru/post/92590/ | null | ru | null |
# Просто о Хиндли-Милнере
#### Введение
Если вы когда-нибудь интересовались не слишком популярными языками, то должно быть слышали о «Хиндли-Милнере». Этот алгоритм вывода типов используются в F# и Haskell и OCaml, как и в их предшественнике ML. Некоторые исследователи даже пытаются использовать ХМ для оптимизации динамических языков вроде Ruby, JavaScript и Clojure.
И не смотря на его распространенность, до сих пор не было простого и понятного объяснения, что же это такое. Как же эта магия работает? Всегда ли выводимые типы будут верными? Или чем Хиндли-Милнер лучше, скажем, Java? И пока те, кто действительно знает что такое ХМ будут восстанавливаться от очередного умственного перенапряжения, мы попробуем разобраться в этом сами.
#### Первый шаг
По-существу, Хиндли-Милнер (или «Дамас-Милнер») это алгоритм для вывода типов значений на основании того, как они используются. Буквально, он формализует интуитивное представление о том, что тип может быть выведен из поддерживаемых им операций. Рассмотрим следующий код на псевдо-Scala[[4]](#comm4):
```
def foo(s: String) = s.length
// заметьте: без указания типов
def bar(x, y) = foo(x) + y
```
Просто посмотрев на определение функции `bar`, мы можем сказать, что ее тип *должен* быть `(String, Int)=>Int`. Это не сложно вывести. Мы просто смотрим на тело функции и видим два способоа использовать параметры `x` и `y`. `x` передается в `foo`, который ожидает `String`. Следовательно `x` должен иметь тип `String` для того, чтобы этот код скомпилировался. Более того, `foo` возвращает значение типа `Int`. Метод `+` класса `Int` ожидает параметр, также `Int`, следовательно `y` должен быть типа `Int`. Наконец, мы знаем, что `+` возвращает `Int`, а значит это и есть тип, возвращаемый `bar`.
И этот именно то, что делает Хиндли-Милнер: просматривая определение функции он вычисляет *множество ограничений*, накладываемых тем, как значение используется. И именно это мы и делали, когда заметили, что `foo` принимает параметр типа `String`. Как только создано множество ограничений, алгоритм завершает восстановление типов при помощи *унификации* этих ограничений. Если выражение хорошо типизировано, то в итоге ограничения приведут к недвусмысленному типу. Иначе одно (или несколько) ограничений будут взаимоисключающими или неразрешимыми с данным набором типов.
#### Неформальный алгоритм
##### Простой пример
Для того, чтобы было проще понять алгоритм, выполним каждый его шаг вручную. Во-первых, нужно вывести множество ограничений. Начнем с присваивания каждой переменной (`x` и `y`) *нового* типа (т.е. «не существующего»). Если бы мы записали `bar` с этими типами, то вышло бы что-нибудь вроде[[1]](#comm1):
```
def bar(x: X, y: Y) = foo(x) + y
```
Не важно, как называются типы, главное, что они никак не пересекаются с «реальными» типами. Они нужны для того, чтобы алгоритм мог недвусмысленно ссылаться на еще не известный тип каждого значения. Без чего невозможно создать множество ограничений.
Далее, мы погружаемся в тело функции в поиске операций, которые налагают некоторые ограничения на тип. И так, первой операцией является вызов метода `foo`.[[2]](#comm2) Мы знаем, что тип `foo` это `String=>Int` и это позволяет нам записать ограничение:
`*X* ↦ String`
Следующей операцией будет `+`, связанной со значением `y`. Scala представляет все операторы как вызов метода, т.о. это выражение в действительности значит "`foo(x).+(y)`". Мы уже знаем, что `foo(x)` это выражение типа `Int` (из типа возвращаемого `foo`), как и то, что `+` определен как метод класса `Int` с типом `Int=>Int` (конечно, это не совсем корректно использовать магию присущую только Scala). Что позволяет добавить в наше множество еще одно ограничение:
`*X* ↦ String
*Y* ↦ Int`
Последний шаг восстановления типов — это *унификация* всех этих ограничений для того, чтобы получить реальные типы, которые мы подставим вместо переменных `*X*` и `*Y*`. Унификация, буквально, — это процесс прохода через все ограничения в попытке найти единственный тип, который удовлетворяет им всем. Например, представьте, что вам дали следующие факты:
* Маша высокая
* Вася высокий
* Маша любит красный
* Вася любит синий
Теперь, посмотрите на эти ограничения:
* Некто высок
* Некто любит красный
Хмм, кем же может быть Некто? Этот процесс комбинирования множества ограничений вместе с множеством фактов может быть математически формализован в виде унификации. В случае с восстановление типов, достаточно переименовать «типы» в «факты».
В этом примере унификация множества ограничений тривиальна. У нас было всего лишь одно ограничение для каждого значения (`x` и `y`) и оба они отображаются в реальные типы. Единственное, что требовалось это подставить "`String`" вместо "`*X*`" и "`Int`" вместо "`*Y*`".
##### Сложный пример
Чтобы почувствовать силу унификации, рассмотрим пример посложнее. Допустим, у нас есть следующая функция[[3]](#comm3):
```
def baz(a, b) = a(b) :: b
```
Здесь объявлена функция `baz`, которая из параметров принимает функцию и что-то еще, вызывая функцию от переданного ей второго параметра и затем присоединяя результат к нему же самому. Легко вывести множество ограничений для этой функции. Как и до этого, мы начнем с создания новых типов для каждого значения.
Заметьте, что в этом случае мы аннотируем не только параметры, но и возвращаемое значение.
```
def baz(a: X, b: Y): Z = a(b) :: b
```
Первое ограничение, которые мы выведем, будет тем, что параметр `a` должен быть функцией, что принимает значение типа `*Y*` и возвращает значение нового типа `*Y'*`. Более того, мы знаем, что `::` это функция над классом `List[A]`, которая принимает новый элемент `A` и возвращает новый список `List[A]`. Таким образом мы знаем, что `*Y*` и `*Z*` должны быть типа `List[*Y'*]`. Ограничения, записанные в формальном виде:
`*X* ↦ (*Y*=>*Y'*)
*Y* ↦ List[*Y'*]
*Z* ↦ List[*Y'*]`
Теперь унификация не на столько тривиальна. Важно, что переменная `*X*` зависит от `*Y*`, то есть потребуется как минимум еще один дополнительный шаг:
`*X* ↦ (List[*Y'*]=>*Y'*)
*Y* ↦ List[*Y'*]
*Z* ↦ List[*Y'*]`
Это то же множество ограничений, только на этот раз мы подставили известное отображение для `*Y*`в отображение для `*X*`. С помощью этой подстановки мы избавились от `*X*`, `*Y*` и `*Z*` из выведенных нами типов, получив следующую, типизированную функцию `baz`:
```
def baz(a: List[Y`]=>Y`, b: List[Y`]): List[Y`] = a(b) :: b
```
Конечно, это все еще не конечный результат. Даже если бы имя типа `*Y'*` было бы синтаксически верно, то ошибкой являлось бы отсутствие такого типа. Это случается, достаточно часто, при работе с алгоритмом восстановления типов Хиндли-Милнера. Каким-то образом, после вывода всех ограничений и унификации мы имеем «остатки» типов переменных, для которых больше нет ограничений.
Решением можно считать неограниченные переменные вроде параметров типа. В конце-концов, если параметр ничем не ограничен, то мы можем просто подставить любой тип, включая дженерик. И так, окончательная версия функции `baz`, куда мы добавили неограниченный параметр типа "`A`" и заменили им все вхождения `*Y'*` в выведенных типах:
```
def baz[A](a: List[A]=>A, b: List[A]): List[A] = a(b) :: b
```
#### Вывод
И… это всё! Хиндли-Милнер не сложнее, чем то, что мы здесь описали. Просто представить, как этот алгоритм может быть использован для восстановления типов выражений значительно более сложных, чем мы рассмотрели.
Надеюсь, эта статья помогла вам лучше понять, как же работает алгоритм Хиндли-Милнера. Этот тип вывода типов может быть очень полезен, сокращая количество кода, нужное для статической типизации до необходимого минимума. Пример "`bar`" был специально приведен в похожем на Ruby синтаксисе, чтобы показать, что этой информации все еще достаточно для проверки типов. Это может быть полезно следующий раз, когда кто-то скажет, что все статически типизированные языки слишком не выразительны.
#### Сноски и комментарии
1. Тип возвращаемого значения опущен для простоты чтения. Технически, типы всегда выводятся для выражения в целом.
2. Это поиск в глубину по АСД, что значит, что мы в первую очередь смотрим на операции с высоким приоритетом. Хотя технически не важен порядок обхода, но таким образом проще думать об алгоритме.
3. "`::`" — это так называемый `cons`-оператор в Scala. Он отвечает за присоединение левого элемента к правому списку.
4. [О корректности использования Scala для примеров кода](#comment_4124301) | https://habr.com/ru/post/125250/ | null | ru | null |
# Определяем подходящий размер для кластера Kafka в Kubernetes
***Прим. перев.**: В этой статье компания Banzai Cloud делится примером использования её специальных утилит для облегчения эксплуатации Kafka в рамках Kubernetes. Приводимые инструкции иллюстрируют, как можно определить оптимальный размер инфраструктуры и настроить саму Kafka для достижения требуемой пропускной способности.*
Apache Kafka — распределённая стриминговая платформа для создания надёжных, масштабируемых и высокопроизводительных потоковых систем реального времени. Её впечатляющие возможности можно расширить с помощью Kubernetes. Для этого мы разработали [Open Source-оператор Kafka](https://github.com/banzaicloud/kafka-operator) и инструмент под названием [Supertubes](https://banzaicloud.com/docs/supertubes/overview/). Они позволяют запускать Kafka в Kubernetes и использовать её различные функции, такие как тонкая настройка конфигурации брокера, масштабирование на основе метрик с ребалансировкой, rack awareness (осведомлённость об аппаратных ресурсах), «мягкое» *(graceful)* выкатывание обновлений и т.д.
> Попробуйте Supertubes в своём кластере:
>
>
>
>
> ```
> curl https://getsupertubes.sh | sh и supertubes install -a --no-democluster --kubeconfig
> ```
>
>
> Или обратитесь к [документации](https://banzaicloud.com/docs/supertubes/cli/reference/). Также можно почитать о некоторых возможностях Kafka, работа с которыми автоматизирована с помощью Supertubes и Kafka operator. О них мы уже писали в блоге:
>
>
>
> * [Oh no! Yet another Kafka operator for Kubernetes](https://banzaicloud.com/blog/kafka-operator/);
> * [Monitor and operate Kafka based on Prometheus metrics](https://banzaicloud.com/blog/kafka-alert/);
> * [Kafka rack awareness on Kubernetes](https://banzaicloud.com/blog/kafka-rack-awareness/);
> * [Running Apache Kafka over Istio — benchmark](https://banzaicloud.com/blog/kafka-on-istio-performance/);
> * [User authenticated and access controlled clusters with the Kafka operator](https://banzaicloud.com/blog/kafka-topic-user-management/);
> * [Kafka rolling upgrade and dynamic configuration on Kubernetes](https://banzaicloud.com/blog/kafka-rolling-upgrade/);
> * [Envoy protocol filter for Kafka, meshed](https://banzaicloud.com/blog/kafka-envoy-protocol-filter/).
>
Решив развернуть кластер Kafka в Kubernetes, вы наверняка столкнетесь с проблемой определения оптимального размера базовой инфраструктуры и необходимостью тонкой подстройки конфигурации Kafka для удовлетворения требований к пропускной способности. Максимальная производительность каждого брокера определяется производительностью компонентов инфраструктуры в его основе, таких как память, процессор, скорость диска, пропускная способность сети и т.д.
В идеале конфигурация брокера должна быть такой, чтобы все элементы инфраструктуры использовались на максимуме своих возможностей. Однако в реальной жизни такая настройка весьма сложна. Более вероятно, что пользователи будут настраивать конфигурацию брокеров таким образом, чтобы максимизировать использование одного или двух компонентов (диска, памяти или процессора). Вообще говоря, брокер показывает максимальную производительность, когда его конфигурация позволяет задействовать самый медленный компонент «по полной программе». Так мы можем получить примерное представление о нагрузке, с которой способен справиться один брокер.
Теоретически, мы также можем прикинуть число брокеров, необходимое для работы с заданной нагрузкой. Однако на практике вариантов настройки на различных уровнях столь много, что оценить потенциальную производительность некой конфигурации весьма сложно (если не невозможно). Другими словами, очень сложно спланировать конфигурацию, отталкиваясь от некой заданной производительности.
Для пользователей Supertubes мы обычно применяем следующий подход: начинаем с некоторой конфигурации (инфраструктура + настройки), затем измеряем её производительность, корректируем настройки брокера и повторяем процесс ещё раз. Это происходит до тех пор, пока потенциал самого медленного компонента инфраструктуры не будет полностью задействован.
Таким способом мы получаем более чёткое представление о том, сколько брокеров необходимо кластеру, чтобы справиться с определённой нагрузкой (количество брокеров также зависит от других факторов, таких как минимальное число реплик сообщений для обеспечения устойчивости, количество partition-лидеров и т.п.). Кроме того, мы получаем представление о том, для какого инфраструктурного компонента желательно масштабирование по вертикали.
В этой статье речь пойдёт о шагах, которые мы предпринимаем для того, чтобы «выжать всё» из самых медленных компонентов в начальных конфигурациях и измерить пропускную способность кластера Kafka. Высокоустойчивая конфигурация требует наличия по крайней мере трёх работающих брокеров (`min.insync.replicas=3`), разнесённых по трём разным зонам доступности. Для настройки, масштабирования и мониторинга инфраструктуры Kubernetes мы используем собственную платформу управления контейнерами для гибридных облаков — [Pipeline](https://github.com/banzaicloud/pipeline). Она поддерживает on-premise (bare metal, VMware) и пять типов облаков (Alibaba, AWS, Azure, Google, Oracle), а также их любые сочетания.
Мысли по поводу инфраструктуры и конфигурации кластера Kafka
------------------------------------------------------------
Для примеров, приведённых ниже, мы выбрали AWS в качестве поставщика облачных услуг и EKS в качестве дистрибутива Kubernetes. Аналогичную конфигурацию можно реализовать с помощью [PKE](https://github.com/banzaicloud/pke) — дистрибутива Kubernetes от Banzai Cloud, сертифицированного CNCF.
### Диск
Amazon предлагает различные [типы томов EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html). В основе *gp2* и *io1* лежат SSD-диски, однако для обеспечения высокой пропускной способности *gp2* потребляет накопленные кредиты *(I/O credits)*, поэтому мы предпочли тип *io1*, который предлагает стабильную высокую пропускную способность.
### Типы инстансов
Производительность Kafka сильно зависит от страничного кэша операционной системы, поэтому нам нужны инстансы с достаточным количеством памяти для брокеров (JVM) и страничного кэша. Инстанс *c5.2xlarge* — неплохое начало, поскольку имеет 16 Гб памяти и [оптимизирован для работы с EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-optimized.html). Его недостатком является то, что он способен обеспечивать максимальную производительность на протяжении не более 30 минут каждые 24 часа. Если рабочая нагрузка требует максимальной производительности в течение более длительного промежутка времени, следует присмотреться к другим типам инстансов. Мы именно так и поступили, остановившись на *c5.4xlarge*. Он обеспечивает максимальную пропускную способность в **593,75 Мб/с**. Максимальная пропускная способность тома EBS *io1* выше, чем у инстанса *c5.4xlarge*, поэтому самый медленный элемент инфраструктуры, по всей видимости, это пропускная способность I/O этого типа инстанса (что также должны подтвердить результаты наших нагрузочных тестов).
### Сеть
Пропускная способность сети должна оказаться достаточно большой по сравнению с производительностью инстанса VM и диска, в противном случае сеть становится узким местом. В нашем случае сетевой интерфейс *c5.4xlarge* поддерживает скорость до 10 Гб/с, что значительно выше пропускной способности I/O инстанса VM.
### Развёртывание брокеров
Брокеры должны разворачиваться (планироваться в Kubernetes) на выделенные узлы, чтобы избежать конкуренции с другим процессами за ресурсы процессора, памяти, сети и диска.
### Версия Java
Логичным выбором является Java 11, поскольку она совместима с Docker в том смысле, что JVM правильно определяет процессоры и память, доступные контейнеру, в котором работает брокер. Зная, что лимиты по процессорам важны, JVM внутренне и прозрачно устанавливает количество потоков GC и потоков JIT-компилятора. Мы использовали образ Kafka `banzaicloud/kafka:2.13-2.4.0`, включающий версию Kafka 2.4.0 (Scala 2.13) на Java 11.
> Если вы желаете подробнее узнать о Java/JVM на Kubernetes, обратите внимание на следующие наши публикации:
>
>
>
> * [Why my Java application is OOMKilled](https://banzaicloud.com/blog/java-resource-limits/);
> * [How to correctly size containers for Java 10 applications](https://banzaicloud.com/blog/java10-container-sizing/).
>
### Настройки памяти брокера
Существует два ключевых аспекта в настройке памяти брокера: настройки для JVM и для pod'а Kubernetes. Предел памяти, установленный для pod'а, должен быть больше, чем максимальный heap size, чтобы у JVM оставалось место для метапространства Java, которое находится в собственной памяти, и для страничного кэша операционной системы, который Kafka активно использует. Мы в своих тестах запускали брокеры Kafka с параметрами `-Xmx4G -Xms2G`, а предел памяти для pod'а составлял `10 Gi`. Обратите внимание, что настройки памяти для JVM можно получать автоматом с помощью `-XX:MaxRAMPercentage` и `-X:MinRAMPercentage`, исходя из лимита памяти для pod'а.
### Процессорные настройки брокера
Вообще говоря, можно поднять производительность, повысив параллелизм за счёт увеличения числа потоков, используемых Kafka. Чем больше процессоров доступны для Kafka, тем лучше. В нашем тесте мы начали с лимита в 6 процессоров и постепенно (итерациями) подняли их число до 15. Кроме того, мы установили `num.network.threads=12` в настройках брокера, чтобы увеличить количество потоков, принимающих данные из сети и посылающих их. Сразу обнаружив, что брокеры-последователи не могут получать реплики достаточно быстро, подняли `num.replica.fetchers` до 4, чтобы увеличить скорость, с которой брокеры-последователи реплицировали сообщения от лидеров.
### Инструмент генерирования нагрузки
Следует убедиться, что потенциал выбранного генератора нагрузки не иссякнет до того, как кластер Kafka (бенчмарк которого проводится) достигнет своей максимальной нагрузки. Другими словами, необходимо провести предварительную оценку возможностей инструмента генерирования нагрузки, а также выбрать для него типы instance'ов с достаточным количеством процессоров и памяти. В этом случае наш инструмент будет продуцировать больше нагрузки, чем способен переварить кластер Kafka. После множества опытов, мы остановились на трёх экземплярах *c5.4xlarge*, в каждом из которых был запущен генератор.
Бенчмаркинг
-----------
Измерение производительности — итеративный процесс, включающий следующие стадии:
* настройка инфраструктуры (кластера EKS, кластера Kafka, инструмента генерирования нагрузки, а также Prometheus и Grafana);
* генерирование нагрузки в течение определённого периода для фильтрации случайных отклонений в собираемых показателях производительности;
* подстройка инфраструктуры и конфигурации брокера на основе наблюдаемых показателей производительности;
* повторение процесса до тех пор, пока не будет достигнут требуемый уровень пропускной способности кластера Kafka. При этом он должен быть стабильно воспроизводимым и демонстрировать минимальные вариации пропускной способности.
В следующем разделе описаны шаги, которые выполнялись в процессе бенчмарка тестового кластера.
### Инструменты
Для быстрого развёртывания базовой конфигурации, генерации нагрузки и измерения производительности использовались следующие инструменты:
* [Banzai Cloud Pipeline](https://banzaicloud.com/docs/pipeline/overview/) для организации кластера EKS от Amazon c [Prometheus](https://prometheus.io/) (для сбора метрик Kafka и инфраструктуры) и [Grafana](https://grafana.com/) (для визуализации этих метрик). Мы воспользовались **интегрированными** в [Pipeline](https://github.com/banzaicloud/pipeline) сервисами, которые обеспечивают федеративный мониторинг, централизованный сбор логов, сканирование уязвимостей, восстановление после сбоев, безопасность корпоративного уровня и многое другое.
* [Sangrenel](https://github.com/jamiealquiza/sangrenel) — инструмент для нагрузочного тестирования кластера Kafka.
* Панели Grafana для визуализации метрик Kafka и инфраструктуры: [Kubernetes Kafka](https://grafana.com/grafana/dashboards/10123), [Node Exporter](https://grafana.com/grafana/dashboards/1860).
* Supertubes CLI для максимально простой настройки кластера Kafka в Kubernetes. Zookeeper, Kafka operator, Envoy и множество других компонентов установлены и должным образом сконфигурированы для запуска готового к production кластера Kafka в Kubernetes.
+ Для установки *supertubes CLI* воспользуйтесь инструкциями, приведенными [здесь](https://banzaicloud.com/docs/supertubes/cli/install/).
### Кластер EKS
Подготовьте кластер EKS с выделенными рабочими узлами *c5.4xlarge* в различных зонах доступности для pod'ов с брокерами Kafka, а также выделенные узлы для генератора нагрузки и мониторинговой инфраструктуры.
```
banzai cluster create -f https://raw.githubusercontent.com/banzaicloud/kafka-operator/master/docs/benchmarks/infrastructure/cluster_eks_202001.json
```
Когда кластер EKS заработает, включите его интегрированную [службу мониторинга](https://banzaicloud.com/docs/pipeline/features/integrated-services/) — она развернёт Prometheus и Grafana в кластер.
### Системные компоненты Kafka
Установите системные компоненты Kafka (Zookeeper, kafka-operator) в EKS с помощью supertubes CLI:
```
supertubes install -a --no-democluster --kubeconfig
```
### Кластер Kafka
По умолчанию в EKS используются тома EBS типа *gp2*, поэтому необходимо создать отдельный класс хранилищ на основе томов *io1* для кластера Kafka:
```
kubectl create -f - <
```
Установите для брокеров параметр `min.insync.replicas=3` и разверните pod'ы брокеров на узлах в трёх разных зонах доступности:
```
supertubes cluster create -n kafka --kubeconfig -f https://raw.githubusercontent.com/banzaicloud/kafka-operator/master/docs/benchmarks/infrastructure/kafka\_202001\_3brokers.yaml --wait --timeout 600
```
### Топики
Мы параллельно запускали три экземпляра генератора нагрузки. Каждый из них пишет в свой топик, то есть всего нам нужно три топика:
```
supertubes cluster topic create -n kafka --kubeconfig -f -< -f -< -f -<
```
Для каждого топика фактор репликации равен 3 — минимальному рекомендованному значению для высокодоступных production-систем.
### Инструмент генерирования нагрузки
Мы запускали три экземпляра генератора нагрузки (каждый писал в отдельный топик). Для pod'ов генератора нагрузки необходимо прописать node affinity, чтобы они планировались только на выделенные для них узлы:
```
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
labels:
app: loadtest
name: perf-load1
namespace: kafka
spec:
progressDeadlineSeconds: 600
replicas: 1
revisionHistoryLimit: 10
selector:
matchLabels:
app: loadtest
strategy:
rollingUpdate:
maxSurge: 25%
maxUnavailable: 25%
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
app: loadtest
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: nodepool.banzaicloud.io/name
operator: In
values:
- loadgen
containers:
- args:
- -brokers=kafka-0:29092,kafka-1:29092,kafka-2:29092,kafka-3:29092
- -topic=perftest1
- -required-acks=all
- -message-size=512
- -workers=20
image: banzaicloud/perfload:0.1.0-blog
imagePullPolicy: Always
name: sangrenel
resources:
limits:
cpu: 2
memory: 1Gi
requests:
cpu: 2
memory: 1Gi
terminationMessagePath: /dev/termination-log
terminationMessagePolicy: File
dnsPolicy: ClusterFirst
restartPolicy: Always
schedulerName: default-scheduler
securityContext: {}
terminationGracePeriodSeconds: 30
```
Несколько моментов, на которые следует обратить внимание:
* Генератор нагрузки генерирует сообщения длиной 512 байт и публикует их в Kafka партиями по 500 сообщений.
* С помощью аргумента `-required-acks=all` публикация признаётся успешной, когда все синхронизированные реплики сообщения получены и подтверждены брокерами Kafka. Это означает, что в бенчмарке мы измеряли не только скорость работы лидеров, получающих сообщения, но и их последователей, реплицирующих сообщения. В задачу данного теста не входит оценка скорости чтения потребителями *(consumers)* недавно принятых сообщений, которые пока остаются в страничном кэше ОС, и её сравнение со скоростью чтения сообщений, хранящихся на диске.
* Генератор нагрузки параллельно запускает 20 worker'ов (`-workers=20`). Каждый worker содержит 5 producer'ов, которые совместно используют подключение worker'а к кластеру Kafka. В итоге каждый генератор насчитывает 100 producer'ов, и все они отправляют сообщения в кластер Kafka.
### Наблюдение за состоянием кластера
Во время нагрузочного тестирования кластера Kafka мы также следили за его здоровьем, чтобы убедиться в отсутствии перезапусков pod'ов, рассинхронизированных реплик и максимальной пропускной способности с минимальными флуктуациями:
* Генератор нагрузки пишет стандартную статистику о количестве опубликованных сообщений и уровне ошибок. Процент ошибок должен оставаться в значении `0,00%`.
* [Cruise Control](https://github.com/linkedin/cruise-control), развёрнутый kafka-operator'ом, предоставляет панель мониторинга, на которой мы также можем наблюдать за состоянием кластера. Для просмотра этой панели выполните:
```
supertubes cluster cruisecontrol show -n kafka --kubeconfig
```
* Уровень ISR *(число реплик «in-sync»)* shrink и expansion равен 0.
Результаты измерений
--------------------
### 3 брокера, размер сообщений — 512 байт
С partition'ами, равномерно распределёнными по трём брокерам, нам удалось достичь производительности *~500 Мб/с (примерно 990 тыс. сообщений в секунду)*:
Потребление памяти виртуальной машиной JVM не превысило 2 Гб:
Пропускная способность диска достигла максимальной пропускной способности I/O узла на всех трёх инстансах, на которых работали брокеры:
Из данных об использовании памяти узлами следует, что системная буферизация и кэширование заняли ~10-15 Гб:
### 3 брокера, размер сообщений — 100 байт
С уменьшением размера сообщений пропускная способность падает примерно на 15-20%: сказывается время, затрачиваемое на обработку каждого сообщения. Кроме того, нагрузка на процессор выросла почти вдвое.
Поскольку на узлах брокеров по-прежнему имеются неиспользуемые ядра, производительность можно повысить за счёт изменения конфигурации Kafka. Это непростая задача, поэтому для увеличения пропускной способности лучше работать с сообщениями большего размера.
### 4 брокера, размер сообщений — 512 байт
Можно легко увеличить производительность кластера Kafka, просто добавляя новые брокеры и сохраняя баланс partition'ов (это обеспечивает равномерное распределение нагрузки между брокерами). В нашем случае после добавления брокера пропускная способность кластера возросла до *~580 Мб/с (~1,1 млн сообщений в секунду)*. Рост оказался меньшим, чем ожидалось: преимущественно это объясняется дисбалансом partition'ов (не все брокеры работают на пике возможностей).
Потребление памяти машиной JVM осталось ниже 2 Гб:
На работе брокеров с накопителями сказался дисбаланс partition'ов:
Выводы
------
Представленный выше итеративный подход может быть расширен для охвата более сложных сценариев, включающих сотни consumer'ов, repartitioning, накатываемые обновления, перезапуски pod'ов и т.д. Всё это позволяет нам оценить пределы возможностей кластера Kafka в различных условиях, выявить узкие места в его работе и найти способы борьбы с ними.
Мы разработали Supertubes для быстрого и лёгкого развёртывания кластера, его конфигурирования, добавления/удаления брокеров и топиков, реагирования на оповещения и обеспечения правильной работы Kafka в Kubernetes в целом. Наша цель — помочь сконцентрироваться на основной задаче («генерировать» и «потреблять» сообщения Kafka), а всю тяжёлую работу предоставить Supertubes и Kafka operator'у.
Если вам интересны технологии и Open Source-проекты Banzai Cloud, подписывайтесь на компанию в [GitHub](https://github.com/banzaicloud), [LinkedIn](https://www.linkedin.com/company/banzaicloud) или [Twitter](https://twitter.com/BanzaiCloud).
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Одна история с оператором Redis в K8s и мини-обзор утилит для анализа данных этой БД](https://habr.com/ru/company/flant/blog/480722/)»;
* «[Беспростойная миграция RabbitMQ в Kubernetes](https://habr.com/ru/company/flant/blog/450662/)»;
* «[zetcd от CoreOS: Заменяя ZooKeeper на… хранилище etcd](https://habr.com/ru/company/flant/blog/329224/)». | https://habr.com/ru/post/488920/ | null | ru | null |
# Кортежи объектов в Java и их коллекции
Достаточно часто на практике возникает необходимость воспользоваться такими конструкциями как «пара» (`Pair`), менее часто «тринарными» объектами (`Triplet`) и более длинными цепочками ассоциированных объектов. В связи с чем всегда удивлялся, почему в JDK (в `java.lang.*` или `java.util.*`) до настоящего момента нет стандартной `Pair` или более длинных конструкций. Думаю многие программисты практикующие на Java имеют свою реализацию «пары». Не исключением являюсь и я.
И вот в очередной раз наткнувшись на необходимость работать с большим количеством различных кортежей, решил взяться за эту проблему системно. Придумал название проекту, определил цели и после экспериментов, занявших некоторое время, выложил код ( git://github.com/telesik/rumba.git ).
Чего хотелось достичь:
* Необходима удобная конструкция (назовем ее **кортеж**) для ассоциации нескольких объектов, типы которых определялись бы из позиции в полученном кортеже;
* Кортеж должен быть неограниченным по длине и типу;
* Типы элементов должны быть относительно контролируемым (как минимум ограничен дженериками);
* Описание структуры кортежа должно быть простым;
### Явление на свет кортежа
И вот на свет появился интерфейс `Cortege`:
```
public interface Cortege {
T setValue(V value);
T nextElement();
Vi getValue(int index) throws ClassCastException; // be careful with types. Type is not bounded
int getDeep();
void setValue(int index, Vi value); // be careful with types. Type is not bounded
Cortege setValues(Object... values); // be careful with types. Type is not bounded!!!
V getValue();
static abstract class End> implements Cortege {
}
}
```
На рисунке ниже наглядно показан механизм описания кортежей произвольной длины и типов элементов
Рис. 1. механизм описания кортежей произвольной длины и типов элементов
Но что есть “голый” интерфейс, если нет ни одной реализации? Есть такая! Имя ей `CortegeChain`. Наличие в названии слова Chain обусловлено способом организации хранения элементов в кортеже. Предполагаю и надеюсь, что в будущем появятся другие реализации, оптимизированные для различных типов использования.
В реализации `CortegeChain` я не ставил особых целей оптимизации с точки зрения использования памяти или скорости работы. Основной задачей, которую я хотел решить — это попробовать саму идею, найти слабые места, обозначить очевидные и не очевидные возможности, открывающиеся перед разработчиком.
### Примеры использования
Перейду сразу к наглядным примерам использования:
```
// создание инстанса кортежа:
Cortege> cortegeLS = CortegeChain.create(2);
```
Следует обратить внимание на аргумент метода create. В связи с тем, что в Java дженерики существуют лишь на этапе компиляции, и добраться к ним в runtime я «законных» методов не нашел :(, пришлось «заплатить» за это такой ценой. Суть этого параметра — декларация глубины создаваемого кортежа. Но в виду того, что разработчик как правило знает кол-во элементов, необходимость указания этого параметра не должно вызывать больших проблем.
*примечание: Но все же, если кто-то может предложить свое решение это проблемки с параметром — я буду чрезвычайно благодарен.*
Итак пример,
```
// заполнение элементов значениями
// 1-й вариант (заполняем первый элемент в кортеже, с контролем типа)
cortegeLS.setValue(4L);
cortegeLS.nextElement().setValue("str");
// 2-й вариант (заполняем подряд цепью, с контролем типа)
cortegeLS.setValue(4L).setValue("str");
// 3-й вариант (заполняем массивом, без контроля типа)
cortegeLS.setValues(4L, "str");
```
Теперь чтение,
```
// 1-й вариант (чтение первого элемента в кортеже, с контролем типа)
Long valueA = cortegeLS.getValue();
// 2-й вариант (чтение выбранного элемента в кортеже, с контролем типа)
String valueB = cortegeLS.nextElement().getValue();
// 3-й вариант (чтение выбранного элемента в кортеже, без контроля типа)
Long valueC = cortegeLS.getValue(1);
String valueD = cortegeLS.getValue(2);
```
Что еще можно сделать с кортежем:
1. Получить кортеж “справа”.
```
Cortege rightCortegeS = cortegeLS.nextElement();
// еще раз
Cortege.End rightCortegeEnd = cortegeLS.nextElement().nextElement();
```
2. Получить “глубину” (кол-во элементов в кортеже)
```
int deep = cortegeLS.getDeep();
```
Пожалуй все. Но не все! :)
### Коллекции кортежей
Создавал я кортеж не просто так. Теперь имея такую конструкцию хорошо бы ее «прикрутить» к дружному семейству коллекций (`java.util.Collection`). Сказано — сделано. Но банальное использование кортежа как элемента коллекции не интересно. Хочется не просто находить, удалять, модифицировать элементы коллекции вцелом, что дают традиционные реализации интерфейсов `java.util.Set` и `java.util.List`, но и искать, фильтровать по отдельным элементам кортежей, хранящимся в коллекции, модифицировать колонки целиком и т.п, что является естественным для реляционных таблиц.
Итак вновь поставив цели:
* Коллекция должна быть совместима с давно ставшими стандартом интерфейсами семейства `java.util.Collection` (такими как `java.util.Set` и `java.util.List`)
* Имплементация должна расширять функционал своих аналогов в мире простых объектов (например таких как `java.util.HashSet`);
* В коллекции должно быть легко искать по абстрактному критерию;
* Необходимо реализовать получение подмножества;
* Очень хотелось бы реализовать возможность создания представления (аналог **view** в реляционных базах) над коллекцией.
+ представление не “владеет” исходными данными, а лишь фильтрует оригинальную коллекцию согласно критерию
+ фильтрация должна быть не одноразовой, а динамической. т.е. должна быть актуальной и отражать состояние оригинальной таблицы. все вставки, модификации и удаления из коллекции должны отражаться в ее представлении согласно предикату наложенному на **view**.
*Примечание: Из всего, что я хотел, не получилось только реализовать последний пункт “представление” (аналог **view** в реляционных базах данных). Но работа идет и возможно в недалеком будущем на свет появится реализация и этой многообещающей идеи.*
И вот что получилось:
```
public interface CortegeCollection extends Collection, Iterable {
boolean contains(int num, T obj);
CortegeCollection extract(int num, Object key);
CortegeCollection extract(Corteges.Predicate predicate);
// CortegeCollection view(int num, Corteges.Predicate predicate);
T findAny(int num, Object key);
T findAny(Corteges.Predicate predicate);
List getColumnCopy(int num);
void fill(int num, Vi value);
}
public interface CortegeSet extends CortegeCollection, Set {
}
public interface CortegeList extends CortegeCollection, List {
}
```
Рис. 2. Топология кортежных коллекций
### Примеры использования коллекций кортежей
Теперь наверное стоит как и в случае с описанием `Cortege` сразу перейти к наглядным примерам использования:
```
public class ExampleCollections {
public static void main(String[] args) {
// Создание экземпляра CortegeHashSet
CortegeSet>> cortegeHashSetLS = Corteges.newCortegeHashSet(2);
for (long i = 0; i < 5; i++) {
Cortege> cortegeLS = CortegeChain.create(2);
cortegeLS.setValue(i).setValue("" + i);
cortegeHashSetLS.add(cortegeLS);
}
for (Cortege cortege : cortegeHashSetLS) {
System.out.println(cortege);
}
cortegeHashSetLS.add(CortegeChain.>create(2));
Cortege> cortegeIS = CortegeChain.create(2);
System.out.println(cortegeHashSetLS.contains(cortegeIS));
cortegeIS.setValue(null).setValue("3");
System.out.println(cortegeIS);
System.out.println(cortegeHashSetLS.contains(cortegeIS));
System.out.println(cortegeHashSetLS.contains(1, 3L));
Cortege>> cortegeLLS1 = CortegeChain.create(3);
Cortege>> cortegeLLS2 = CortegeChain.create(3);
Cortege>> cortegeLLS3 = CortegeChain.create(3);
CortegeChain>> cortegeSLS = CortegeChain.create(3);
cortegeLLS1.setValue(1L);
cortegeLLS1.nextElement().setValue(11L);
cortegeLLS1.nextElement().nextElement().setValue("AAA");
cortegeLLS2.setValue(2L);
cortegeLLS2.nextElement().nextElement().setValue("BBB");
cortegeLLS3.setValue(3L);
cortegeLLS3.nextElement().setValue(33L);
cortegeLLS3.nextElement().nextElement().setValue("AAA");
CortegeHashSet>>> cortegeSetLLS = Corteges.newCortegeHashSet(cortegeLLS1.getDeep());
System.out.println(cortegeSetLLS.contains(cortegeLLS1));
cortegeSetLLS.add(cortegeLLS1);
cortegeSetLLS.add(cortegeLLS2);
cortegeSetLLS.add(cortegeLLS3);
System.out.println(cortegeSetLLS.contains(cortegeLLS1));
for (Cortege>> cortege : cortegeSetLLS) {
System.out.println(cortege);
}
System.out.println(cortegeSetLLS.contains(3, "AAA"));
cortegeSetLLS.fill(1, 5L);
cortegeSetLLS.fill(2, 8L);
cortegeSetLLS.fill(3, "XXX");
for (Cortege>> cortege : cortegeSetLLS) {
System.out.println(cortege);
}
// Collection corteges = cortegeSetLLS.extract(2, "111");
}
}
```
### Подведем итоги
Как видно из примера, получилась достаточно удобная библиотека для хранения и манипулирования с длинными кортежами объектов. К бенефитам библиотеки можно отнести:
* Создание кортежа произвольной длины достаточно просто и сводится лишь к перечислению типов элементов составляющих будущий экземпляр кортежа
* При последовательном обращении к элементам кортежа контролируется тип элемента
* Благодаря выбранной структуре декларации и хранения кортежа возможно получение под-кортежа «справа» (метод `nextElement()`)
Кроме самой структуры Cortege в библиотеке есть два типа коллекций, расширяющих всем известные `java.util.Set` и `java.util.List`) соответственно `com.rumba.cortege.CortegeSet` и `com.rumba.cortege.CortegeList`).
* Есть возможность найти кортеж или подмножество кортежей в коллекции по простому критерию эквивалентности элемента эталонному объекту (методы extract(int num, Object key) и findAny(int num, Object key))
* Есть возможность найти кортеж или подмножество кортежей в коллекции по предикату (методы extract(Corteges.Predicate predicate) и findAny(Corteges.Predicate predicate))
* Есть возмодность получить любую колонку с указанным номером образованную из элементов кортежей коллекции
* Есть возмодность заполнить целиком колонку элементов
Но и есть очевидные недостатки обусловленные в первую очередь невозможностью «добраться» к декларациям дженериков в Java и, как следствие, потеря контроля над типом при обращении по индексу к элементу кортежа. Справедливости ради я поискал библиотеки, решающие подобные задачи, и нашел достаточно интересную реализацию [javatuples](http://www.javatuples.org/). В ней проблема декларации «длинных» цепочек ассоциациированных объектов решается простым перебором “разумного” с точки зрения разработчиков максимального размера кортежа.
* Unit(1 element)
* Pair (2 elements)
* Triplet (3 elements)
* Quartet (4 elements)
* Quintet (5 elements)
* Sextet (6 elements)
* Septet (7 elements)
* Octet (8 elements)
* Ennead (9 elements)
* Decade (10 elements)
### Заключение
Работая над библиотекой я старался покрыть наиболее типичные, и с моей точки зрения, полезные задачи, возникающие при работе с кортежами и их коллекциями. К сожалению не все планы реализовано, но надеюсь та толика работы, что была выполнена будет кому-нибудь полезна. Но работа продолжается, надеюсь не зря.
Было бы очень интересно получить конструктивный фитбэк на эту статью и библиотеку.
#### Полезные ссылки
[javatuples](http://www.javatuples.org/)
[достаточно интересная попытка реализации](http://stackoverflow.com/questions/3642452/java-n-tuple-implementation/3642623) | https://habr.com/ru/post/144176/ | null | ru | null |
# Шаблоны проектирования с человеческим лицом
Шаблоны проектирования — это способ решения периодически возникающих проблем. Точнее, это руководства по решению конкретных проблем. Это не классы, пакеты или библиотеки, которые вы можете вставить в своё приложение и ожидать волшебства.
Как сказано в Википедии:
> В программной инженерии шаблон проектирования приложений — это многократно применяемое решение регулярно возникающей проблемы в рамках определённого контекста архитектуры приложения. Шаблон — это не законченное архитектурное решение, которое можно напрямую преобразовать в исходный или машинный код. Это описание подхода к решению проблемы, который можно применять в разных ситуациях.
### image Будьте осторожны
* Шаблоны проектирования — не «серебряная пуля».
* Не пытайтесь внедрять их принудительно, последствия могут быть негативными. Помните, что шаблоны — это способы **решения**, а не **поиска** проблем. Так что не перемудрите.
* Если применять их правильно и в нужных местах, они могут оказаться спасением. В противном случае у вас будет ещё больше проблем.
В статье приведены примеры на PHP 7, но пусть вас это не смущает, ведь заложенные в шаблонах принципы неизменны. Кроме того, **внедряется поддержка других языков**.
### Виды шаблонов проектирования
* [Порождающие](https://habrahabr.ru/company/mailru/blog/325492/#porozhdayuschie-shablony-proektirovaniya)
* [Структурные](https://habrahabr.ru/company/mailru/blog/325492/#strukturnye-shablony-proektirovaniya)
* [Поведенческие](https://habrahabr.ru/company/mailru/blog/325492/#povedencheskie-shablony-proektirovaniya)
Порождающие шаблоны проектирования
----------------------------------
**Вкратце**
Порождающие шаблоны описывают создание (instantiate) объекта или группы связанных объектов.
**Википедия**
> В программной инженерии порождающими называют шаблоны, которые используют механизмы создания объектов, чтобы создавать объекты подходящим для данной ситуации способом. Базовый способ создания может привести к проблемам в архитектуре или к её усложнению. Порождающие шаблоны пытаются решать эти проблемы, управляя способом создания объектов.
* [Простая фабрика](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles49cfd95d249cfd95d226e47ceb73b85d6c35ff184png-prostaya-fabrika)
* [Фабричный метод](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesdbd913d1edbd913d1e60f4c4e9a0991241f8b246epng-fabrichnyy-metod)
* [Абстрактная фабрика](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesa079a0c34a079a0c348ef4f79b4fe7ac190407f3epng-abstraktnaya-fabrika)
* [Строитель](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles301beff6b301beff6b71b4be18c4ab10aaabb464fpng-stroitel)
* [Прототип](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesa730be6c4a730be6c433647d3af9858e505876141png-prototip)
* [Одиночка](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles46db1404e46db1404ea144dbf8b16073d5397698dpng-odinochka)
### image Простая фабрика
**Аналогия**
Допустим, вы строите дом и вам нужны двери. Будет бардак, если каждый раз, когда вам требуется дверь, вы станете вооружаться инструментами и делать её на стройплощадке. Вместо этого вы закажете двери на фабрике.
**Вкратце**
Простая фабрика просто генерирует экземпляр для клиента без предоставления какой-либо логики экземпляра.
**Википедия**
> В объектно ориентированном программировании фабрикой называется объект, создающий другие объекты. Формально фабрика — это функция или метод, возвращающая объекты разных прототипов или классов из вызова какого-то метода, который считается новым.
**Пример**
Для начала нам нужен интерфейс двери и его реализация.
```
interface Door
{
public function getWidth(): float;
public function getHeight(): float;
}
class WoodenDoor implements Door
{
protected $width;
protected $height;
public function __construct(float $width, float $height)
{
$this->width = $width;
$this->height = $height;
}
public function getWidth(): float
{
return $this->width;
}
public function getHeight(): float
{
return $this->height;
}
}
```
Теперь соорудим фабрику дверей, которая создаёт и возвращает нам двери.
```
class DoorFactory
{
public static function makeDoor($width, $height): Door
{
return new WoodenDoor($width, $height);
}
}
```
Использование:
```
$door = DoorFactory:makeDoor(100, 200);
echo 'Width: ' . $door->getWidth();
echo 'Height: ' . $door->getHeight();
```
**Когда использовать?**
Когда создание объекта подразумевает какую-то логику, а не просто несколько присваиваний, то имеет смысл делегировать задачу выделенной фабрике, а не повторять повсюду один и тот же код.
### image Фабричный метод
**Аналогия**
Одна кадровичка не в силах провести собеседования со всеми кандидатами на все должности. В зависимости от вакансии она может делегировать разные этапы собеседований разным сотрудникам.
**Вкратце**
Это способ делегирования логики создания объектов (instantiation logic) дочерним классам.
**Википедия**
> В классо-ориентированном программировании (class-based programming) фабричным методом называют порождающий шаблон проектирования, использующий генерирующие методы (factory method) для решения проблемы создания объектов без указания для них конкретных классов. Объекты создаются посредством вызова не конструктора, а генерирующего метода, определённого в интерфейсе и реализованного дочерними классами либо реализованного в базовом классе и, опционально, переопределённого (overridden) производными классами (derived classes).
**Пример**
Сначала создадим интерфейс сотрудника, проводящего собеседование, и некоторые реализации для него.
```
interface Interviewer
{
public function askQuestions();
}
class Developer implements Interviewer
{
public function askQuestions()
{
echo 'Asking about design patterns!';
}
}
class CommunityExecutive implements Interviewer
{
public function askQuestions()
{
echo 'Asking about community building';
}
}
```
Теперь создадим кадровичку `HiringManager`.
```
abstract class HiringManager
{
// Фабричный метод
abstract public function makeInterviewer(): Interviewer;
public function takeInterview()
{
$interviewer = $this->makeInterviewer();
$interviewer->askQuestions();
}
}
```
Любой дочерний класс может расширять его и предоставлять нужного собеседующего:
```
class DevelopmentManager extends HiringManager
{
public function makeInterviewer(): Interviewer
{
return new Developer();
}
}
class MarketingManager extends HiringManager
{
public function makeInterviewer(): Interviewer
{
return new CommunityExecutive();
}
}
```
Использование:
```
$devManager = new DevelopmentManager();
$devManager->takeInterview(); // Output: Спрашивает о шаблонах проектирования.
$marketingManager = new MarketingManager();
$marketingManager->takeInterview(); // Output: Спрашивает о создании сообщества.
```
**Когда использовать?**
Этот шаблон полезен для каких-то общих обработок в классе, но требуемые подклассы динамически определяются в ходе выполнения (runtime). То есть когда клиент не знает, какой именно подкласс может ему понадобиться.
### image Абстрактная фабрика
**Аналогия**
Вернёмся к примеру с дверями из «Простой фабрики». В зависимости от своих потребностей вы можете купить деревянную дверь в одном магазине, стальную — в другом, пластиковую — в третьем. Для монтажа вам понадобятся разные специалисты: деревянной двери нужен плотник, стальной — сварщик, пластиковой — спец по ПВХ-профилям.
**Вкратце**
Это фабрика фабрик. То есть фабрика, группирующая индивидуальные, но взаимосвязанные/взаимозависимые фабрики без указания для них конкретных классов.
**Википедия**
> Шаблон «Абстрактная фабрика» описывает способ инкапсулирования группы индивидуальных фабрик, объединённых некой темой, без указания для них конкретных классов.
**Пример**
Создадим интерфейс Door и несколько реализаций для него.
```
interface Door
{
public function getDescription();
}
class WoodenDoor implements Door
{
public function getDescription()
{
echo 'I am a wooden door';
}
}
class IronDoor implements Door
{
public function getDescription()
{
echo 'I am an iron door';
}
}
```
Теперь нам нужны специалисты по установке каждого вида дверей.
```
interface DoorFittingExpert
{
public function getDescription();
}
class Welder implements DoorFittingExpert
{
public function getDescription()
{
echo 'I can only fit iron doors';
}
}
class Carpenter implements DoorFittingExpert
{
public function getDescription()
{
echo 'I can only fit wooden doors';
}
}
```
Мы получили абстрактную фабрику, которая позволяет создавать семейства объектов или взаимосвязанные объекты. То есть фабрика деревянных дверей создаст деревянную дверь и человека для её монтажа, фабрика стальных дверей — стальную дверь и соответствующего специалиста и т. д.
```
interface DoorFactory
{
public function makeDoor(): Door;
public function makeFittingExpert(): DoorFittingExpert;
}
// Фабрика деревянных дверей возвращает плотника и деревянную дверь
class WoodenDoorFactory implements DoorFactory
{
public function makeDoor(): Door
{
return new WoodenDoor();
}
public function makeFittingExpert(): DoorFittingExpert
{
return new Carpenter();
}
}
// Фабрика стальных дверей возвращает стальную дверь и сварщика
class IronDoorFactory implements DoorFactory
{
public function makeDoor(): Door
{
return new IronDoor();
}
public function makeFittingExpert(): DoorFittingExpert
{
return new Welder();
}
}
```
Использование:
```
$woodenFactory = new WoodenDoorFactory();
$door = $woodenFactory->makeDoor();
$expert = $woodenFactory->makeFittingExpert();
$door->getDescription(); // Output: Я деревянная дверь
$expert->getDescription(); // Output: Я могу устанавливать только деревянные двери
// Same for Iron Factory
$ironFactory = new IronDoorFactory();
$door = $ironFactory->makeDoor();
$expert = $ironFactory->makeFittingExpert();
$door->getDescription(); // Output: Я стальная дверь
$expert->getDescription(); // Output: Я могу устанавливать только стальные двери
```
Здесь фабрика деревянных дверей инкапсулировала `carpenter` и `wooden door`, фабрика стальных дверей — `iron door` and `welder`. То есть можно быть уверенными, что для каждой из созданных дверей мы получим правильного специалиста.
**Когда использовать?**
Когда у вас есть взаимосвязи с не самой простой логикой создания (creation logic).
### image Строитель
**Аналогия**
Допустим, вы пришли в забегаловку, заказали бургер дня, и вам выдали его **без вопросов**. Это пример «Простой фабрики». Но иногда логика создания состоит из большего количества шагов. К примеру, при заказе бургера дня есть несколько вариантов хлеба, начинки, соусов, дополнительных ингредиентов. В таких ситуациях помогает шаблон «Строитель».
**Вкратце**
Шаблон позволяет создавать разные свойства объекта, избегая загрязнения конструктора (constructor pollution). Это полезно, когда у объекта может быть несколько свойств. Или когда создание объекта состоит из большого количества этапов.
**Википедия**
> Шаблон «Строитель» предназначен для поиска решения проблемы антипаттерна Telescoping constructor.
Поясню, что такое антипаттерн Telescoping constructor. Каждый из нас когда-либо сталкивался с подобным конструктором:
```
public function __construct($size, $cheese = true, $pepperoni = true, $tomato = false, $lettuce = true)
{
}
```
Как видите, количество параметров может быстро разрастись, и станет трудно разобраться в их структуре. Кроме того, этот список параметров будет расти и дальше, если в будущем вы захотите добавить новые опции. Это и есть антипаттерн Telescoping constructor.
**Пример**
Разумная альтернатива — шаблон «Строитель». Сначала создадим бургер:
```
class Burger
{
protected $size;
protected $cheese = false;
protected $pepperoni = false;
protected $lettuce = false;
protected $tomato = false;
public function __construct(BurgerBuilder $builder)
{
$this->size = $builder->size;
$this->cheese = $builder->cheese;
$this->pepperoni = $builder->pepperoni;
$this->lettuce = $builder->lettuce;
$this->tomato = $builder->tomato;
}
}
```
А затем добавим «строителя»:
```
class BurgerBuilder
{
public $size;
public $cheese = false;
public $pepperoni = false;
public $lettuce = false;
public $tomato = false;
public function __construct(int $size)
{
$this->size = $size;
}
public function addPepperoni()
{
$this->pepperoni = true;
return $this;
}
public function addLettuce()
{
$this->lettuce = true;
return $this;
}
public function addCheese()
{
$this->cheese = true;
return $this;
}
public function addTomato()
{
$this->tomato = true;
return $this;
}
public function build(): Burger
{
return new Burger($this);
}
}
```
Использование:
```
$burger = (new BurgerBuilder(14))
->addPepperoni()
->addLettuce()
->addTomato()
->build();
```
**Когда использовать?**
Когда у объекта может быть несколько свойств и когда нужно избежать Telescoping constructor. Ключевое отличие от шаблона «Простая фабрика»: он используется в одноэтапном создании, а «Строитель» — в многоэтапном.
### image Прототип
**Аналогия**
Помните клонированную овечку Долли? Так вот, этот шаблон проектирования как раз посвящён клонированию.
**Вкратце**
Объект создаётся посредством клонирования существующего объекта.
**Википедия**
> Шаблон «Прототип» используется, когда типы создаваемых объектов определяются экземпляром-прототипом, клонированным для создания новых объектов.
То есть шаблон позволяет дублировать существующий объект и модифицировать копию в соответствии с потребностями. Без заморочек с созданием объекта с нуля и его настройкой.
**Пример**
В PHP это легко можно сделать с помощью `clone`:
```
class Sheep
{
protected $name;
protected $category;
public function __construct(string $name, string $category = 'Mountain Sheep')
{
$this->name = $name;
$this->category = $category;
}
public function setName(string $name)
{
$this->name = $name;
}
public function getName()
{
return $this->name;
}
public function setCategory(string $category)
{
$this->category = $category;
}
public function getCategory()
{
return $this->category;
}
}
```
Затем можно клонировать так:
```
$original = new Sheep('Jolly');
echo $original->getName(); // Джолли
echo $original->getCategory(); // Горная овечка
// Клонируйте и модифицируйте, что нужно
$cloned = clone $original;
$cloned->setName('Dolly');
echo $cloned->getName(); // Долли
echo $cloned->getCategory(); // Горная овечка
```
Также для модификации процедуры клонирования можно обратиться к магическому методу `__clone`.
**Когда использовать?**
Когда необходимый объект аналогичен уже существующему или когда создание с нуля дороже клонирования.
### image Одиночка
**Аналогия**
У страны может быть только один президент. Он должен действовать, когда того требуют обстоятельства и долг. В данном случае президент — одиночка.
**Вкратце**
Шаблон позволяет удостовериться, что создаваемый объект — единственный в своём классе.
**Википедия**
> Шаблон «Одиночка» позволяет ограничивать создание класса единственным объектом. Это удобно, когда для координации действий в рамках системы требуется, чтобы объект был единственным в своём классе.
На самом деле шаблон «Одиночка» считается антипаттерном, не следует им слишком увлекаться. Он необязательно плох и иногда бывает полезен. Но применяйте его с осторожностью, потому что «Одиночка» вносит в приложение глобальное состояние, так что изменение в одном месте может повлиять на все остальные случаи использования, а отлаживать такое — не самое простое занятие. Другие недостатки шаблона: он делает ваш код сильно связанным (tightly coupled), а создание прототипа (mocking) «Одиночки» может быть затруднено.
**Пример**
Сделайте конструктор приватным, отключите расширения и создайте статическую переменную для хранения экземпляра:
```
final class President
{
private static $instance;
private function __construct()
{
// Прячем конструктор
}
public static function getInstance(): President
{
if (!self::$instance) {
self::$instance = new self();
}
return self::$instance;
}
private function __clone()
{
// Отключаем клонирование
}
private function __wakeup()
{
// Отключаем десериализацию
}
}
```
Использование:
```
$president1 = President::getInstance();
$president2 = President::getInstance();
var_dump($president1 === $president2); // true
```
Структурные шаблоны проектирования
----------------------------------
**Вкратце**
Эти шаблоны в основном посвящены компоновке объектов (object composition). То есть тому, как сущности могут друг друга использовать. Ещё одно объяснение: структурные шаблоны помогают ответить на вопрос «Как построить программный компонент?»
**Википедия**
> Структурными называют шаблоны, которые облегчают проектирование, определяя простой способ реализации взаимоотношений между сущностями.
* [Адаптер](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles08bbdb0a708bbdb0a740d4129bea4f8fe9456e0d0png-adapter)
* [Мост](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles5730de7ab5730de7abc284e128bce7c4e5ea64913png-most)
* [Компоновщик](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles899fb76f3899fb76f3bbc4489a71f36d4c0b190f8png-komponovschik)
* [Декоратор](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles1d6a22eff1d6a22eff4b047e691417f69f37647f5png-dekorator)
* [Фасад](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesc1feaf9e9c1feaf9e90c0486fb48479326557424apng-fasad)
* [Приспособленец](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilese17d114ebe17d114eb9d645c7ab57f590a1aea3b3png-prisposoblenec)
* [Заместитель](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesa8ed1e294a8ed1e294f2842a0b4d066c471905962png-zamestitel)
### image Адаптер
**Аналогия**
Допустим, у вас на карте памяти есть какие-то картинки. Их нужно перенести на компьютер. Нужен адаптер, совместимый с входным портом компьютера, в который можно вставить карту памяти. В данном примере адаптер — это картридер. Ещё один пример: переходник, позволяющий использовать американский блок питания с российской розеткой. Третий пример: переводчик — это адаптер, соединяющий двух людей, говорящих на разных языках.
**Вкратце**
Шаблон «Адаптер» позволяет помещать несовместимый объект в обёртку, чтобы он оказался совместимым с другим классом.
**Википедия**
> Шаблон проектирования «Адаптер» позволяет использовать интерфейс существующего класса как другой интерфейс. Этот шаблон часто применяется для обеспечения работы одних классов с другими без изменения их исходного кода.
**Пример**
Представим себе охотника на львов.
Создадим интерфейс `Lion`, который реализует все типы львов.
```
interface Lion
{
public function roar();
}
class AfricanLion implements Lion
{
public function roar()
{
}
}
class AsianLion implements Lion
{
public function roar()
{
}
}
```
Охотник должен охотиться на все реализации интерфейса `Lion`.
```
class Hunter
{
public function hunt(Lion $lion)
{
}
}
```
Добавим теперь дикую собаку `WildDog`, на которую охотник тоже может охотиться. Но у нас не получится сделать это напрямую, потому что у собаки другой интерфейс. Чтобы она стала совместима с охотником, нужно создать подходящий адаптер.
```
// Это нужно добавить
class WildDog
{
public function bark()
{
}
}
// Адаптер вокруг собаки сделает её совместимой с охотником
class WildDogAdapter implements Lion
{
protected $dog;
public function __construct(WildDog $dog)
{
$this->dog = $dog;
}
public function roar()
{
$this->dog->bark();
}
}
```
Теперь `WildDog` может вступить в игру действие благодаря `WildDogAdapter`.
```
$wildDog = new WildDog();
$wildDogAdapter = new WildDogAdapter($wildDog);
$hunter = new Hunter();
$hunter->hunt($wildDogAdapter);
```
### image Мост
**Аналогия**
Допустим, у вас есть сайт с несколькими страницами. Вы хотите позволить пользователям менять темы оформления страниц. Как бы вы поступили? Создали множественные копии каждой страницы для каждой темы или просто сделали отдельные темы и подгружали их в соответствии с настройками пользователей? Шаблон «Мост» позволяет реализовать второй подход.
**Вкратце**
Шаблон «Мост» — это предпочтение компоновки наследованию. Подробности реализации передаются из одной иерархии другому объекту с отдельной иерархией.
**Википедия**
> Шаблон «Мост» означает отделение абстракции от реализации, чтобы их обе можно было изменять независимо друг от друга.
**Пример**
Реализуем вышеописанный пример с веб-страницами. Сделаем иерархию `WebPage`:
```
interface WebPage
{
public function __construct(Theme $theme);
public function getContent();
}
class About implements WebPage
{
protected $theme;
public function __construct(Theme $theme)
{
$this->theme = $theme;
}
public function getContent()
{
return "About page in " . $this->theme->getColor();
}
}
class Careers implements WebPage
{
protected $theme;
public function __construct(Theme $theme)
{
$this->theme = $theme;
}
public function getContent()
{
return "Careers page in " . $this->theme->getColor();
}
}
```
Отделим иерархию тем:
```
interface Theme
{
public function getColor();
}
class DarkTheme implements Theme
{
public function getColor()
{
return 'Dark Black';
}
}
class LightTheme implements Theme
{
public function getColor()
{
return 'Off white';
}
}
class AquaTheme implements Theme
{
public function getColor()
{
return 'Light blue';
}
}
```
Обе иерархии:
```
$darkTheme = new DarkTheme();
$about = new About($darkTheme);
$careers = new Careers($darkTheme);
echo $about->getContent(); // "About page in Dark Black";
echo $careers->getContent(); // "Careers page in Dark Black";
```
### image Компоновщик
**Аналогия**
Каждая компания состоит из сотрудников. У каждого сотрудника есть одни и те же свойства: зарплата, обязанности, отчётность перед кем-то, субординация...
**Вкратце**
Шаблон «Компоновщик» позволяет клиентам обрабатывать отдельные объекты в едином порядке.
**Википедия**
> Шаблон «Компоновщик» описывает общий порядок обработки группы объектов, словно это одиночный экземпляр объекта. Суть шаблона — компонование объектов в древовидную структуру для представления иерархии от частного к целому. Шаблон позволяет клиентам одинаково обращаться к отдельным объектам и к группам объектов.
**Пример**
Вот разные типы сотрудников:
```
interface Employee
{
public function __construct(string $name, float $salary);
public function getName(): string;
public function setSalary(float $salary);
public function getSalary(): float;
public function getRoles(): array;
}
class Developer implements Employee
{
protected $salary;
protected $name;
public function __construct(string $name, float $salary)
{
$this->name = $name;
$this->salary = $salary;
}
public function getName(): string
{
return $this->name;
}
public function setSalary(float $salary)
{
$this->salary = $salary;
}
public function getSalary(): float
{
return $this->salary;
}
public function getRoles(): array
{
return $this->roles;
}
}
class Designer implements Employee
{
protected $salary;
protected $name;
public function __construct(string $name, float $salary)
{
$this->name = $name;
$this->salary = $salary;
}
public function getName(): string
{
return $this->name;
}
public function setSalary(float $salary)
{
$this->salary = $salary;
}
public function getSalary(): float
{
return $this->salary;
}
public function getRoles(): array
{
return $this->roles;
}
}
```
А вот компания, которая состоит из сотрудников разных типов:
```
class Organization
{
protected $employees;
public function addEmployee(Employee $employee)
{
$this->employees[] = $employee;
}
public function getNetSalaries(): float
{
$netSalary = 0;
foreach ($this->employees as $employee) {
$netSalary += $employee->getSalary();
}
return $netSalary;
}
}
```
Использование:
```
// Подготовка сотрудников
$john = new Developer('John Doe', 12000);
$jane = new Designer('Jane Doe', 15000);
// Включение их в штат
$organization = new Organization();
$organization->addEmployee($john);
$organization->addEmployee($jane);
echo "Net salaries: " . $organization->getNetSalaries(); // Net Salaries: 27000
```
### image Декоратор
**Аналогия**
Допустим, у вас свой автосервис, оказывающий различные услуги. Как выставлять клиентам счёт? Добавлять последовательно услуги и их стоимость — и в конце концов получится итоговая сумма к оплате. Здесь каждый тип услуги — это «декоратор».
**Вкратце**
Шаблон «Декоратор» позволяет во время выполнения динамически изменять поведение объекта, обёртывая его в объект класса «декоратора».
**Википедия**
> Шаблон «Декоратор» позволяет подключать к объекту дополнительное поведение (статически или динамически), не влияя на поведение других объектов того же класса. Шаблон часто используется для соблюдения принципа единственной обязанности (Single Responsibility Principle), поскольку позволяет разделить функциональность между классами для решения конкретных задач.
**Пример**
Возьмём в качестве примера кофе. Сначала просто реализуем интерфейс:
```
interface Coffee
{
public function getCost();
public function getDescription();
}
class SimpleCoffee implements Coffee
{
public function getCost()
{
return 10;
}
public function getDescription()
{
return 'Simple coffee';
}
}
```
Можно сделать код расширяемым, чтобы при необходимости вносить модификации. Добавим «декораторы»:
```
class MilkCoffee implements Coffee
{
protected $coffee;
public function __construct(Coffee $coffee)
{
$this->coffee = $coffee;
}
public function getCost()
{
return $this->coffee->getCost() + 2;
}
public function getDescription()
{
return $this->coffee->getDescription() . ', milk';
}
}
class WhipCoffee implements Coffee
{
protected $coffee;
public function __construct(Coffee $coffee)
{
$this->coffee = $coffee;
}
public function getCost()
{
return $this->coffee->getCost() + 5;
}
public function getDescription()
{
return $this->coffee->getDescription() . ', whip';
}
}
class VanillaCoffee implements Coffee
{
protected $coffee;
public function __construct(Coffee $coffee)
{
$this->coffee = $coffee;
}
public function getCost()
{
return $this->coffee->getCost() + 3;
}
public function getDescription()
{
return $this->coffee->getDescription() . ', vanilla';
}
}
```
Теперь приготовим кофе:
```
$someCoffee = new SimpleCoffee();
echo $someCoffee->getCost(); // 10
echo $someCoffee->getDescription(); // Simple Coffee
$someCoffee = new MilkCoffee($someCoffee);
echo $someCoffee->getCost(); // 12
echo $someCoffee->getDescription(); // Simple Coffee, milk
$someCoffee = new WhipCoffee($someCoffee);
echo $someCoffee->getCost(); // 17
echo $someCoffee->getDescription(); // Simple Coffee, milk, whip
$someCoffee = new VanillaCoffee($someCoffee);
echo $someCoffee->getCost(); // 20
echo $someCoffee->getDescription(); // Simple Coffee, milk, whip, vanilla
```
### image Фасад
**Аналогия**
Как включить компьютер? Вы скажете: «Нажать кнопку включения». Это потому, что вы используете простой интерфейс, предоставляемый компьютером наружу. А внутри него происходит очень много процессов. Простой интерфейс для сложной подсистемы — это фасад.
**Вкратце**
Шаблон «Фасад» предоставляет упрощённый интерфейс для сложной подсистемы.
**Википедия**
> «Фасад» — это объект, предоставляющий упрощённый интерфейс для более крупного тела кода, например библиотеки классов.
**Пример**
Создадим класс computer:
```
class Computer
{
public function getElectricShock()
{
echo "Ouch!";
}
public function makeSound()
{
echo "Beep beep!";
}
public function showLoadingScreen()
{
echo "Loading..";
}
public function bam()
{
echo "Ready to be used!";
}
public function closeEverything()
{
echo "Bup bup bup buzzzz!";
}
public function sooth()
{
echo "Zzzzz";
}
public function pullCurrent()
{
echo "Haaah!";
}
}
```
Теперь «фасад»:
```
class ComputerFacade
{
protected $computer;
public function __construct(Computer $computer)
{
$this->computer = $computer;
}
public function turnOn()
{
$this->computer->getElectricShock();
$this->computer->makeSound();
$this->computer->showLoadingScreen();
$this->computer->bam();
}
public function turnOff()
{
$this->computer->closeEverything();
$this->computer->pullCurrent();
$this->computer->sooth();
}
}
```
Использование:
```
$computer = new ComputerFacade(new Computer());
$computer->turnOn(); // Ouch! Beep beep! Loading.. Ready to be used!
$computer->turnOff(); // Bup bup buzzz! Haah! Zzzzz
```
### image Приспособленец
**Аналогия**
Обычно в заведениях общепита чай заваривают не отдельно для каждого клиента, а сразу в некой крупной ёмкости. Это позволяет экономить ресурсы: газ/электричество, время и т. д. Шаблон «Приспособленец» как раз посвящён общему использованию (sharing).
**Вкратце**
Шаблон применяется для минимизирования использования памяти или вычислительной стоимости за счёт общего использования как можно большего количества одинаковых объектов.
**Википедия**
> «Приспособленец» — это объект, минимизирующий использование памяти за счёт общего с другими, такими же объектами использования как можно большего объёма данных. Это способ применения многочисленных объектов, когда простое повторяющееся представление приведёт к неприемлемому потреблению памяти.
**Пример**
Сделаем типы чая и чайника.
```
// Приспособленец — то, что будет закешировано.
// Типы чая здесь — приспособленцы.
class KarakTea
{
}
// Действует как фабрика и экономит чай
class TeaMaker
{
protected $availableTea = [];
public function make($preference)
{
if (empty($this->availableTea[$preference])) {
$this->availableTea[$preference] = new KarakTea();
}
return $this->availableTea[$preference];
}
}
```
Сделаем забегаловку `TeaShop`, принимающую и обрабатывающую заказы:
```
class TeaShop
{
protected $orders;
protected $teaMaker;
public function __construct(TeaMaker $teaMaker)
{
$this->teaMaker = $teaMaker;
}
public function takeOrder(string $teaType, int $table)
{
$this->orders[$table] = $this->teaMaker->make($teaType);
}
public function serve()
{
foreach ($this->orders as $table => $tea) {
echo "Serving tea to table# " . $table;
}
}
}
```
Использование:
```
$teaMaker = new TeaMaker();
$shop = new TeaShop($teaMaker);
$shop->takeOrder('less sugar', 1);
$shop->takeOrder('more milk', 2);
$shop->takeOrder('without sugar', 5);
$shop->serve();
// Serving tea to table# 1
// Serving tea to table# 2
// Serving tea to table# 5
```
### image Заместитель
**Аналогия**
Открыть дверь с электронным замком можно с помощью карточки доступа (access card) или кнопки для обхода системы безопасности. То есть основная функциональность двери — открыться, а поверх неё может быть ещё какая-то функциональность — «заместитель».
**Вкратце**
С помощью шаблона «Заместитель» класс представляет функциональность другого класса.
**Википедия**
> В наиболее общей форме «Заместитель» — это класс, функционирующий как интерфейс к чему-либо. Это оболочка или объект-агент, вызываемый клиентом для получения доступа к другому, «настоящему» объекту. «Заместитель» может просто переадресовывать запросы настоящему объекту, а может предоставлять дополнительную логику: кеширование данных при интенсивном выполнении операций или потреблении ресурсов настоящим объектом; проверка предварительных условий (preconditions) до вызова выполнения операций настоящим объектом.
**Пример**
Реализуем интерфейс двери и саму дверь:
```
interface Door
{
public function open();
public function close();
}
class LabDoor implements Door
{
public function open()
{
echo "Opening lab door";
}
public function close()
{
echo "Closing the lab door";
}
}
```
Сделаем «заместителя», чтобы дверь могла выполнять защитную функцию:
```
class Security
{
protected $door;
public function __construct(Door $door)
{
$this->door = $door;
}
public function open($password)
{
if ($this->authenticate($password)) {
$this->door->open();
} else {
echo "Big no! It ain't possible.";
}
}
public function authenticate($password)
{
return $password === '$ecr@t';
}
public function close()
{
$this->door->close();
}
}
```
Использование:
```
$door = new Security(new LabDoor());
$door->open('invalid'); // Big no! It ain't possible.
$door->open('$ecr@t'); // Opening lab door
$door->close(); // Closing lab door
```
Ещё один пример связан с реализацией преобразователя данных (data-mapper). С помощью этого шаблона я недавно сделал ODM (Object Data Mapper) для MongoDB. Я написал «заместителя» вокруг mongo-классов, воспользовавшись волшебным методом `__call()`. Все вызовы методов проходили к оригинальным mongo-классам через «заместителя», а извлечённые результаты возвращались как есть. Только в случае с `find` или `findOne` данные преобразовывались в объекты требуемого класса, которые возвращались вместо `Cursor`.
Поведенческие шаблоны проектирования
------------------------------------
**Вкратце**
Они связаны с присвоением обязанностей (responsibilities) объектам. От структурных шаблонов они отличаются тем, что не просто описывают структуру, но и очерчивают шаблоны передачи данных, обеспечения взаимодействия. То есть поведенческие шаблоны позволяют ответить на вопрос «Как реализовать поведение в программном компоненте?»
**Википедия**
> Поведенческие шаблоны проектирования определяют алгоритмы и способы реализации взаимодействия различных объектов и классов. Они обеспечивают гибкость взаимодействия между объектами.
* [Цепочка ответственности](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles8fc3f4f858fc3f4f85cd240bf9628c2c6e5728e2cpng-cepochka-otvetstvennosti)
* [Команда](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles8d2e5082a8d2e5082afd747d4aee91ca0e48113c4png-komanda)
* [Итератор](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles625e57fc3625e57fc3cfa494da9b770f93f5322b0png-iterator)
* [Посредник](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles4358f59fc4358f59fcb634418a9dc22bce47b0720png-posrednik)
* [Хранитель](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesf1c4c72d2f1c4c72d22204ce08703d3a196fa9908png-hranitel)
* [Наблюдатель](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesd7bce8a7ed7bce8a7e9cd4ed989a08d5f21c16f75png-nablyudatel)
* [Посетитель](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles735be130d735be130d5514a59a834860596a6087bpng-posetitel)
* [Стратегия](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles0ff1d477c0ff1d477ce4d4e2ca81d427ce072a757png-strategiya)
* [Состояние](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfiles375200f5a375200f5aa9c444aa74eac8813c00af5png-sostoyanie)
* [Шаблонный метод](https://habrahabr.ru/company/mailru/blog/325492/#imagehttpshabrastorageorgfilesdc3e84492dc3e84492b0f47e0954fd7454fcad987png-shablonnyy-metod)
### image Цепочка ответственности
**Аналогия**
Допустим, для вашего банковского счёта доступны три способа оплаты (`A`, `B` и `C`). Каждый подразумевает разные доступные суммы денег: `A` — 100 долларов, `B` — 300, `C` — 1000. Приоритетность способов при оплате: А, затем В, затем С. Вы пытаетесь купить что-то за 210 долларов. На основании «цепочки ответственности» система попытается оплатить способом А. Если денег хватает — то оплата проходит, а цепочка прерывается. Если денег не хватает — то система переходит к способу В, и т. д.
**Вкратце**
Шаблон «Цепочка ответственности» позволяет создавать цепочки объектов. Запрос входит с одного конца цепочки и движется от объекта к объекту, пока не будет найден подходящий обработчик.
**Википедия**
> Шаблон «Цепочка ответственности» содержит исходный управляющий объект и ряд обрабатывающих объектов. Каждый обрабатывающий объект содержит логику, определяющую типы командных объектов, которые он может обрабатывать, а остальные передаются по цепочке следующему обрабатывающему объекту.
**Пример**
Создадим основной банковский счёт, содержащий логику связывания счетов в цепочки, и сами счета.
```
abstract class Account
{
protected $successor;
protected $balance;
public function setNext(Account $account)
{
$this->successor = $account;
}
public function pay(float $amountToPay)
{
if ($this->canPay($amountToPay)) {
echo sprintf('Paid %s using %s' . PHP_EOL, $amountToPay, get_called_class());
} elseif ($this->successor) {
echo sprintf('Cannot pay using %s. Proceeding ..' . PHP_EOL, get_called_class());
$this->successor->pay($amountToPay);
} else {
throw new Exception('None of the accounts have enough balance');
}
}
public function canPay($amount): bool
{
return $this->balance >= $amount;
}
}
class Bank extends Account
{
protected $balance;
public function __construct(float $balance)
{
$this->balance = $balance;
}
}
class Paypal extends Account
{
protected $balance;
public function __construct(float $balance)
{
$this->balance = $balance;
}
}
class Bitcoin extends Account
{
protected $balance;
public function __construct(float $balance)
{
$this->balance = $balance;
}
}
```
Теперь с помощью определённых выше линков (Bank, Paypal, Bitcoin) подготовим цепочку:
```
// Сделаем такую цепочку
// $bank->$paypal->$bitcoin
//
// Приоритет у банка
// Если банк не может оплатить, переходим к Paypal
// Если Paypal не может, переходим к Bitcoin
$bank = new Bank(100); // У банка баланс 100
$paypal = new Paypal(200); // У Paypal баланс 200
$bitcoin = new Bitcoin(300); // У Bitcoin баланс 300
$bank->setNext($paypal);
$paypal->setNext($bitcoin);
// Начнём с банка
$bank->pay(259);
// Выходной вид
// ==============
// Нельзя оплатить с помощью банка. Обрабатываю...
// Нельзя оплатить с помощью Paypal. Обрабатываю...
// Оплачено 259 с помощью Bitcoin!
```
### image Команда
**Аналогия**
Вы пришли в ресторан. Вы (`Client`) просите официанта (`Invoker`) принести блюда (`Command`). Официант перенаправляет запрос шеф-повару (`Receiver`), который знает, что и как готовить. Другой пример: вы (`Client`) включаете (`Command`) телевизор (`Receiver`) с помощью пульта (`Invoker`).
**Вкратце**
Шаблон «Команда» позволяет инкапсулировать действия в объекты. Ключевая идея — предоставить средства отделения клиента от получателя.
**Википедия**
> В шаблоне «Команда» объект используется для инкапсуляции всей информации, необходимой для выполнения действия либо для его инициирования позднее. Информация включает в себя имя метода; объект, владеющий методом; значения параметров метода.
**Пример**
Сначала сделаем получателя, содержащего реализации каждого действия, которое может быть выполнено.
```
// Receiver
class Bulb
{
public function turnOn()
{
echo "Bulb has been lit";
}
public function turnOff()
{
echo "Darkness!";
}
}
```
Теперь сделаем интерфейс, который будет реализовывать каждая команда. Также сделаем набор команд.
```
interface Command
{
public function execute();
public function undo();
public function redo();
}
// Command
class TurnOn implements Command
{
protected $bulb;
public function __construct(Bulb $bulb)
{
$this->bulb = $bulb;
}
public function execute()
{
$this->bulb->turnOn();
}
public function undo()
{
$this->bulb->turnOff();
}
public function redo()
{
$this->execute();
}
}
class TurnOff implements Command
{
protected $bulb;
public function __construct(Bulb $bulb)
{
$this->bulb = $bulb;
}
public function execute()
{
$this->bulb->turnOff();
}
public function undo()
{
$this->bulb->turnOn();
}
public function redo()
{
$this->execute();
}
}
```
Теперь сделаем вызывающего `Invoker`, с которым будет взаимодействовать клиент для обработки команд.
```
// Invoker
class RemoteControl
{
public function submit(Command $command)
{
$command->execute();
}
}
```
Посмотрим, как всё это может использовать клиент:
```
$bulb = new Bulb();
$turnOn = new TurnOn($bulb);
$turnOff = new TurnOff($bulb);
$remote = new RemoteControl();
$remote->submit($turnOn); // Лампочка зажглась!
$remote->submit($turnOff); // Темнота!
```
Шаблон «Команда» можно использовать и для реализации системы на основе транзакций. То есть системы, в которой вы сохраняете историю команд по мере их выполнения. Если последняя команда выполнена успешно, то всё хорошо. В противном случае система итерирует по истории и делает `undo` для всех выполненных команд.
### image Итератор
**Аналогия**
Хороший пример — радиоприёмник. Вы начинаете с какой-то радиостанции, а затем перемещаетесь по станциям вперёд/назад. То есть устройство предоставляет интерфейс для итерирования по каналам.
**Вкратце**
Шаблон — это способ доступа к элементам объекта без раскрытия базового представления.
**Википедия**
> В этом шаблоне итератор используется для перемещения по контейнеру и обеспечения доступа к элементам контейнера. Шаблон подразумевает отделение алгоритмов от контейнера. В каких-то случаях алгоритмы, специфичные для этого контейнера, не могут быть отделены.
**Пример**
В PHP довольно легко реализовать этот шаблон с помощью стандартной библиотеки PHP. Сначала создадим радиостанцию `RadioStation`.
```
class RadioStation
{
protected $frequency;
public function __construct(float $frequency)
{
$this->frequency = $frequency;
}
public function getFrequency(): float
{
return $this->frequency;
}
}
```
Теперь создадим итератор:
```
use Countable;
use Iterator;
class StationList implements Countable, Iterator
{
/** @var RadioStation[] $stations */
protected $stations = [];
/** @var int $counter */
protected $counter;
public function addStation(RadioStation $station)
{
$this->stations[] = $station;
}
public function removeStation(RadioStation $toRemove)
{
$toRemoveFrequency = $toRemove->getFrequency();
$this->stations = array_filter($this->stations, function (RadioStation $station) use ($toRemoveFrequency) {
return $station->getFrequency() !== $toRemoveFrequency;
});
}
public function count(): int
{
return count($this->stations);
}
public function current(): RadioStation
{
return $this->stations[$this->counter];
}
public function key()
{
return $this->counter;
}
public function next()
{
$this->counter++;
}
public function rewind()
{
$this->counter = 0;
}
public function valid(): bool
{
return isset($this->stations[$this->counter]);
}
}
```
Использование:
```
$stationList = new StationList();
$stationList->addStation(new RadioStation(89));
$stationList->addStation(new RadioStation(101));
$stationList->addStation(new RadioStation(102));
$stationList->addStation(new RadioStation(103.2));
foreach($stationList as $station) {
echo $station->getFrequency() . PHP_EOL;
}
$stationList->removeStation(new RadioStation(89)); // Will remove station 89
```
### image Посредник
**Аналогия**
Когда вы говорите с кем-то по мобильнику, то между вами и собеседником находится мобильный оператор. То есть сигнал передаётся через него, а не напрямую. В данном примере оператор — посредник.
**Вкратце**
Шаблон «Посредник» подразумевает добавление стороннего объекта («посредника») для управления взаимодействием между двумя объектами («коллегами»). Шаблон помогает уменьшить связанность (coupling) классов, общающихся друг с другом, ведь теперь они не должны знать о реализациях своих собеседников.
**Википедия**
> Шаблон определяет объект, который инкапсулирует способ взаимодействия набора объектов.
**Пример**
Простейший пример: чат («посредник»), в котором пользователи («коллеги») отправляют друг другу сообщения.
Создадим «посредника»:
```
interface ChatRoomMediator
{
public function showMessage(User $user, string $message);
}
// Посредник
class ChatRoom implements ChatRoomMediator
{
public function showMessage(User $user, string $message)
{
$time = date('M d, y H:i');
$sender = $user->getName();
echo $time . '[' . $sender . ']:' . $message;
}
}
```
Теперь создадим «коллег»:
```
class User {
protected $name;
protected $chatMediator;
public function __construct(string $name, ChatRoomMediator $chatMediator) {
$this->name = $name;
$this->chatMediator = $chatMediator;
}
public function getName() {
return $this->name;
}
public function send($message) {
$this->chatMediator->showMessage($this, $message);
}
}
```
Использование:
```
$mediator = new ChatRoom();
$john = new User('John Doe', $mediator);
$jane = new User('Jane Doe', $mediator);
$john->send('Hi there!');
$jane->send('Hey!');
// Выходной вид
// Feb 14, 10:58 [John]: Hi there!
// Feb 14, 10:58 [Jane]: Hey!
```
### image Хранитель
**Аналогия**
В качестве примера можно привести калькулятор («создатель»), у которого любая последняя выполненная операция сохраняется в памяти («хранитель»), чтобы вы могли снова вызвать её с помощью каких-то кнопок («опекун»).
**Вкратце**
Шаблон «Хранитель» фиксирует и хранит текущее состояние объекта, чтобы оно легко восстанавливалось.
**Википедия**
> Шаблон «Хранитель» позволяет восстанавливать объект в его предыдущем состоянии (отмена через откат — undo via rollback).
Обычно шаблон применяется, когда нужно реализовать функциональность отмены операции.
**Пример**
Текстовый редактор время от времени сохраняет своё состояние, чтобы можно было восстановить текст в каком-то прошлом виде.
Сначала создадим объект «хранитель», в котором можно сохранять состояние редактора.
```
class EditorMemento
{
protected $content;
public function __construct(string $content)
{
$this->content = $content;
}
public function getContent()
{
return $this->content;
}
}
```
Теперь сделаем редактор («создатель»), который будет использовать объект «хранитель».
```
class Editor
{
protected $content = '';
public function type(string $words)
{
$this->content = $this->content . ' ' . $words;
}
public function getContent()
{
return $this->content;
}
public function save()
{
return new EditorMemento($this->content);
}
public function restore(EditorMemento $memento)
{
$this->content = $memento->getContent();
}
}
```
Использование:
```
$editor = new Editor();
// Пишем что-нибудь
$editor->type('This is the first sentence.');
$editor->type('This is second.');
// Сохранение состояния в: This is the first sentence. This is second.
$saved = $editor->save();
// Пишем ещё
$editor->type('And this is third.');
// Output: Содержимое до сохранения
echo $editor->getContent(); // This is the first sentence. This is second. And this is third.
// Восстанавливаем последнее сохранённое состояние
$editor->restore($saved);
$editor->getContent(); // This is the first sentence. This is second.
```
### image Наблюдатель
**Аналогия**
Хороший пример: люди, ищущие работу, подписываются на публикации на сайтах вакансий и получают уведомления, когда появляются вакансии, подходящие по параметрам.
**Вкратце**
Шаблон определяет зависимость между объектами, чтобы при изменении состояния одного из них его «подчинённые» узнавали об этом.
**Википедия**
> В шаблоне «Наблюдатель» есть объект («субъект»), ведущий список своих «подчинённых» («наблюдателей») и автоматически уведомляющий их о любом изменении своего состояния, обычно с помощью вызова одного из их методов.
**Пример**
Сначала реализуем людей, ищущих работу, которых нужно уведомлять о появлении вакансий.
```
class JobPost
{
protected $title;
public function __construct(string $title)
{
$this->title = $title;
}
public function getTitle()
{
return $this->title;
}
}
class JobSeeker implements Observer
{
protected $name;
public function __construct(string $name)
{
$this->name = $name;
}
public function onJobPosted(JobPost $job)
{
// Do something with the job posting
echo 'Hi ' . $this->name . '! New job posted: '. $job->getTitle();
}
}
```
Теперь реализуем публикации вакансий, на которые люди будут подписываться.
```
class JobPostings implements Observable
{
protected $observers = [];
protected function notify(JobPost $jobPosting)
{
foreach ($this->observers as $observer) {
$observer->onJobPosted($jobPosting);
}
}
public function attach(Observer $observer)
{
$this->observers[] = $observer;
}
public function addJob(JobPost $jobPosting)
{
$this->notify($jobPosting);
}
}
```
Использование:
```
// Создаём подписчиков
$johnDoe = new JobSeeker('John Doe');
$janeDoe = new JobSeeker('Jane Doe');
// Создаём публикатора и прикрепляем подписчиков
$jobPostings = new JobPostings();
$jobPostings->attach($johnDoe);
$jobPostings->attach($janeDoe);
// Добавляем новую вакансию и смотрим, будут ли уведомлены подписчики
$jobPostings->addJob(new JobPost('Software Engineer'));
// Output
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer
```
### image Посетитель
**Аналогия**
Туристы собрались в Дубай. Сначала им нужен способ попасть туда (виза). После прибытия они будут посещать любую часть города, не спрашивая разрешения, ходить где вздумается. Просто скажите им о каком-нибудь месте — и туристы могут там побывать. Шаблон «Посетитель» помогает добавлять места для посещения.
**Вкратце**
Шаблон «Посетитель» позволяет добавлять будущие операции для объектов без их модифицирования.
**Википедия**
> Шаблон «Посетитель» — это способ отделения алгоритма от структуры объекта, в которой он оперирует. Результат отделения — возможность добавлять новые операции в существующие структуры объектов без их модифицирования. Это один из способов соблюдения принципа открытости/закрытости (open/closed principle).
**Пример**
Возьмём зоопарк: у нас есть несколько видов животных, и нам нужно послушать издаваемые ими звуки.
```
// Место посещения
interface Animal
{
public function accept(AnimalOperation $operation);
}
// Посетитель
interface AnimalOperation
{
public function visitMonkey(Monkey $monkey);
public function visitLion(Lion $lion);
public function visitDolphin(Dolphin $dolphin);
}
```
Реализуем животных:
```
class Monkey implements Animal
{
public function shout()
{
echo 'Ooh oo aa aa!';
}
public function accept(AnimalOperation $operation)
{
$operation->visitMonkey($this);
}
}
class Lion implements Animal
{
public function roar()
{
echo 'Roaaar!';
}
public function accept(AnimalOperation $operation)
{
$operation->visitLion($this);
}
}
class Dolphin implements Animal
{
public function speak()
{
echo 'Tuut tuttu tuutt!';
}
public function accept(AnimalOperation $operation)
{
$operation->visitDolphin($this);
}
}
```
Реализуем посетителя:
```
class Speak implements AnimalOperation
{
public function visitMonkey(Monkey $monkey)
{
$monkey->shout();
}
public function visitLion(Lion $lion)
{
$lion->roar();
}
public function visitDolphin(Dolphin $dolphin)
{
$dolphin->speak();
}
}
```
Использование:
```
$monkey = new Monkey();
$lion = new Lion();
$dolphin = new Dolphin();
$speak = new Speak();
$monkey->accept($speak); // Уа-уа-уааааа!
$lion->accept($speak); // Ррррррррр!
$dolphin->accept($speak); // Туут тутт туутт!
```
Это можно было сделать просто с помощью иерархии наследования, но тогда пришлось бы модифицировать животных при каждом добавлении к ним новых действий. А здесь менять их не нужно. Например, мы можем добавить животным прыжки, просто создав нового посетителя:
```
class Jump implements AnimalOperation
{
public function visitMonkey(Monkey $monkey)
{
echo 'Jumped 20 feet high! on to the tree!';
}
public function visitLion(Lion $lion)
{
echo 'Jumped 7 feet! Back on the ground!';
}
public function visitDolphin(Dolphin $dolphin)
{
echo 'Walked on water a little and disappeared';
}
}
```
Использование:
```
$jump = new Jump();
$monkey->accept($speak); // Ooh oo aa aa!
$monkey->accept($jump); // Jumped 20 feet high! on to the tree!
$lion->accept($speak); // Roaaar!
$lion->accept($jump); // Jumped 7 feet! Back on the ground!
$dolphin->accept($speak); // Tuut tutt tuutt!
$dolphin->accept($jump); // Walked on water a little and disappeared
```
### image Стратегия
**Аналогия**
Возьмём пример с пузырьковой сортировкой. Мы её реализовали, но с ростом объёмов данных сортировка стала выполняться очень медленно. Тогда мы сделали быструю сортировку (Quick sort). Алгоритм работает быстрее на больших объёмах, но на маленьких он очень медленный. Тогда мы реализовали стратегию, при которой для маленьких объёмов данных используется пузырьковая сортировка, а для больших — быстрая.
**Вкратце**
Шаблон «Стратегия» позволяет переключаться между алгоритмами или стратегиями в зависимости от ситуации.
**Википедия**
> Шаблон «Стратегия» позволяет при выполнении выбирать поведение алгоритма.
**Пример**
Возьмём вышеописанный пример. Сначала сделаем интерфейс стратегии и реализации самих стратегий.
```
interface SortStrategy
{
public function sort(array $dataset): array;
}
class BubbleSortStrategy implements SortStrategy
{
public function sort(array $dataset): array
{
echo "Sorting using bubble sort";
// Do sorting
return $dataset;
}
}
class QuickSortStrategy implements SortStrategy
{
public function sort(array $dataset): array
{
echo "Sorting using quick sort";
// Do sorting
return $dataset;
}
}
```
Теперь реализуем клиента, который будет использовать нашу стратегию.
```
class Sorter
{
protected $sorter;
public function __construct(SortStrategy $sorter)
{
$this->sorter = $sorter;
}
public function sort(array $dataset): array
{
return $this->sorter->sort($dataset);
}
}
```
Использование:
```
$dataset = [1, 5, 4, 3, 2, 8];
$sorter = new Sorter(new BubbleSortStrategy());
$sorter->sort($dataset); // Output : Пузырьковая сортировка
$sorter = new Sorter(new QuickSortStrategy());
$sorter->sort($dataset); // Output : Быстрая сортировка
```
### image Состояние
**Аналогия**
Допустим, в графическом редакторе вы выбрали инструмент «Кисть». Она меняет своё поведение в зависимости от настройки цвета: т. е. рисует линию выбранного цвета.
**Вкратце**
Шаблон позволяет менять поведение класса при изменении состояния.
**Википедия**
> Шаблон «Состояние» реализует машину состояний объектно ориентированным способом. Это достигается с помощью:
>
> * реализации каждого состояния в виде производного класса интерфейса шаблона «Состояние»,
> * реализации переходов состояний (state transitions) посредством вызова методов, определённых вышестоящим классом (superclass).
>
>
>
>
>
> Шаблон «Состояние» — это в некотором плане шаблон «Стратегия», при котором возможно переключение текущей стратегии с помощью вызова методов, определённых в интерфейсе шаблона.
**Пример**
Текстовый редактор меняет состояние текста, который вы печатаете, т. е. если выбрано полужирное начертание — то редактор печатает полужирным и т. д.
Сначала сделаем интерфейс состояний и сами состояния:
```
interface WritingState
{
public function write(string $words);
}
class UpperCase implements WritingState
{
public function write(string $words)
{
echo strtoupper($words);
}
}
class LowerCase implements WritingState
{
public function write(string $words)
{
echo strtolower($words);
}
}
class Default implements WritingState
{
public function write(string $words)
{
echo $words;
}
}
```
Сделаем редактор:
```
class TextEditor
{
protected $state;
public function __construct(WritingState $state)
{
$this->state = $state;
}
public function setState(WritingState $state)
{
$this->state = $state;
}
public function type(string $words)
{
$this->state->write($words);
}
}
```
Использование:
```
$editor = new TextEditor(new Default());
$editor->type('First line');
$editor->setState(new UpperCase());
$editor->type('Second line');
$editor->type('Third line');
$editor->setState(new LowerCase());
$editor->type('Fourth line');
$editor->type('Fifth line');
// Output:
// First line
// SECOND LINE
// THIRD LINE
// fourth line
// fifth line
```
### image Шаблонный метод
**Аналогия**
Допустим, вы собрались строить дома. Этапы будут такими:
* Подготовка фундамента.
* Возведение стен.
* Настил крыши.
* Настил перекрытий.
Порядок этапов никогда не меняется. Вы не настелите крышу до возведения стен — и т. д. Но каждый этап модифицируется: стены, например, можно возвести из дерева, кирпича или газобетона.
**Вкратце**
«Шаблонный метод» определяет каркас выполнения определённого алгоритма, но реализацию самих этапов делегирует дочерним классам.
**Википедия**
> «Шаблонный метод» — это поведенческий шаблон, определяющий основу алгоритма и позволяющий наследникам переопределять некоторые шаги алгоритма, не изменяя его структуру в целом.
**Пример**
Допустим, у нас есть программный инструмент, позволяющий тестировать, проводить контроль качества кода (lint), выполнять сборку, генерировать отчёты сборки (отчёты о покрытии кода, о качестве кода и т. д.), а также развёртывать приложение на тестовом сервере.
Сначала наш базовый класс определяет каркас алгоритма сборки.
```
abstract class Builder
{
// Шаблонный метод
final public function build()
{
$this->test();
$this->lint();
$this->assemble();
$this->deploy();
}
abstract public function test();
abstract public function lint();
abstract public function assemble();
abstract public function deploy();
}
```
Теперь создаём реализации:
```
class AndroidBuilder extends Builder
{
public function test()
{
echo 'Running android tests';
}
public function lint()
{
echo 'Linting the android code';
}
public function assemble()
{
echo 'Assembling the android build';
}
public function deploy()
{
echo 'Deploying android build to server';
}
}
class IosBuilder extends Builder
{
public function test()
{
echo 'Running ios tests';
}
public function lint()
{
echo 'Linting the ios code';
}
public function assemble()
{
echo 'Assembling the ios build';
}
public function deploy()
{
echo 'Deploying ios build to server';
}
}
```
Использование:
```
$androidBuilder = new AndroidBuilder();
$androidBuilder->build();
// Output:
// Выполнение Android-тестов
// Линтинг Android-кода
// Создание Android-сборки
// Развёртывание Android-сборки на сервере
$iosBuilder = new IosBuilder();
$iosBuilder->build();
// Output:
// Выполнение iOS-тестов
// Линтинг iOS-кода
// Создание iOS-сборки
// Развёртывание iOS-сборки на сервере
```
### image Закругляемся
На этом обзор закончен. Я продолжу его улучшать и планирую написать главы про архитектурные шаблоны. Так что периодически заглядывайте. | https://habr.com/ru/post/325492/ | null | ru | null |
# Ввод-вывод — уже не узкое место
На собеседованиях с программистами я часто прошу их написать простую программу, подсчитывающую частотность слов в текстовом файле. Это хорошая задача, проверяющая множество навыков, а уточняющие вопросы позволяют зайти на удивление глубоко.
Один из моих уточняющих вопросов такой: «Что является узким местом производительности вашей программы?» Многие отвечают что-то типа «считывание из входящего файла».
На самом деле, написать эту статью меня вдохновил ответ на чей-то вопрос в Gopher Slack: «Я заметил, что много дополнительной работы приходится на разделение строки и тому подобное, но обычно всё это намного быстрее ввода-вывода, поэтому нас это не волнует».
Я не стал спорить… и пока не [проанализировал производительность](https://benhoyt.com/writings/count-words/) задачи с подсчётом слов, думал так же. Ведь всех нас этому учили, правда? «Ввод-вывод — это медленно».
Но это больше не так! Дисковый ввод-вывод мог быть медленным 10-20 лет назад, но 2022 году **последовательное считывание файла с диска выполняется очень быстро.**
Насколько же быстро? Я протестировал скорость чтения и записи моего ноутбука при помощи [этой методики](https://www.shellhacks.com/disk-speed-test-read-write-hdd-ssd-perfomance-linux/), но с параметром `count=4096`, то есть с чтением и записью 4 ГБ. Вот результаты, полученные на моём Dell XPS 13 Plus 2022 года с накопителем Samsung PM9A1 NVMe и Ubuntu 22.04:
| Тип ввода-вывода | Скорость (ГБ/с) |
| --- | --- |
| Чтение (без кэширования) | 1,7 |
| Чтение (с кэшированием) | 10,8 |
| Запись (с учётом времени синхронизации) | 1,2 |
| Запись (без учёта синхронизации) | 1,6 |
Разумеется, системные вызовы относительно медленны, но при последовательном чтении или записи один syscall нужно выполнять через каждые 4 КБ или 64 КБ (или другую величину, в зависимости от размера буфера). А ввод-вывод по сети по-прежнему медленный, особенно в нелокальной сети.
Так что же *является* узким местом в программе, считающей частотность слов? Это обработка или парсинг входящих данных, а также соответствующее распределение памяти: разбиение входящих данных на слова, преобразование в нижний регистр и подсчёт частотностей при помощи таблицы хэшей.
Я модифицировал свои программы подсчёта слов на Python и Go так, чтобы фиксировать время разных этапов процесса: считывания входящих данных, обработки (медленная часть), сортировки по самым частым элементам и вывода. Потом выполнил проверку на текстовом файле размером 413 МБ, то есть на приличном объёме входящих данных (100 конкатенированных копий [текста Библии короля Якова](https://www.gutenberg.org/cache/epub/10/pg10.txt)).
Ниже показаны усреднённые результаты трёх лучших прогонов в секундах:
| Этап | Python | Go (простая) | Go (оптимизированная) |
| --- | --- | --- | --- |
| Чтение | 0,384 | 0,499 | 0,154 |
| Обработка | 7,980 | 3,492 | 2,249 |
| Сортировка | 0,005 | 0,002 | 0,002 |
| Вывод | 0,010 | 0,009 | 0,010 |
| **Всего** | 8,386 | 4,000 | 2,414 |
Сортировка и вывод занимают пренебрежимо мало времени: так как входящие данные состоят из 100 копий, количество уникальных слов относительно невелико. Примечание: это приводит к ещё одному уточняющему вопросу на собеседовании. Некоторые кандидаты говорят, что узким местом будет сортировка, потому что её сложность O(N log N), а не обработка входящих данных, сложность которой O(N). Однако здесь легко забыть, что мы имеем дело с двумя разными N: общим количеством слов в файле и количеством уникальных слов.
Внутренняя работа [версии на Python](https://github.com/benhoyt/io-performance/blob/master/simple.py) сводится к нескольким строкам кода:
```
content = sys.stdin.read()
counts = collections.Counter(content.lower().split())
most_common = counts.most_common()
for word, count in most_common:
print(word, count)
```
На Python запросто можно выполнять построчное чтение, однако это немного медленнее, поэтому здесь я просто считываю весь файл в память и обрабатываю его за раз.
В [простой версии на Go](https://github.com/benhoyt/io-performance/blob/master/simple.go) используется тот же подход, однако стандартная библиотека Go не содержит [`collections.Counter`](https://docs.python.org/3/library/collections.html#collections.Counter), поэтому выполнять сортировку «самых частых» нам нужно самостоятельно.
[Оптимизированная версия на Go](https://github.com/benhoyt/io-performance/blob/master/optimized.go) существенно быстрее, однако и гораздо сложнее. Мы избегаем большинства распределений памяти, выполняя преобразования в нижний регистр и разделяя текст на слова *с замещением*. Это хорошее эмпирическое правило для оптимизации кода с интенсивными вычислениями: снижайте количество распределений памяти. Информацию о том, как это профилировать, читайте в моей [статье об оптимизации подсчёта количества слов](https://benhoyt.com/writings/count-words/).
Я не показал оптимизированную версию на Python, потому что сложно оптимизировать Python ещё сильнее! (Время снизилось с 8,4 до 7,5 секунды). Код уже и так быстр, потому что базовые операции выполняются в коде на C; именно поэтому часто не важно, что «Python медленный».
Как видите, дисковый ввод-вывод в простой версии на Go занимает всего 14% от времени выполнения. В оптимизированной версии мы ускорили и чтение, и обработку, и дисковый ввод-вывод занимает всего 7% от общего времени.
Какой же я делаю вывод? Если вы обрабатываете «big data», то дисковый ввод-вывод, вероятно, не будет узким местом. Даже поверхностные измерения дадут понять, что основное время тратится на парсинг и распределение памяти. | https://habr.com/ru/post/702026/ | null | ru | null |
# Альтернатива UISplitViewController (отображение MasterView в книжной ориентации устройства)
Как было замечено в статье [“Всплывающие окна. Работа с UIPopoverController”](http://habrahabr.ru/blogs/macosxdev/91094/) в iPhone SDK 3.2 были добавлены новые элементы интерфейса: UIPopoverController и UISplitViewController. О первом из них уже довольно подробно рассказано на хабре. Я же хочу поговорить о UISplitViewController, верней о некой альтернативе.
“Зачем же нужна эта альтернатива?”, — спросите Вы, — “какова причина?”. Все дело в особенности поведения SplitView, вот выдержка из SDK: “Both view controllers are displayed in landscape orientations but only the detail view controller is displayed in portrait orientations”. Т.е. при книжной ориентации правая часть (MasterView) попросту прячется(см. рис. 1)
[](http://hotimg23.fotki.com/p/a/195_39/211_226/split_landscape.jpg "FREE Fotki Image Hosting") [](http://hotimg23.fotki.com/p/a/195_39/211_226/split_port.jpg "FREE Fotki Image Hosting")
*Рисунок 1 — SplitView в альбомной (а) и книжной (б) ориентации*
Посмотрев на Основные настройки iPad мы увидим совсем другую картину: и в книжной и в альбомной ориентации левая часть (MasterView) отображается одинаково (не прячется)
[](http://hotimg23.fotki.com/p/a/195_39/211_226/pref_general.jpg "FREE Fotki Image Hosting")
*Рисунок 2 — Основные настройки iPad*
Ну что ж, построим свой SplitView, ~~где бы левая часть не пряталась~~ с блекджеком и шлюхами, ~~хотя к черту SplitView и блэкджек~~.
Начнем с создания нового проекта в Xcode(View-based Application). Я дал ему название AlternativeSplit (см. Рис 3).
[](http://hotimg23.fotki.com/p/a/195_39/211_226/new_project.jpg "FREE Fotki Image Hosting")
*Рисунок 3- Создание нового проекта*
Далее добавим в проект два новых класса MasterViewController (subclass of UITableViewController) и DetailViewController (subclass of UIViewController), выбрав в меню File->New file… ->Cocoa Touch Class-> UIViewController subclass.
Откроем AlternativeSplitViewController.xib в InterfaceBuilder и «нарисуем примерно такую картину»:
[](http://hotimg23.fotki.com/p/a/195_39/211_226/altsplit_ib.jpg "FREE Fotki Image Hosting")
*Рисунок 4 — Редактирование AlternativeSplitViewController.xib*
Настроим Autosizing так, что бы наш view не «поплыл» при переключении с одной ориентации на другую. Для левой части Master (NavigationBar и TableView) укажем такие же параметры как и на рисунке 5.а, а для правой Detail (NavigationBar и View) —как на рис. 5.б
[](http://hotimg23.fotki.com/p/a/195_39/211_226/master.jpg "FREE Fotki Image Hosting") [](http://hotimg23.fotki.com/p/a/195_39/211_226/detail.jpg "FREE Fotki Image Hosting")
*Рисунок 5 — параметры Autosizing*
Добавим в класс AlternativeSplitViewControlle.h новую IBOutlet переменную, отредактировав файл
AlternativeSplitViewController.h следующим образом
> `1. //
> 2. // AlternativeSplitViewController.h
> 3. // AlternativeSplit
> 4. //
> 5. #import
> 6. @class MasterViewController;
> 7. @interface AlternativeSplitViewController : UIViewController {
> 8. IBOutlet MasterViewController\* masterViewController;
> 9. }
> 10. @end
> \* This source code was highlighted with Source Code Highlighter.`
Класс MasterViewController будет отвечать у нас за таблицу, содержащую пункты меню. Перепишем его следующим образом (если кратко: ниже в коде мы заполняем таблицу и при выборе пользователем ячейки таблицы (didSelectRowAtIndexPath) посылаем сообщение DetailView):
> `1. //
> 2. // MasterViewController.h
> 3. // AlternativeSplit
> 4. //
> 5. #import
> 6. @class DetailViewController;
> 7.
> 8. @interface MasterViewController : UITableViewController {
> 9. IBOutlet DetailViewController\* detailViewController;
> 10. }
> 11.
> 12. @end
> \* This source code was highlighted with Source Code Highlighter.`
> `1.
> 2. //
> 3. // MasterViewController.m
> 4. // AlternativeSplit
> 5. //
> 6. #import "MasterViewController.h"
> 7. #import "DetailViewController.h"
> 8.
> 9. @implementation MasterViewController
> 10.
> 11. #pragma mark -
> 12. #pragma mark View lifecycle
> 13.
> 14. - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
> 15. // Override to allow orientations other than the default portrait orientation.
> 16. return YES;
> 17. }
> 18. #pragma mark -
> 19. #pragma mark Table view data source
> 20. - (NSInteger)numberOfSectionsInTableView:(UITableView \*)tableView {
> 21. // Return the number of sections.
> 22. return 1;
> 23. }
> 24. - (NSInteger)tableView:(UITableView \*)tableView numberOfRowsInSection:(NSInteger)section {
> 25. // Return the number of rows in the section.
> 26. return 5;
> 27. }
> 28. // Customize the appearance of table view cells.
> 29. - (UITableViewCell \*)tableView:(UITableView \*)tableView cellForRowAtIndexPath:(NSIndexPath \*)indexPath {
> 30.
> 31. static NSString \*CellIdentifier = @"Cell";
> 32.
> 33. UITableViewCell \*cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
> 34. if (cell == nil) {
> 35. cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] autorelease];
> 36. }
> 37. // Configure the cell...
> 38. cell.textLabel.text= [NSString stringWithFormat:@"Row %i",indexPath.row];
> 39. return cell;
> 40. }
> 41. #pragma mark -
> 42. #pragma mark Table view delegate
> 43.
> 44. - (void)tableView:(UITableView \*)tableView didSelectRowAtIndexPath:(NSIndexPath \*)indexPath {
> 45.
> 46. [detailViewController setNewText:[NSString stringWithFormat:@"Row %i", indexPath.row]];
> 47. }
> 48.
> 49.
> 50. #pragma mark -
> 51. #pragma mark Memory management
> 52.
> 53. - (void)didReceiveMemoryWarning {
> 54. // Releases the view if it doesn't have a superview.
> 55. [super didReceiveMemoryWarning];
> 56.
> 57. // Relinquish ownership any cached data, images, etc that aren't in use.
> 58. }
> 59.
> 60. - (void)dealloc {
> 61. [super dealloc];
> 62. }
> 63. @end
> \* This source code was highlighted with Source Code Highlighter.`
DetailViewController будет отвечаеть у нас за правую часть. Отредактируем класс DetailViewController (добавим новую IBOutlet переменную UILabel \*lbl и новый метод setNewText, который будет изменять текст нашей lbl )
> `1. //
> 2. // DetailViewController.h
> 3. // AlternativeSplit
> 4. //
> 5. #import
> 6.
> 7. @interface DetailViewController : UIViewController {
> 8. IBOutlet UILabel\* lbl;
> 9. }
> 10. -(void) setNewText:(NSString\*) text;
> 11. @end
> \* This source code was highlighted with Source Code Highlighter.`
> `1. //
> 2. // DetailViewController.m
> 3. // AlternativeSplit
> 4. //
> 5.
> 6. #import "DetailViewController.h"
> 7. @implementation DetailViewController
> 8. -(void) setNewText:(NSString\*) text{
> 9. lbl.text=text;
> 10. }
> 11. - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
> 12. // Overriden to allow any orientation.
> 13. return YES;
> 14. }
> 15. - (void)didReceiveMemoryWarning {
> 16. // Releases the view if it doesn't have a superview.
> 17. [super didReceiveMemoryWarning];
> 18.
> 19. // Release any cached data, images, etc that aren't in use.
> 20. }
> 21. - (void)viewDidUnload {
> 22. [super viewDidUnload];
> 23. // Release any retained subviews of the main view.
> 24. // e.g. self.myOutlet = nil;
> 25. }
> 26. - (void)dealloc {
> 27. [super dealloc];
> 28. }
> 29. @end
> \* This source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).`
Все что осталось нам сделать — это связать в interfaceBuildere наши IBOutlet переменные (см рис. 6). И дело в шляпе.
[](http://hotimg23.fotki.com/p/a/195_39/211_226/-shot-2010-04-18-at-4-40-46-PM.jpg "FREE Fotki Image Hosting")
*Рисунок 6 — Связывание IBOutlet переменных*
Результат:
[](http://hotimg23.fotki.com/p/a/195_39/211_226/result1.jpg "FREE Fotki Image Hosting") [](http://hotimg23.fotki.com/p/a/195_39/211_226/result2.jpg "FREE Fotki Image Hosting")
*Рисунок 7 — Альтернативный SplitView*
Исходный код можно скачать [здесь](http://rapidshare.com/files/377310377/AlternativeSplit.zip.html) или [здесь](http://upload.com.ua/link/901558391/).
Спасибо за внимание.
P.S. Есть некое продолжение этой статьи: «Легким движением руки ~~брюки~~ UITabBar превращается, ~~брюки~~ UITabBar превращается… в ~~элегантные шорты~~ UISplitView» (эдакий Костыль при портировании iPhone приложения под iPad). Стоит ли писать? | https://habr.com/ru/post/91366/ | null | ru | null |
# Безопасность сервисов для видеосвязи
*Базовые требования к сервисам для организации видеоконференцсвязи — качество, надёжность и безопасность. И если первые два требования в основном сопоставимы у всех крупных игроков, то ситуация с безопасностью значительно отличается. В этом посте рассмотрим, как обстоят дела с защитой у самых используемых сервисов: Zoom, Skype, Microsoft Teams и Google Meet.*
С начала пандемии все сервисы для организации видеоконференцсвязи столкнулись с взрывным ростом числа пользователей:
* число ежедневных пользователей Skype [всего за месяц выросло на 70%](https://tass.ru/ekonomika/8118207),
* количество пользователей MS Teams с января [выросло в 5 раз и достигло 75 млн человек](https://habr.com/ru/news/t/500550/),
* количество пользователей Zoom [за 4 месяца выросло в 30 раз](https://www.ixbt.com/news/2020/06/03/zoom-30-4.html) и превысило 300 млн человек в день,
* с января 2020 года количество ежедневных пользователей приложения Google (Hangout) Meet [выросло в 30 раз и сейчас составляет 100 млн человек](https://habr.com/ru/news/t/499724/)
*Рост стоимости акций Zoom Video с момента начала пандемии. Источник: Investing.com*
Однако массовый спрос вызвал не только [рост курса акций компаний](https://quote.rbc.ru/news/article/5e79e18d9a79473f9ed225bb), но и наглядно продемонстрировал проблемы с безопасностью сервисов, о которых раньше почему-то никто не задумывался. Некоторые из проблем связаны с качеством работы программистов и могут привести к удалённому выполнению кода. В основе других лежат неправильные архитектурные решения, обеспечивающие возможность для злонамеренного использования сервиса.
**### Zoom**
Компания Zoom Video буквально ворвалась на рынок ВКС-сервисов и быстро стала лидером. К сожалению, лидерство проявилось не только в числе пользователей, но и в количестве обнаруженных ошибок. Ситуация была настолько удручающей, что военные и государственные ведомства многих стран запретили сотрудникам пользоваться проблемным продуктом; их примеру последовали крупные компании. Рассмотрим уязвимости Zoom, ставшие причиной таких решений.
**Проблемы с шифрованием**
Zoom декларирует, что все видеозвонки защищены шифрованием, однако в действительности всё не так красиво: сервис действительно использует шифрование, но сеансовый ключ клиентская программа запрашивает у одного из серверов «системы управления ключами», входящими в состав облачной инфраструктуры Zoom. Эти серверы генерируют ключ шифрования и выдают его абонентам, которые подключаются к конференции — [один ключ для всех участников конференции.](https://theintercept.com/2020/03/31/zoom-meeting-encryption/)
Передача ключа от сервера к клиенту происходит через протокол TLS, который также используется для https. Если кто-то из участников конференции пользуется Zoom на телефоне, копия ключа шифрования также будет передана ещё одному серверу-коннектору телефонии Zoom.
Часть серверов системы управления ключами расположена в Китае, причём они используются для выдачи ключей даже когда все участники конференции находятся в других странах. Возникают справедливые опасения, что правительство КНР может перехватить зашифрованный трафик, а затем расшифровать его с помощью ключей, полученных от провайдеров в добровольно-принудительном порядке.
Другая проблема шифрования связана с его практической реализацией:
* хотя в документации указано, что используются 256-битные ключи AES, их фактическая длина составляет лишь 128 бит;
* алгоритм AES работает в режиме ECB, при использовании которого результат шифрования частично сохраняет структуру исходных данных.
*Результат шифрования изображения с использованием режима ECB и других режимов AES. Источник: Wikipedia*
**Уязвимость на 500 тыс. долларов**
В середине апреля 2020 года в клиентах Zoom для Windows и macOS были обнаружены две уязвимости нулевого дня. RCE-уязвимость Windows-клиента [сразу же выставили на продажу за 500 тыс. Долларов США](https://www.vice.com/en_us/article/qjdqgv/hackers-selling-critical-zoom-zero-day-exploit-for-500000). Чтобы воспользоваться ошибкой, атакующий должен позвонить жертве, либо участвовать с ней в одной конференции.
Уязвимость в macOS-клиенте не давала таких возможностей, поэтому её использование в реальных атаках маловероятно.
**Ответы на неавторизованные XMPP-запросы**
В конце апреля 2020 года в Zoom обнаружили ещё одну уязвимость: с помощью специально сформированного XMPP-запроса [любой желающий мог получить список всех пользователей сервиса, относящихся к любому домену](https://blog.talosintelligence.com/2020/04/zoom-user-enumeration.html). Например, можно было получить список адресов пользователей с домена usa.gov, отправив XMPP-запрос вида:
```
```
*Приложение просто не проверяло домен пользователя, запрашивающего список адресов.*
**Захват контроля над macOS**
В клиенте Zoom для macOS были обнаружен [две уязвимости, позволявшие злоумышленнику захватить контроль над устройством.](https://techcrunch.com/2020/04/01/zoom-doom/)
1. Инсталлятор Zoom применял технику теневой установки, которую часто используют вредоносные программы, чтобы установиться без взаимодействия с пользователем. Локальный непривилегированный злоумышленник мог внедрить в инсталлятор Zoom вредоносный код и получить привилегии root.
2. Внедрив вредоносный код в установленный Zoom-клиент, атакующий мог получить доступ к камере и микрофону, уже предоставленный приложению. При этом не будет отображаться никаких дополнительных запросов или уведомлений.
**UNC-уязвимость в Windows-клиенте**
Обнаруженная в клиенте Zoom для Windows [уязвимость могла привести к утечке учётных данных пользователей через UNC-ссылки](https://securityaffairs.co/wordpress/100906/hacking/zoom-windows-client-flaw.html). Причина в том, что Windows-клиент Zoom преобразует ссылки в UNC-пути, поэтому, если отправить в чат ссылку вида \\evil.com\img\kotik.jpg, Windows попытается подключиться к этому сайту, используя протокол SMB, чтобы открыть файл kotik.jpg. Удалённый сайт получит от локального компьютера имя пользователя и NTLM-хэш, который можно взломать, используя утилиту Hashcat или другие инструменты.
Используя эту технику, можно было [запустить практически любую программу на локальном компьютере](https://www.bleepingcomputer.com/news/security/zoom-lets-attackers-steal-windows-credentials-run-programs-via-unc-links). Например, по ссылке \127.0.0.1\C$\windows\system32\calc.exe запустится калькулятор.
**Утечки записей видеозвонков**
В начале апреля [на YouTube и Vimeo появились в открытом доступе записи личных видеозвонков пользователей Zoom](https://www.washingtonpost.com/technology/2020/04/03/thousands-zoom-video-calls-left-exposed-open-web). В их числе были школьные уроки, психотерапевтические сеансы и консультации врачей, а также корпоративные совещания.
Причиной утечки стало то, что сервис присваивал видеоконференциям открытые идентификаторы, а организаторы конференций не защищали доступ к ним паролем. Любой желающий мог «слить» записи и использовать их по своему усмотрению.
**Зумбомбинг**
Тот самый случай, когда недостаточное внимание к настройкам безопасности конференций по умолчанию приводит к печальным последствиям. Для подключения к любой видеовстрече в Zoom достаточно было знать идентификатор встречи, и этим массово стали пользоваться пранкеры. Они врывались на онлайн-уроки и упражнялись там в своеобразном «остроумии», например, запускали демонстрацию экрана с порнороликом или разрисовывали документ на экране учителя непристойными изображениями.
Затем выяснилось, что проблема значительно шире, чем просто срыв онлайн-уроков. Журналисты The New York Times обнаружили закрытые чаты и ветки на форумах Reddit и 4Chan, участники которых проводили [массовые кампании по срыву публичных мероприятий](https://www.nytimes.com/2020/04/03/technology/zoom-harassment-abuse-racism-fbi-warning.html), онлайн-встреч обществ анонимных алкоголиков и других Zoom-встреч. Они разыскивали опубликованные в общем доступе реквизиты для подключения, а затем приглашали других троллей присоединиться к «веселью».
**Работа над ошибками**
Массовые отказы от использования сервиса заставили руководство Zoom принимать экстренные меры. В своём [интервью CNN в начале апреля CEO Zoom Эрик Юань сказал](https://edition.cnn.com/videos/media/2020/04/05/zoom-founder-eric-yuan-security-concerns-stelter-rs-vpx.cnn/video/playlists/business-media), что компания двигалась слишком быстро, поэтому они допустили некоторые ошибки. Усвоив урок, они сделали шаг назад, чтобы сосредоточиться на конфиденциальности и безопасности.
В соответствии с программой [«90 дней к безопасности»](https://blog.zoom.us/wordpress/2020/04/01/a-message-to-our-users), Zoom c 1 апреля 2020 года остановила работу над новыми функциями и занялась устранением выявленных проблем и аудитом безопасности кода.
Результатом этих мер стал выпуск Zoom версии 5.0, в которой помимо прочего проапгрейдили AES-шифрование до 256 бит и реализовали множество других доработок, связанных с безопасностью по умолчанию.
**### Skype**
Несмотря на быстрый рост числа пользователей, Skype появлялся в новостях информационной безопасности текущего года всего раз, да и то не в связи с уязвимостью. В январе 2020 года один из бывших подрядчиков рассказал изданию The Guardian, что [Microsoft в течение нескольких лет прослушивала и обрабатывала голоса пользователей Skype и Cortana без каких-либо мер безопасности.](https://www.theguardian.com/technology/2020/jan/10/skype-audio-graded-by-workers-in-china-with-no-security-measures) Однако впервые об этом стало известно ещё в августе 2019 года, и уже тогда представители Microsoft пояснили, что [сбор голосовых данных проводится для обеспечения и совершенствования работы голосовых сервисов](https://www.rbc.ru/rbcfreenews/5d55386a9a79479b0c71f182): поиска и распознавания голосовых команд, перевода речи и транскрибирования.
*Результат поиска в базе уязвимостей по запросу «Skype». Источник: [cve.mitre.org/cgi-bin/cvekey.cgi?keyword=Skype](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=Skype)*
Что касается уязвимостей, то по данным базы CVE, [в 2020 году в Skype не найдено ни одной уязвимости.](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=Skype)
**### MS Teams**
Microsoft уделяет много внимания безопасности своих продуктов, в том числе и MS Teams (хотя противоположное мнение широкого распространено). В 2019-2020 году в Teams обнаружены и исправлены следующие уязвимости:
1. [CVE-2019-5922](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-5922) — уязвимость в инсталляторе Teams, которая позволяла атакующему подсунуть ему вредоносную DLL и получить права в целевой системе, так как инсталлятор не проверял, что за DLL находится в его папке.
2. [Уязвимость платформы Microsoft Teams позволяла скомпрометировать учётную запись пользователя с помощью картинки.](https://www.cyberark.com/threat-research-blog/beware-of-the-gif-account-takeover-vulnerability-in-microsoft-teams)
*Схема атаки на MS Teams с помощью картинки. Источник: [www.cyberark.com/resources/threat-research-blog/beware-of-the-gif-account-takeover-vulnerability-in-microsoft-teams](https://www.cyberark.com/resources/threat-research-blog/beware-of-the-gif-account-takeover-vulnerability-in-microsoft-teams)*
Источник проблемы был в том, как Teams работает с токенами доступа к изображениям. Для аутентификации пользователя в платформе используются два токена: authtoken и skypetoken. Authtoken позволяет пользователю загружать изображения в доменах Teams и Skype и генерирует skypetoken, который используется для аутентификации на сервере, обрабатывающем команды от клиента, например, чтение или отправку сообщений.
Перехвативший оба токена злоумышленник может выполнять вызовы Teams API и получить полный контроль над учётной записью:
* читать и отправлять сообщения,
* создавать группы,
* добавлять и удалять пользователей,
* менять разрешения.
Для перехвата достаточно было заманить жертву на подконтрольный злоумышленнику поддомен домена teams.microsoft.com с помощью GIF-файла. Тогда браузер жертвы отправит хакеру authtoken, после получения которого он сможет создать skypetoken.
3. [Несколько уязвимостей, обнаруженных исследователями Tenable](https://www.tenable.com/security/research/tra-2019-54) в компоненте для отправки открыток с благодарностями (Praise Cards) и окнах чата, позволяли внедрить код для несанкционированного изменения настроек, а также для хищения учётных данных пользователя. Microsoft не выпускала отдельных рекомендаций по поводу этих проблем, исправив их в новой версии приложения.
**### Google Meet**
В отличие от аналогичных сервисов Google Meet полностью работает в браузере. Благодаря этой особенности за последние два года видеоконференцсвязь от Google ни разу не засветилась в новостях информационной безопасности. Даже вызванный пандемией 30-кратный рост числа пользователей не выявил уязвимостей, затрагивающих их безопасность.
**### Наши рекомендации**
Использование любых программ требует ответственного отношения к безопасности, и средства для проведения видеоконференций не исключение. Приведём некоторые правила, которые помогут защитить ваши онлайн-встречи:
1. используйте последнюю версию ПО,
2. загружайте установщики программ только с официальных ресурсов,
3. не публикуйте ID встреч в интернете,
4. защищайте учётные записи с помощью двухфакторной аутентификации,
5. разрешайте подключение к встречам только авторизованным пользователям,
6. закройте возможность новых подключений после начала мероприятия,
7. включите для организатора возможность блокировать или удалять участников встречи,
8. используйте современные антивирусные решения, обеспечивающие комплексную защиту от новых и известных угроз.
Соблюдение правил онлайн-гигиены для видеоконференций позволят эффективно и безопасно работать даже в самые сложные периоды. | https://habr.com/ru/post/510300/ | null | ru | null |
# «Extended WPF Toolkit™» от XCeed поменял лицензию
Добрый день, если вы используете в коммерческих проектах "бесплатную" библитотеку
Extended WPF Toolkit, то самое время форкнуть версию 3.6.0 или приготовиться к покупке платной версии, т.к. примерно месяц назад поменялась лицензия данной библиотеки.
Extended WPF Toolkit — это некогда популярный набор WPF контролов. <https://xceed.com/xceed-toolkit-plus-for-wpf/>
чтобы ознакомиться с их возможностями (вернее с их бесплатной частью, можно запустить LiveExplorer)
С версии 3.7.0, как указано в README.md, бесплатная часть компонентов будет распространяться под кастомной лицензией: XCEED SOFTWARE, INC. COMMUNITY LICENSE AGREEMENT (for non-commercial use).
Давайте немного посмотрим что поменялось:
Было **Microsoft Public License (Ms-PL)** — <https://licenses.nuget.org/MS-PL>
стало **XCEED SOFTWARE, INC. COMMUNITY LICENSE AGREEMENT (for non-commercial use)** — <https://www.nuget.org/packages/Extended.Wpf.Toolkit/3.7.0/License>
**Краткое описание Ms-Pl взято из википедии**:
```
Это наименее ограничивающая лицензия Microsoft, разрешающая распространение скомпилированного кода как для коммерческого, так и для некоммерческого использования под любой лицензией, подчиняющейся Ms-PL. Распространение самого исходного кода возможно только под Ms-PL.
```
**XCEED SOFTWARE, INC. COMMUNITY LICENSE AGREEMENT (for non-commercial use)**,
немного вольного перевода особенно интересных пунктов лицензии:
```
If you are not a software developer, you are not authorized to use our Software.
```
Если вы не являетесь разработчиком программного обеспечения, вы не имеете права использовать наше Программное обеспечение.
```
Would Licensee need to use the Software in any commercial way or purpose, Licensee must acquire a Commercial License (with a paid subscription)
```
Если лицензиату потребуется использовать программное обеспечение любым коммерческим способом или в коммерческих целях, то лицензиат должен приобрести
коммерческую лицензия (с платной подпиской).
```
Licensee is not authorized to:
...
create a competitive software product based on Xceed Software;
```
Лицензиат не имеет права:
…
создание конкурентного программного продукта на основе Xceed Software;
```
Xceed does not allow Community Licensees to publish results from benchmarks or performance comparison tests (with other products) without advance permission by Xceed.
```
Xceed не позволяет пользователям Community Licensees публиковать результаты тестов производительности или сравнения производительности (с другими продуктами)
без предварительного разрешения Xceed.
А вот и список коммитов по изменению лицензии:
V3.7.0 Released (committed on 26 Nov 2019): <https://github.com/xceedsoftware/wpftoolkit/commit/1e0b826e1fca8cdb2bb4640194c906ac23e53c2b>
Update license.md (committed on 26 Nov 2019): <https://github.com/xceedsoftware/wpftoolkit/commit/32c71eb1e7c83812bdb1dc99a7efee018321c6d5>
Update README.md (committed on 26 Nov 2019): <https://github.com/xceedsoftware/wpftoolkit/commit/5b2b5adfb84d5499e730d589e0cb7a065e8dd78f>
P.S. пользуясь случаем хочу сказать спасибо ребятам из XCeed за опенсорсные контролы,
но вот кастомная лицензия считается дурным тоном в мире OpenSource.
P.P.S. а вы какие используете контролы для десктопной разработки ? | https://habr.com/ru/post/483006/ | null | ru | null |
# Dynamic Programming, или как использовать предыдущий computation-опыт
Меня зовут Аят, я Android-инженер финтех кластера в inDrive. Эта статья не связана с продукционной разработкой, но будет касаться программирования. Я расскажу о Dynamic Programming (DP) и о том, как эффективно использовать предыдущий computation-опыт. Надеюсь, будет интересно.
Введение в Dynamic Programming
------------------------------
Термин Dynamic Programming впервые [использовал](https://en.wikipedia.org/wiki/Richard_E._Bellman) известный американский математик, один из ведущих специалистов в области вычислительной техники Ричард Беллман в 40-х годах XX века. Он писал, что Dynamic Programming — это способ решения сложных задач путем разбиения их на более мелкие подзадачи.
Ричард БеллманОбласть решаемых проблем для DP должна соответствовать двум свойствам:
1. **Оптимальная подструктура**. В динамическом программировании означает, что решение подзадач меньшего размера может быть использовано для решения исходной задачи. Оптимальная подструктура — основное свойство задач парадигмы «разделяй и властвуй» (Divide and Conquer).
Классическим примером реализации является алгоритм сортировки слиянием (merge sort), в котором мы рекурсивно разбиваем задачи, спускаясь до самых простейших (массивы размером 1), после чего производим вычисление по каждому. Результаты используются для решения следующего вышестоящего слоя до тех пор, пока не будет достигнут исходный.
2. **Перекрывающиеся подзадачи**. Представляют набор операций, который выполняется многократно для получения искомого результата. В программировании — выполнение одного и того же кода с одними и теми же входными данными и одинаковыми результатами. Классический пример такой проблемы — вычисление N-го элемента в последовательности чисел Фибоначчи, который рассмотрим ниже.
Можно сделать вывод, что DP является частным случаем использования парадигмы Divide and Conquer или её более комплексной версией. Паттерн хорошо подходит для решения задач, связанными с комбинаторикой, где вычисляется большое количество разных комбинаций, но зачастую монотонно и одинаково для N-го количества элементов.
В проблемах с оптимальной подструктурой и перекрывающимися подзадачами при brute force-подходе мы имеем множественные повторяющиеся вычисления и операции. DP помогает оптимизировать решение и избежать дублирование computation двумя основными подходами: мемоизацией и табуляцией:
1. **Мемоизация (нисходящее DP)** реализуется через рекурсию. Задача разбивается на более мелкие подзадачи, их результаты записываются в память и комбинируются для решения исходной задачи путем повторного использования.
* **Минус**: подход расходует память стека рекурсивными вызовами функций и инициализацией расходных переменных внутри каждой.
* **Плюс**: гибкость к задачам DP.
2. **Табуляция (восходящее DP)** реализуется через итеративный метод. Подзадачи от самой малой до исходной вычисляются последовательно, итеративно.
* **Минус**: ограниченный спектр применения. Для подхода необходимо изначальное понимание всей последовательности подзадач. Но в некоторых проблемах это недостижимо.
* **Плюс**: эффективное использование памяти, так как все выполняется в рамках одной функции.
Теория может показаться скучной и непонятной — давайте разбирать примеры.
---
Problem: Fibonacci Sequence
---------------------------
Классическим примером DP является вычисление N-го элемента в последовательности чисел Фибоначчи, когда каждый элемент является суммой двух предыдущих, а первый и второй элемент равен 0 и 1.
По условию сразу обратим внимание на свойство **оптимальной подструктуры**, так как для вычисления одного значения нужно получить предшествующее ему. Чтобы вычислить предыдущее, нужно получить те, который были ещё раньше и так далее. Свойство **перекрывающихся подзадач** подсвечу в разборе ниже.
Разберем на этой задаче три кейса:
1. Решение в лоб: выявим минусы подхода.
2. Оптимизированное решение с использованием мемоизации.
3. Оптимизированное решение с использованием табуляции.
### Решение в лоб (Straightforward/bruteForce approach)
Первое, что может прийти в голову — расписать рекурсию, суммировать предыдущие два элемента и выдать их результат.
```
/**
* Straightforward(Brute force) approach
*/
fun fibBruteForce(n: Int): Int {
return when (n) {
1 -> 0
2 -> 1
else -> fibBruteForce(n - 1) + fibBruteForce(n - 2)
}
}
```
На скрине ниже можно увидеть стек вызовов функций, чтобы вычислить пятый элемент в последовательности.
Обратим внимание, что функция fib(1) вызывается пять раз, fib(2) — три раза. Функции с одной сигнатурой, с одними и теми же параметрами запускаются повторно, делают одно и то же. С увеличением числа N дерево будет увеличиваться не линейно, а экспоненциально, что приведёт к колоссальному дублированию вычислений.
*Math Analysis:
Time Complexity: O(2n),
Space Complexity: O(n) ->* пропорционально максимальной глубине рекурсивного дерева, так как это максимальное количество элементов, которое может присутствовать в стеке неявных вызовов функций.
*Итог:* подход является чудовищно неэффективным. Например, для вычисления 30-го элемента потребуется 1073741824 операций.
### Мемоизация (нисходящее DP)
В этом подходе имплементация не будет сильно отличаться от предшествующего решения «грубой силы». За исключением того, что мы выделим дополнительную память, переменную **memo**, в которую будем записывать результат вычислений любой завершенной функции fib() в нашем стеке.
*Стоит отметить, что можно было обойтись массивом целых чисел и по индексам обращаться к нему, но для концептуальной наглядности была создана хеш-таблица.*
```
/**
* Memoization(Top-down) approach
*/
val memo = HashMap().apply {
this[1] = 0
this[2] = 1
}
fun fibMemo(n: Int): Int {
if (!memo.containsKey(n)) {
val result = fibMemo(n - 1) + fibMemo(n - 2)
memo[n] = result
}
return memo[n]!!
}
```
Снова обратим внимание на стек вызовов функций:
1. Первая выполненная функция, которая запишет результат в memo — highlighted fib(2). Она вернёт управление highlighted fib(3).
2. highlighted fib(3) получит своё значение, просуммировав результаты вызовов fib(2) и fib(1), запишет своё решение в memo и вернёт управление fib(4).
3. Наступает этап переиспользования раннего опыта — при возвращении управления fib(4) в ней ждёт своей очереди вызов fib(2). В свою очередь fib(2) вместо того, чтобы вызвать (fib(1) + fib(0)) воспользуется готовым решением из memo и сразу его вернёт.
4. fib(4) вычисляется и возвращает управление fib(5), которой осталось запустить fib(3). По прошлой аналогии fib(3) сразу вернёт значение из memo без вычислений.
Можем наблюдать сокращение количества вызовов функций и вычислений. Также с увеличением N сокращений будет экспоненциально кратно меньше.
*Math Analysis:
Time Complexity: O(n)
Space Complexity: O(n)*
*Итог:* разница в асимптотической сложности очевидна. Данный подход сократил её в сравнении с примитивным решением до линейной во времени и не увеличил в памяти.
### Табуляция (восходящее DP)
Как упоминалось выше, в этом подходе итеративно идёт вычисление от меньшей подзадачи к большей . В случае с Фибоначчи наименьшие «подзадачи» — это первый и второй элемент в последовательности, 0 и 1 соотвественно.
Нам четко известна зависимость элементов относительно друг друга, которая выражена в формуле: `fib(n) = fib(n-1) + fib(n-2)`. Зная предыдущие элементы, мы без труда можем подсчитать следущий, идущий после него и так далее.
Суммируя известные нам значения, получаем следующий элемент. Проводим эту операцию циклично до получения искомого.
```
/**
* Tabulation(Bottom-up) approach
*/
fun fibTab(n: Int): Int {
var element = 0
var nextElement = 1
for (i in 2 until n) {
val newNext = element + nextElement
element = nextElement
nextElement = newNext
}
return nextElement
}
```
*Math Analysis:
Time Complexity: O(n)
Space Complexity: O(1)*
*Итог*: подход также эффективен с точки зрения скорости как и мемоизация, но при этом расходует константное количество памяти.
Problem: Unique Binary Trees
----------------------------
Рассмотрим более комплексную [задачу](https://leetcode.com/problems/unique-binary-search-trees/): необходимо найти количество всех структурно уникальных бинарных деревьев, которые можно построить из N нод.
[*Бинарное дерево*](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) *—* иерархическая структура данных, в которой каждая нода имеет не более двух потомков. Как правило, первый называется родительской нодой, а дети — левым и правым наследниками.
Предположим, нам нужно найти решения для N = 3. Структурно уникальных деревьев для трех нод — 5. Их можно просчитать в голове, но при увеличении N эскалация вариаций будет огромной и визуализировать их в голове будет невозможно.
Данную задачу можно отнести к комбинаторике. Давайте разбираться, какие комбинации можно построить и как выявить паттерн их построения.
1. Каждое дерево начинается с вершинной ноды (Vertex of The Tree). Начиная с неё, оно разрастается вглубь.
2. Каждая нода является началом нового дочернего дерева (subtree), как указано на скрине. Левое дочернее дерево окрашено в зелёный цвет, правое — в красный. У каждой из них своя вершина.
---
Рассмотрим пример задачи, где N = 6 на концептуальном уровне. Назовём нашу функцию вычисления ***numOfUniqueTrees(n: Int).***
В нашем примере дано 6 нод, из которых по ранее указанному принципу одна нода расходуется на вершину дерева, остаток — 5 нод.
Далее мы взаимодействуем с оставшимися нодами. Делать это можно по-разному. Например, все пять нод использовать для построения левого поддерева или же все пять отправить для правого. Или разбить ноды по обоим одновременно — влево 2 и вправо 3 (см. скрин ниже), таких вариаций у нас ограниченное множество.
Распределение нодЧтобы получить результат ***numOfUniqueTrees(6)***, нужно перебрать все вариации распределений наших нод. Они указаны в таблице:
| | |
| --- | --- |
| Ноды в левом сабтри | Ноды в правом сабтри |
| 5 | 0 |
| 4 | 1 |
| 3 | 2 |
| 2 | 3 |
| 1 | 4 |
| 0 | 5 |
В таблице 6 разных распределений нод. Если мы найдём, сколько уникальных деревьев можно сгенерировать для каждого распределения и просуммируем их, получим наш итоговый результат.
*Как найти количество уникальных деревьев для распределения? У нас два параметра: leftNodes, rightNodes (левый и правый столбец в таблице).* Количество будет равно ***numOfUniqueTrees(leftNodes) \* numOfUniqueTrees(rightNodes).***
*Почему?* Слева у нас будет X уникальных деревьев и на каждое мы можем подставить Y уникальных вариаций деревьев справа. Перемножаем и получаем результат.
Найдем вариации для первого распределения (5 left, 0 right). ***numOfUniqueTrees(5) \* numOfUniqueTrees(0)***, так как справа у нас нет нод. Результат сводится к ***numOfUniqueTrees(5)*** — количеству уникальных поддеревьев слева с неизменной правой стороной.
Подсчет numOfUniqueTrees(5)
Подсчёт ***numOfUniqueTrees(5)****.* Теперь у нас меньшая подзадача, оперировать с ней мы будем также, как и с большей. На этом этапе нам очевидна черта задач DP — **оптимальная подструктура**, рекурсивное поведение.
Одна нода (green node) отправляется на вершину. Остаток (четыре ноды) распределяем аналогично прошлому опыту (4:0), (3:1), (2:2), (1:3), (0:4). Вычислим первое распределение (4:0). Оно равно ***numOfUniqueTrees(4) \* numOfUniqueTrees(0) ->*** ***numOfUniqueTrees(4)*** по ранней аналогии.
Подсчет numOfUniqueTrees(4)Подсчёт ***numOfUniqueTrees(4)***. Выделяем ноду на вершину, и у нас остается 3.
Распределения (3:0), (2:1), (1:2), (0:3).
Для двух нод всего 2 вариации, для одной — одна. По скрину в начале разбора задачи мы знаем, что для трёх нод есть 5 вариаций.
Как результат — распределения
(3:0), (0:3) будут равны 5, (2:1), (1:2) — 2. Суммируем 5 + 2 + 2 + 5, получаем 14. ***numOfUniqueTrees(4) = 14.***Записываем результат вычисления в переменную **memo** по опыту мемоизации. Каждый раз, когда нам понадобится получить вариации для четырёх нод, мы не будет их высчитывать снова, а переиспользуем ранний опыт.
Возвращаемся к подсчету (5:0), который равен сумме распределений (4:0), (3:1), (2:2), (1:3), (0:4). Известно, что (4:0) = 14. Обращаемся к **memo**, (3:1) = 5, (2:2) = 4 (2 вариации слева \* 2 справа), (1:3) = 5, (0:4) = 14. Суммируем и получаем 42, ***numOfUniqueTrees(5) = 42.***Возвращаемся к подсчёту **numOfUniqueTrees(6)**, которая равна сумме распределений
(5:0) = 42, (4:1) = 14, (3:2) =10 (5 left \* 2 right), (2:3) = 10, (1:4) = 14, (0:5) = 42. Суммируем и получаем 132, ***numOfUniqueTrees(5) = 132.***Задача решена!
*Итог*: отметим **перекрывающиеся подзадачи** в решении при N = 6. При решении в лоб ***numOfUniqueTrees(3)*** вызывался бы 18 раз (скрин ниже), с увеличением N повторений будет гораздо больше.
Вызовы numOfUniqueTrees(3) во всех распределениях при N = 6Подсвечу, что количество уникальных деревьев для (5 left, 0 right) и (0 left, 5 right) будет одинаковым. Только в одном случае они будут слева, а во втором случае справа. Это работает и для (4 left, 1 right) и (1 left, 4 right).
Мемоизация как подход динамического программирования позволил нам оптимизировать решение такой комплексной задачи.
### Имплементация
```
class Solution {
fun numTrees(n: Int): Int {
val memo = arrayOfNulls(n+1)
return calculateTees(n, memo)
}
fun calculateTees(n: Int, memo:Array): Int {
var treesNum = 0
if(n < 1) return 0
if(n == 2) return 2
if(n == 1) return 1
if(memo[n]!=null)
return memo[n]!!
for (i in 1..n){
val leftSubTrees = calculateTees( i - 1, memo)
val rightSubTrees = calculateTees(n - i, memo)
treesNum += if(leftSubTrees>0 && rightSubTrees>0){
leftSubTrees\*rightSubTrees
} else
leftSubTrees+leftSubTrees
}
memo[n] = treesNum
return treesNum
}
}
```
Результаты по скорости и времени имплементацииВывод
-----
При определенных обстоятельствах решения задач с помощью Dynamic Programming может сэкономить огромное количество времени и сделать алгоритм максимально эффективным.
Спасибо, что дочитали статью до конца. Если у вас есть вопросы, буду рад ответить на них в комментариях | https://habr.com/ru/post/711352/ | null | ru | null |
# Подводные камни Inter-AS Option C на JunOS
Данная статья написана так сказать по заявкам слушателей нашей радиостанции. При настройке Option C на JunOS у многих возникает один и тот же вопрос: почему ничего не работает хотя все вроде бы правильно? На JunOS все не так тривиально, как на Cisco и проблем может быть несколько. Перейдем непосредственно к сути: симптомы такие — вы настроили на ASBR BGP-LU сессию для организации Opt.C стыка на оборудовании Juniper (и естественно VPNv4 сессию между рефлекторами, но она тут не причем), но пинги между лупбеками PE маршрутизаторов различных автономных систем есть, а вот L3VPN не работает. Давайте разбираться, почему это происходит и как с этим бороться.
Opt.C в отличии от opt.B или opt.A это не только сессия между ASBR разных автономных систем, а комплексное решение, в которое входит BGP-LU сессия между ASBR, предназначенная для передачи маршрутов с метками до лупбеков между автономными системами, а так же VPNv4 сессия, как правило, между рефлекторами разных автономных систем, предназначенная для передачи VPNv4 префиксов. Внутри вашей автономной системы метод распределения маршрутов с метками до удаленных лупбеков выбираете вы сами — это может быть BGP-LU сессия на прямую с ASBR или через RR, либо редистрибуция BGP-LU маршрутов в IGP на ASBR. Каждый подход имеет свои плюсы и минусы, почитать об этом можете в моей предыдущей статье, описывающей принцип работы opt.C. Выбор варианта только за вами, но лично мне нравится когда все работает исключительно через BGP, однако я эксплуатирую сеть в которой есть как сегменты где происходит редистрибуция, так и сегменты, где используется исключительно BGP.
Давайте воспроизведем проблему в эмуляторе и докопаемся да ее сути. Возьмем такую сетку:
Метки, полученные по eBGP-LU из соседней автономной системы внутри нашей локалной автономки будем распространять с помощью iBGP-LU (как я написал ранее можно использовать и редистрибуцию, но этот подход мне не нравится, к тому же имеет свой подводный камень, о котором я напишу далее):
Конфигурация стыков одинакова, и для RZN-ASBR1 выглядит так:
```
bormoglotx@RZN-ASBR1# show protocols bgp
group PE {
type internal;
family inet {
labeled-unicast;
}
export NHS;
neighbor 62.0.0.1 {
local-address 62.0.0.3;
}
}
group ASBR {
type external;
family inet {
labeled-unicast;
}
export LO-export;
neighbor 30.0.0.1 {
local-address 30.0.0.0;
peer-as 71;
}
}
[edit]
bormoglotx@RZN-ASBR1# show policy-options policy-statement NHS
then {
next-hop self;
accept;
}
[edit]
bormoglotx@RZN-ASBR1# show policy-options policy-statement LO-export
term Lo {
from {
protocol ospf;
route-filter 62.0.0.0/24 prefix-length-range /32-/32;
}
then accept;
}
term Lo-local {
from {
protocol direct;
route-filter 62.0.0.0/24 prefix-length-range /32-/32;
}
then accept;
}
then reject;
```
Для TULA-ASBR1 будет все тоже самое с поправкой на адресацию. Первая политика навешивается в сторону локальных PE маршрутизаторов и просто меняет next-hop на себя. Вторая политика навешивается в сторону удаленного ASBR и предназначена для экспорта только маршрутов до лупбеков в соседнюю автономную систему.
Примечание: в политике два терма — первый экспортирует лупбеки, которые имеются в igp, второй экспортирует собственный лупбек ASBR, так как он установлен в rib протоколом direct, а не igp. Это можно сделать и одним термом, но мне так удобнее.
Проверим состояние BGP-LU сессии между RZN-ASBR1 и TULA-ASBR1:
```
bormoglotx@RZN-ASBR1> show bgp neighbor 30.0.0.1
Peer: 30.0.0.1+179 AS 71 Local: 30.0.0.0+56580 AS 62
Type: External State: Established Flags:
Last State: OpenConfirm Last Event: RecvKeepAlive
Last Error: None
Export: [ LO-export ]
Options:
Address families configured: inet-labeled-unicast
Local Address: 30.0.0.0 Holdtime: 90 Preference: 170
Number of flaps: 0
Peer ID: 71.0.0.3 Local ID: 62.0.0.3 Active Holdtime: 90
Keepalive Interval: 30 Group index: 1 Peer index: 0
BFD: disabled, down
Local Interface: ge-0/0/0.0
NLRI for restart configured on peer: inet-labeled-unicast
NLRI advertised by peer: inet-labeled-unicast
NLRI for this session: inet-labeled-unicast
Peer supports Refresh capability (2)
Stale routes from peer are kept for: 300
Peer does not support Restarter functionality
NLRI that restart is negotiated for: inet-labeled-unicast
NLRI of received end-of-rib markers: inet-labeled-unicast
NLRI of all end-of-rib markers sent: inet-labeled-unicast
Peer supports 4 byte AS extension (peer-as 71)
Peer does not support Addpath
Table inet.0 Bit: 10000
RIB State: BGP restart is complete
Send state: in sync
Active prefixes: 3
Received prefixes: 3
Accepted prefixes: 3
Suppressed due to damping: 0
Advertised prefixes: 3
Last traffic (seconds): Received 3 Sent 27 Checked 26
Input messages: Total 1731 Updates 7 Refreshes 0 Octets 33145
Output messages: Total 1728 Updates 3 Refreshes 0 Octets 33030
Output Queue[0]: 0
```
Все отлично, мы отдаем 3 маршрута и столько же и принимаем. В моем случае между ASBR и PE настроена прямая iBGP-LU сессия, в которой передаются лупбеки (схема маленькая и поэтому рефлектора нет).
Идем далее. Проверим, что именно анонсирует RZN-ASBR1 в соседнюю автономку:
```
bormoglotx@RZN-ASBR1> show route advertising-protocol bgp 30.0.0.1
inet.0: 14 destinations, 14 routes (14 active, 0 holddown, 0 hidden)
Prefix Nexthop MED Lclpref AS path
* 62.0.0.1/32 Self 2 I
* 62.0.0.2/32 Self 1 I
* 62.0.0.3/32 Self I
```
Никаких сюрпризов — отдаем только лупбеки. Теперь между PE маршрутизаторами должна подняться vpnv4 сессия. Проверим:
```
bormoglotx@RZN-PE1> show bgp summary group eBGP-VPNV4
Groups: 2 Peers: 2 Down peers: 0
Table Tot Paths Act Paths Suppressed History Damp State Pending
inet.0
10 3 0 0 0 0
bgp.l3vpn.0
1 0 0 0 0 0
Peer AS InPkt OutPkt OutQ Flaps Last Up/Dwn State|#Active/Received/Accepted/Damped...
71.0.0.1 71 6 6 0 0 1:02 Establ
bgp.l3vpn.0: 0/1/1/0
TEST1.inet.0: 0/1/1/0
```
Отлично, сессия в апе и мы видим что получаем один маршрут. Но маршрута в таблице маршрутизации не будет, так как его next-hop в состоянии unusable:
```
bormoglotx@RZN-PE1> show route table bgp.l3vpn.0 hidden
bgp.l3vpn.0: 3 destinations, 3 routes (2 active, 0 holddown, 1 hidden)
+ = Active Route, - = Last Active, * = Both
1:1:10.0.1.0/24
[BGP/170] 00:02:14, localpref 100, from 71.0.0.1
AS path: 71 I, validation-state: unverified
Unusable
```
В этом состоянии он потому, что маршрута до лупбека нет в таблице inet.3, в которой bgp резолвит next-hop. Для этого включим на bgp-lu сессии resolve-vpn, чтобы маршруты устанавливались и в inet.0 и в inet.3 (по умолчанию маршруты BGP-LU попадают в таблицу inet.0):
```
bormoglotx@RZN-PE1> show route table bgp.l3vpn.0 hidden
bgp.l3vpn.0: 3 destinations, 3 routes (3 active, 0 holddown, 0 hidden)
bormoglotx@RZN-PE1> show route table bgp.l3vpn.0 10.0.1.0/24
bgp.l3vpn.0: 3 destinations, 3 routes (3 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
1:1:10.0.1.0/24
*[BGP/170] 00:05:10, localpref 100, from 71.0.0.1
AS path: 71 I, validation-state: unverified
> to 10.0.0.1 via ge-0/0/0.0, Push 16, Push 299968, Push 299792(top)
```
Как видите, маршрут сразу пропал из hidden и установился в таблицу маршрутизации.
По идее все настроено, маршруты есть — трафик должен ходить:
```
bormoglotx@RZN-PE1> show route table TEST1.inet.0 10.0.1.1
TEST1.inet.0: 3 destinations, 3 routes (3 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.1.0/24 *[BGP/170] 00:02:54, localpref 100, from 71.0.0.1
AS path: 71 I, validation-state: unverified
> to 10.0.0.1 via ge-0/0/0.0, Push 16, Push 299968, Push 299792(top)
bormoglotx@RZN-PE1> ping routing-instance TEST1 source 10.0.0.1 10.0.1.1 rapid
PING 10.0.1.1 (10.0.1.1): 56 data bytes
.....
--- 10.0.1.1 ping statistics ---
5 packets transmitted, 0 packets received, 100% packet loss
```
Но фактически получаем эпичный фейл — у нас ничего не заработало. Причем связность между лупбеками PE маршрутизаторов есть:
```
bormoglotx@RZN-PE1> ping source 62.0.0.1 71.0.0.1 rapid
PING 71.0.0.1 (71.0.0.1): 56 data bytes
!!!!!
--- 71.0.0.1 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 9.564/13.021/16.509/2.846 ms
```
Давайте разбираться в чем дело. Для этого придется проверить, что промежуточные маршрутизаторы делают с метками.
Итак, RZN-PE1 пушит три метки: Push 16, Push 299968, Push 299792(top). Метка 299792 нужна, чтобы добраться до RZN-ASBR1, метка 299968- это метка, которую RZN-ASBR1 сгенерировал для префикса 71.0.0.1 (TULA-PE1) ну и метка 16 — это vpnv4 метка.
Верхней меткой в стеке является метка 299792, и именно с ней работает маршрутизатор RZN-P1, получая транзитный mpls пакет — следующую метку в стеке он не смотрит. Мы же проверим, что RZN-P1 должен сделать, получив пакет с указанной выше меткой:
```
bormoglotx@RZN-P1> show route table mpls.0 label 299792
mpls.0: 8 destinations, 8 routes (8 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
299792 *[LDP/9] 13:37:43, metric 1
> to 10.0.1.0 via ge-0/0/1.0, Pop
299792(S=0) *[LDP/9] 13:37:43, metric 1
> to 10.0.1.0 via ge-0/0/1.0, Pop
```
Все логично, так как RZN-P1 является предпоследним маршрутизатором в LSP до RZN-ASBR1, то он снимает верхнюю метку (PHP) и далее отправляет в сторону ASBR пакет с уже двумя метками. То есть на RZN-ASBR1 прилетает пакет с верхней меткой в стеке 299968:
```
bormoglotx@RZN-ASBR1> show route table mpls.0 label 299968
mpls.0: 14 destinations, 14 routes (14 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
299968 *[VPN/170] 00:39:11
> to 30.0.0.1 via ge-0/0/0.0, Swap 300000
```
Тут тоже никакого криминала — как и положено происходит своп данной метки и передача в сторону TULA-ASBR1.
Теперь перемещаемся в соседнюю автономную систему и посмотрим, что будет делает с полученным пакетом TULA-ASB1:
```
bormoglotx@TULA-ASBR1> show route table mpls.0 label 300000
mpls.0: 14 destinations, 14 routes (14 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
300000 *[VPN/170] 00:40:48
> to 20.0.1.1 via ge-0/0/1.0, Pop
300000(S=0) *[VPN/170] 00:40:48
> to 20.0.1.1 via ge-0/0/1.0, Pop
```
TULA-ASBR1 снимает верхнюю метку и отправляет трафик в сторону TULA-P1 пакет всего с одной меткой — меткой 16, которая является vpnv4 меткой. Вот это и есть наша проблема — TULA-P1 не знает о такой метке и просто дропает пакет (а если и знает метку 16, то это будет метка какого то другого сервиса и трафик будет дропнут, только чуть позже):
```
bormoglotx@TULA-P1> show route table mpls.0 label 16
bormoglotx@TULA-P1>
```
Почему это происходит? Дело в том, какой маршрут берется за основу при генерировании меток через BGP-LU сессию. По умолчанию для labeled-unicast сессии используется таблица inet.0 — в нее устанавливаются полученные маршруты и из нее же маршруты отдаются. При этоум за основу при генерирвании маршрутов до лупбеков берутся IGP маршруты (так как именно они являются лучшими в inet.0), в нашем случае это маршруты ospf. Как известно, IGP маршруты не имеют MPLS меток, поэтому при отдаче маршрута через BGP-LU сессию маршрутизатор TULA-ASBR1 записал в таблицу маршрутизации, что метку надо снять и отправить пакет через какой то определенный интерфейс (в нашем случае дальше будет передан пакет с одной меткой — маршрутизатор не знает, что под верхней меткой будет еще одна — он туда не лезет). То есть у нас просто не сшиваются два LSP. Суть всего описанного выше показана на рисунке ниже:
Но почему же тогда пинг до удаленной PE проходит? Все просто — когда PE маршрутизатор отправляет icmp запрос, он не навешиваем vpnv4 метку — пакет идет со стеком из двух меток (ну либо одной, если вы используете редистрибуцию). Трафик все так же приходит на ASBR удаленной автономной системы (в нашем случае на TULA-ASBR1), с него, как мы уже выяснили, снимается метка и уже голый ip трафик идет через P маршрутизатор, который находится в одном IGP домене с хостом назначения и знает маршрут до него (хотя TULA-P1 и не знает обратного маршрута, но это не мешает ему форвардить трафик). То есть это работает вот так:
Путей решения данной проблемы несколько. Начем с опций трафик-инжиниринга протокола mpls. Это не тот трафик инжиниринг о котором вы подумали (думаю вам на ум пришло слово RSVP). Существует 4-ре опции трафик инжиниринга:
```
bormoglotx@RZN-ASBR1# set protocols mpls traffic-engineering ?
Possible completions:
bgp BGP destinations only
bgp-igp BGP and IGP destinations
bgp-igp-both-ribs BGP and IGP destinations with routes in both routing tables
mpls-forwarding Use MPLS routes for forwarding, not routing
```
**Опция bgp** — это опция по умолчанию, она заставляет маршрутизатор инсталировать маршруты ldp и rsvp в таблицу inet.3 и поэтому только bgp имеет доступ к этим маршрутам (резолв next-hop-ов для VPNv4\L2-signaling\EVPN маршрутов). Но обращаю ваше внимание на то, что BGP-LU маршруты будут попадать в inet.0, а не в inet.3.
**Опция bgp-igp** — эта опция заставляет маршрутизатор инсталлировать rsvp и ldp маршруты в таблицу inet.0, причем в этом случае inet.3 станет пустой. Если у вас ASBR используется и как PE-ка для терминации L3VPN, то вы должны осознавать, что они перестанут работать без костылей. Еще одно побочный эффект — «ломается» роутинг.
**Опция bgp-igp-both-ribs** — эта опция заставляет маршрутизатор инсталировать ldp и rsvp маршруты и в таблицу inet.0 и в таблицу inet.3. Побочный эффект как и у прошлой опции — «ломается» роутинг, а вот L3VPN работать будут.
**Опция mpls-forwarding** — эта опция заставляет маршрутизатора копировать маршруты из inet.3 в inet.0, но эти маршруты будут доступны только для форвардинга. В таблице inet.3 изменений не будет. Побочный эффект — трафик, который ранее ходил по ip (например bgp сессии до удаленных лупбеков) теперь будут ходить по mpls (хотя наверно это больше плюс, чем минус — смотря с какой стороны посмотреть).
Эти опции надо использовать с осторожностью, особенно вторую и третью. Обе эти опции ломают роутинг — так как ldp и rsvp маршруты появляются в таблице inet.0, в которой обычно главный протокол igp — isis или ospf. Но теперь маршруты igp станут менее приоритетными в силу их больших protocol preference в сравнении с протоколами распределения меток. Сломают роутинг, это значит, что есть если до включения опции вы видели маршрут до какого лупбека через ospf/isis как луший, то теперь его место займет маршруты ldp/rsvp. Если вы в какой то экспортной политике задали к примеру условие from ospf, то теперь это условие выполняться не будет со всеми вытекающими… Вторая опция, как я указал выше, еще и опасна тем, что таблица inet.3 становится пустой. Имейте это ввиду. А вот опция mpls-forwarding как раз то, что нам надо. При ее включении маршруты из inet.3 будут просто скопированы в inet.0 но только для форвардинга — то есть теперь трафик будет ходить не чистым ip, а через mpls.
Важно понимать, что ни одна из этих опций не генерирует новые LSP — просто существующие LSP копируются (или переносятся) в inet.0. Применяя эти опции (имеется ввиду 2-я, 3-я и 4-я опция в списке), вы позволяете маршрутизатору использовать имеющиеся у него LSP не только для форвардинга трафика L2/3VPN, а так же обычного трафика (если между точками, которые хотят обмениваться этим трафиком, есть LSP — ну к примеру эти точки — лупбеки маршрутизаторов), который обычно ходит чистым IP.
Включим эту опцию и проверим, что получится. Как вы помните, раннее TUAL-ASBR1 анонсировал метку 300000 и делал pop label вместо swap. После включения этой опции метки будут перегенерированы:
```
bormoglotx@RZN-ASBR1> show route receive-protocol bgp 30.0.0.1 71.0.0.1/32 detail
inet.0: 14 destinations, 16 routes (14 active, 0 holddown, 0 hidden)
* 71.0.0.1/32 (1 entry, 1 announced)
Accepted
Route Label: 300080
Nexthop: 30.0.0.1
MED: 2
AS path: 71 I
```
Теперь TULA-ASBR1 анонсирует нам метку 300080. Посмотрим, что будет делать маршрутизатор с транзитным пакетом с этой меткой:
```
bormoglotx@TULA-ASBR1> show route table mpls.0 label 300080
mpls.0: 18 destinations, 18 routes (18 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
300080 *[VPN/170] 00:04:07
> to 20.0.1.1 via ge-0/0/1.0, Swap 299776
```
Вот теперь все так, как надо — происходит swap метки — наши LSP теперь сшиваются. А вот что происходит с таблицей маршрутизации inet.0:
```
bormoglotx@TULA-ASBR1> show route table inet.0 71.0.0.0/24
inet.0: 14 destinations, 16 routes (14 active, 0 holddown, 0 hidden)
@ = Routing Use Only, # = Forwarding Use Only
+ = Active Route, - = Last Active, * = Both
71.0.0.1/32 @[OSPF/10] 00:05:50, metric 2
> to 20.0.1.1 via ge-0/0/1.0
#[LDP/9] 00:05:50, metric 1
> to 20.0.1.1 via ge-0/0/1.0, Push 299776
71.0.0.2/32 @[OSPF/10] 00:05:50, metric 1
> to 20.0.1.1 via ge-0/0/1.0
#[LDP/9] 00:05:50, metric 1
> to 20.0.1.1 via ge-0/0/1.0
71.0.0.3/32 *[Direct/0] 14:16:29
> via lo0.0
```
В таблице появились новые маршруты. Теперь для форвардинга у нас используется LSP(маршрут LDP\RSVP, помеченные #), а для роутинга все те же IGP маршруты (которые теперь помечается @). Хотелось бы заметить, что сейчас маршруты в сторону соседнего ASBR как и ранее генерируются из маршрутов ospf, которые не имеют меток. Но так как у нас теперь для форвардинга используется маршрут LDP, то маршрутизатор будет делать не pop label а swap.
Ну и проверим, что L3VPN завелся:
```
bormoglotx@RZN-PE1> ping routing-instance TEST1 source 10.0.0.1 10.0.1.1 rapid
PING 10.0.1.1 (10.0.1.1): 56 data bytes
!!!!!
--- 10.0.1.1 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 6.861/16.084/47.210/15.596 ms
```
В случае, если вы будете делать редистрибуцию в igp на ASBR:
то вам надо будет сделать egress-policy на протокол ldp, чтобы ASBR стал генерировать метки для полученных префиксов и распределять их внутри сети. По умолчанию JunOS генерирует метку только для своего лупбека, а так же до маршрутов с метками, полученными по ldp, в отличии от той же Cisco, поэтому на оборудовании Cisco такой проблемы нет (но и без этого там хватает своих проблем).
На RZN-ASBR-1 я сделал экспорт маршрутов, полученных по bgp в ospf (bgp LU между PE и ASBR теперь нет):
```
bormoglotx@RZN-ASBR1> show route receive-protocol bgp 30.0.0.1
inet.0: 14 destinations, 14 routes (14 active, 0 holddown, 0 hidden)
Prefix Nexthop MED Lclpref AS path
* 71.0.0.1/32 30.0.0.1 2 71 I
* 71.0.0.2/32 30.0.0.1 1 71 I
* 71.0.0.3/32 30.0.0.1 71 I
```
Согласно политике експорта, данные маршрты уходят в ospf:
```
bormoglotx@RZN-ASBR1> show configuration protocols ospf
export OSPF-EXPORT;
area 0.0.0.0 {
interface lo0.0 {
passive;
}
interface ge-0/0/1.0 {
interface-type p2p;
}
interface ge-0/0/0.0 {
passive;
}
}
bormoglotx@RZN-ASBR1> show configuration policy-options policy-statement OSPF-EXPORT
term Remote-Lo {
from {
route-filter 71.0.0.0/24 prefix-length-range /32-/32;
}
then accept;
}
then reject;
```
Полученные из соседней автономной системы маршруты попадают в ospf database как external и далее распределяются внутри igp домена:
```
bormoglotx@RZN-ASBR1> show ospf database
OSPF database, Area 0.0.0.0
Type ID Adv Rtr Seq Age Opt Cksum Len
Router 62.0.0.1 62.0.0.1 0x80000016 2576 0x22 0xf0fb 60
Router 62.0.0.2 62.0.0.2 0x80000017 2575 0x22 0xf57b 84
Router *62.0.0.3 62.0.0.3 0x8000001a 80 0x22 0xd2dd 72
OSPF AS SCOPE link state database
Type ID Adv Rtr Seq Age Opt Cksum Len
Extern *71.0.0.1 62.0.0.3 0x80000001 80 0x22 0x2afc 36
Extern *71.0.0.2 62.0.0.3 0x80000001 80 0x22 0x1611 36
Extern *71.0.0.3 62.0.0.3 0x80000001 80 0x22 0x225 36
```
Проверим на RZN-PE1 наличие маршрута:
```
bormoglotx@RZN-PE1> show route 71.0.0.1/32
inet.0: 13 destinations, 13 routes (13 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
71.0.0.1/32 *[OSPF/150] 00:02:10, metric 2, tag 0
> to 10.0.0.1 via ge-0/0/0.0
```
Маршрут есть только в таблице inet.0, но для того, чтобы bgp интсталировал маршрут в таблицу bgp.l3vpn.0, необходимо наличие lsp до protocol next-hop в таблице inet.3. Сейчас таблица inet.3 не имеет маршрута к префиксу 71.0.0.1/32. Маршрута нет, так как ldp не генерирует метки для данных префиксов.
```
bormoglotx@RZN-ASBR1> show ldp database
Input label database, 62.0.0.3:0--62.0.0.2:0
Label Prefix
299776 62.0.0.1/32
3 62.0.0.2/32
299792 62.0.0.3/32
Output label database, 62.0.0.3:0--62.0.0.2:0
Label Prefix
300640 62.0.0.1/32
300656 62.0.0.2/32
3 62.0.0.3/32
```
Чтобы появились lsp, необходимо на RZN-ASBR1 сделать egress-policy для ldp, в которой указать, что для префиксов из диапазона 71.0.0.0/24 надо генерировать метки:
```
bormoglotx@RZN-ASBR1> show configuration protocols ldp
egress-policy LDP-EXPORT;
interface ge-0/0/1.0;
bormoglotx@RZN-ASBR1> show configuration policy-options policy-statement LDP-EXPORT
term Local-Lo {
from {
route-filter 62.0.0.3/32 exact;
}
then accept;
}
term Remote-Lo {
from {
route-filter 71.0.0.0/24 prefix-length-range /32-/32;
}
then accept;
}
```
Будьте осторожны с egress-policy для LDP, так как чаще всего при его конфигурировании в первый раз инженер получает пустую inet.3. Те префиксы, которые вы укажите в политике будут анонсировать через LDP, но тогда маршрутизатор станет считать, что он является сорсом для всех этих FEC и просто не будет их инсталлировать в inet.3 (так как локальные FEC в inet.3 не устанавливаются — дефолтный локальный FEC на JunOS это его собственный лупбек и ldp не зачем строить lsp к самому себе). В указанной выше политике я в первом терме отдаю свой собственный лубпек, во втором терме лупбеки соседней автономки, полученные по bgp. Если вы хотите на ASBR инсталлировать маршруты из другой автономки в inet.3. то на сессию в сторону соседней автономной системы надо добавить опцию resolve-vpn:
```
bormoglotx@RZN-ASBR1> show configuration protocols bgp group ASBR
type external;
family inet {
labeled-unicast {
resolve-vpn;
}
}
export LO-export;
neighbor 30.0.0.1 {
local-address 30.0.0.0;
peer-as 71;
}
```
Теперь метки будут генерироваться и для префиксов из диапазона 71.0.0.0/24:
```
bormoglotx@RZN-ASBR1> show ldp database
Input label database, 62.0.0.3:0--62.0.0.2:0
Label Prefix
299776 62.0.0.1/32
3 62.0.0.2/32
299792 62.0.0.3/32
299952 71.0.0.1/32
299968 71.0.0.2/32
299984 71.0.0.3/32
Output label database, 62.0.0.3:0--62.0.0.2:0
Label Prefix
3 62.0.0.1/32
3 62.0.0.2/32
3 62.0.0.3/32
300704 71.0.0.1/32
300720 71.0.0.2/32
300736 71.0.0.3/32
```
После данных манипуляция на RZN-PE1 в inet.3 должны появился маршрут до лупебков соседней автономной системы и, как следствие должна появиться связность внутри L3VPN:
```
bormoglotx@RZN-PE1> show route 71.0.0.1/32
inet.0: 13 destinations, 13 routes (13 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
71.0.0.1/32 *[OSPF/150] 00:09:17, metric 2, tag 0
> to 10.0.0.1 via ge-0/0/0.0
inet.3: 5 destinations, 5 routes (5 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
71.0.0.1/32 *[LDP/9] 00:02:14, metric 1
> to 10.0.0.1 via ge-0/0/0.0, Push 299952
bormoglotx@RZN-PE1> ping routing-instance TEST1 source 10.0.0.1 10.0.1.1 rapid
PING 10.0.1.1 (10.0.1.1): 56 data bytes
!!!!!
--- 10.0.1.1 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 7.054/11.118/21.571/5.493 ms
```
Это мы рассмотрели первый вариант решения проблемы. Теперь перейдем ко второму.
Как я ранее сказал, по умолчанию labeled-unicat маршруты инсталлируются и отдаются из таблицы inet.0, в которой, так же по умолчанию, нет маршрутов с метками. Мы можем заставить маршрутизатор отдавать и принимать маршруты из таблицы inet.3. Делается это так:
```
bormoglotx@RZN-ASBR1# show protocols bgp group ASBR
type external;
family inet {
labeled-unicast {
rib {
inet.3;
}
}
}
export LO-export;
neighbor 30.0.0.1 {
local-address 30.0.0.0;
peer-as 71;
}
```
Примечание: на импорт в политике не должен быть указан протокол igp, так как ospf/isis маршрутов нет в таблице inet.3
Теперь посмотрим, что мы отдаем в соседнюю автономную систему:
```
bormoglotx@RZN-ASBR1> show route advertising-protocol bgp 30.0.0.1
inet.3: 4 destinations, 4 routes (4 active, 0 holddown, 0 hidden)
Prefix Nexthop MED Lclpref AS path
* 62.0.0.1/32 Self 1 I
* 62.0.0.2/32 Self 1 I
```
Только два маршрута, а раньше было три. Не отдается маршрут к самому себе (до лупбека RZN-ASBR1). Почему — легко понять, если поискать свой лубек в таблице inet.3:
```
bormoglotx@RZN-ASBR1> show route table inet.3 62.0.0.3/32
bormoglotx@RZN-ASBR1>
```
Так как локальный FEC в inet.3 не устанавливается, то логично, что маршрута нет. Для того чтобы наш лупбек отдавался, нам необходимо скопировать его из таблицы inet.0 в таблицу inet.3. Для этого надо сделать rib-группу и навесить ее на interface-routes:
```
bormoglotx@RZN-ASBR1> show configuration | compare rollback 4
[edit routing-options]
+ interface-routes {
+ rib-group inet inet.0>>>inet.3-Local-Lo;
+ }
+ rib-groups {
+ inet.0>>>inet.3-Local-Lo {
+ import-rib [ inet.0 inet.3 ];
+ import-policy Local-Lo;
+ }
+ }
[edit policy-options]
+ policy-statement Local-Lo {
+ term Lo {
+ from {
+ protocol direct;
+ route-filter 62.0.0.0/24 prefix-length-range /32-/32;
+ }
+ then accept;
+ }
+ then reject;
+ }
```
Итак, эта строка:
```
import-rib [ inet.0 inet.3 ]
```
говорит нам о том, что маршруты из таблицы inet.0 надо скопировать в таблицу inet.3. А вот эта строка
```
import-policy Local-Lo
```
применяет к этому импорту политику, чтобы не копировать все маршруты. Ну и в конце концов эту rib-группу надо куда прикрутить. Так как мы копируем direct маршрут, то и прикручиваем к interface-routes.
После таких манипуляций маршрут до лупбека будет доступе в таблице inet.3 (но он будет как и в inet.0 установлен в таблицу не протоколом ldp/rsvp, а протоком direct):
```
[edit]
bormoglotx@RZN-ASBR1# run show route 62.0.0.3/32 table inet.3
inet.3: 5 destinations, 5 routes (5 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
62.0.0.3/32 *[Direct/0] 00:00:07
> via lo0.0
```
Можем проверить, отдаем ли мы теперь свой лупбек в соседнюю автономку:
```
bormoglotx@RZN-ASBR1> show route advertising-protocol bgp 30.0.0.1
inet.3: 5 destinations, 5 routes (5 active, 0 holddown, 0 hidden)
Prefix Nexthop MED Lclpref AS path
* 62.0.0.1/32 Self 1 I
* 62.0.0.2/32 Self 1 I
* 62.0.0.3/32 Self I
```
Одну проблему решили. Но возникает вторая проблема:
```
bormoglotx@RZN-PE1> show route table TEST1.inet.0
TEST1.inet.0: 2 destinations, 2 routes (2 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.0.0/24 *[Direct/0] 01:38:46
> via ge-0/0/5.0
10.0.0.1/32 *[Local/0] 01:38:46
Local via ge-0/0/5.0
```
Теперь маршрутов в L3VPN в соседнюю автономку нет, так как лежит bgp пиринг между PE маршрутизаторами:
```
bormoglotx@RZN-PE1> show bgp summary group eBGP-VPNV4
Groups: 2 Peers: 2 Down peers: 1
Table Tot Paths Act Paths Suppressed History Damp State Pending
inet.0
7 0 0 0 0 0
bgp.l3vpn.0
0 0 0 0 0 0
Peer AS InPkt OutPkt OutQ Flaps Last Up/Dwn State|#Active/Received/Accepted/Damped...
71.0.0.1 71 179 183 0 1 18:34 Active
```
Дело в том, что маршруты на ASBR лежат в таблице inet.3, а label-unicast сессия с удаленными PE строится из inet.0, и естественно на PE-ки ничего не отдается. Для этого надо сделать еще одну rib-группу на ASBR и перенести маршруты из inet.3 в inet.0:
```
[edit]
bormoglotx@RZN-ASBR1# show routing-options rib-groups inet.3>>>inet.0-Remote-Lo
import-rib [ inet.3 inet.0 ];
import-policy Remote-Lo;
[edit]
bormoglotx@RZN-ASBR1# show policy-options policy-statement Remote-Lo
term Lo {
from {
route-filter 71.0.0.0/24 prefix-length-range /32-/32;
}
then accept;
}
then reject;
```
И прикручиваем ее на нашу BGP сессию, в который мы получаем данные маршруты:
```
bormoglotx@RZN-ASBR1# show protocols bgp group ASBR
type external;
family inet {
labeled-unicast {
rib-group inet.3>>>inet.0-Remote-Lo;
rib {
inet.3;
}
}
}
export LO-export;
neighbor 30.0.0.1 {
local-address 30.0.0.0;
peer-as 71;
}
```
Аналогичную конфигурацию надо сделать и на втором ASBR, если у вас и там редистрибуция в igp, после чего маршруты до удаленных лупбеков будут установлены в таблицу маршрутизации на PE-ках и eBGP vpnv4 сессия поднимутся (никто не запрещает в одной автономке делать редистрибуцию, а во второй использовать исключительно BGP — выбор только за администраторами сети):
```
bormoglotx@RZN-PE1> show bgp summary group eBGP-VPNV4
Groups: 2 Peers: 2 Down peers: 0
Table Tot Paths Act Paths Suppressed History Damp State Pending
inet.0
10 3 0 0 0 0
bgp.l3vpn.0
1 1 0 0 0 0
Peer AS InPkt OutPkt OutQ Flaps Last Up/Dwn State|#Active/Received/Accepted/Damped...
71.0.0.1 71 184 189 0 1 1:11 Establ
bgp.l3vpn.0: 1/1/1/0
TEST1.inet.0: 1/1/1/0
```
Теперь можно проверить связность внутри L3VPN:
```
bormoglotx@RZN-PE1> ping routing-instance TEST1 source 10.0.0.1 10.0.1.1 rapid
PING 10.0.1.1 (10.0.1.1): 56 data bytes
!!!!!
--- 10.0.1.1 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 4.332/37.029/83.503/29.868 ms
```
Теперь, думаю что вопросов с настройкой opt.C на JunOS станет меньше. Но если у кого то возникли вопросы — пишите в комментарии, ну или мне в телеграмм.
Спасибо за внимание. | https://habr.com/ru/post/336486/ | null | ru | null |
# Как доставлять e-mail уведомления клиентам в условиях невозможности прописать обратную DNS зону
#### Proof of Concept
Из такого заголовка довольно сложно понять, «а кому оно вообще нужно?», а потому для начала краткое предисловие.
Ни для кого не секрет, что интернет-провайдеры весьма агрессивно смотрят на малый бизнес. Условия обслуживания физических и юридических лиц примерно те же, а вот цена весьма существенно разнится. Ситуация монополии в какой-то мере исправилась с приходом таких стандартов, как LTE и 4G, но условия обслуживания и сейчас остаются весьма далекими от гуманности. Итак, это статья посвящается тем, кто по тем или иным условиям вынужден взаимодействовать с провайдером, который предоставляет внешний IP адрес, но не дает возможности редактировать соответствующие обратные DNS записи.
Наверняка многим известно, что в качестве требования к почтовым серверам, помимо DKIM записей и прочих проверок, предъявляется еще и обязательное наличие обратной DNS записи. В противном случае, письма либо не будут доходить вовсе, либо будут попадать в папку «Спам». С вышеозначенными фактами далее мы и будем разбираться.
#### Основная идея
Какие варианты остаются? Во-первых это сервисы прозрачного SMTP проксирования. Но в этом случае клиенту будут приходить письма со стороннего домена, что, вполне естественно, может вызвать недоверие клиента к вашему ресурсу. Во вторых это магия. В сторону последней и будем думать.
Идея в том, чтобы избавиться от вашего IP, как от начального релея. В этом нам помогут службы Gmail Hosted. Процедура настройки вашего домена для использования Gmail Hosted довольно проста и хорошо задокументирована. За всеми подробностями сюда: [Google Apps для бизнеса](http://www.google.com/enterprise/apps/business/).
Настроив свой домен для работы со службами Gmail Hosted и зарегистрировав соответствующий почтовый ящик для связи с клиентами (предположим это noreply@yourdomain.com), очень хочется автоматически из кода вашего ресурса оповещать своих клиентов о событиях. Но если же в такой конфигурации попытаться воспользоваться учетной записью noreply@yourdomain.com, как релеем, то получим то же, от чего уходили. Нанимать сотрудника, который бы входил в веб-интерфейс и отправлял оповещения — неразумно.
#### Много кода
В моем примере я использую OS FreeBSD, так что «as is» данный пример может быть использован только в ней.
Есть отличный консольный браузер elinks, который умеет очень много чего, но не JavaScript. Как бы документация Вас не уверяла в обратном, это не так, elinks интерпретирует JavaScript только в качестве языка для скриптования действий пользователя. Но, так или иначе, это нас не должно остановить, т.к. Gmail пока еще сохраняет совместимость с браузерами, в которых отсутствует поддержка JavaScript интерпретатора.
Как это будет работать:
* Перехват встроенной в php функции mail()
* Вывод аргументов ф-ции mail() во внешнюю среду исполнения
* Запуск elinks, авторизация в системе Gmail
* Переход на страницу создания письма, заполнение соответствующих полей письма
* Отсылка формы с последующей отправкой письма
Сразу оговорюсь, что механизмы, использованные мной не претендуют на изящество, передо мной стояла задача сделать так, чтобы оправка происходила, а не оптимизация процесса под высокую нагрузку.
Нам понадобится:
* PHP в связке с любым HTTP сервером
* APD плагин для PHP (для перехвата базовой ф-ции mail())
* Python с модулем pyexpect (для ведения диалога с процессом elinks)
* Непосредственно, сам elinks с поддержкой скриптинга на языке Lua
* Пакет sudo для того, чтобы дать процессу elinks права на создание необходимых для его работы socket-ов
Если будет необходимость в описании процесса установки всего необходимого, напишите в комментариях, но я беру на себя смелость предполагать, что тот, кто озаботился таковой проблемой уже знаком с процессом установки и настройки приложений.
#### Берем быка за рога
##### Перехват встроенной в php функции mail(), вывод аргументов ф-ции mail() во внешнюю среду исполнения
К любой постоянно включаемой области страницы вашего проекта, дописываем следующий код:
```
function my_mail($args)
{
$result = $args[0] . "\n";
$result .= $args[1] . "\n";
$result .= $args[2];
$file = '/tmp/msg.exchange';
$current = $result . "\n";
file_put_contents($file, $current);
fclose($file);
exec('/usr/local/bin/sudo /bin/csh /root/exec.sh > /dev/null &');
return 1;
}
override_function('mail', '', 'my_mail(func_get_args());');
```
Здесь такие аргументы ф-ции mail(), как «Кому», «Тема», «Тело» сохраняются в хранимый в памяти файл "/tmp/msg.exchange". Далее происходит вызов основного тела скрипта с перенаправлением потока stdout в null устройство, чтобы загрузка страницы происходила сразу, не дожидаясь окончания исполнения скрипта.
Сразу стоит отметить назначение прав в файле "/usr/local/etc/sudoers":
```
Defaults:www !requiretty
www ALL=(ALL) NOPASSWD: /usr/local/bin/elinks, /usr/local/bin/python, /usr/bin/su, /bin/csh
```
Внимание! строка «Defaults:www !requiretty» необходима, т. к. если ее не будет, вы будете получать ошибку в логе вашего веб-сервера о том, что запуск приложения в headless режиме без выделения отдельного tty устройства невозможен.
##### Запуск elinks, авторизация в системе Gmail
Для корректной работы elinks с русским языком, понадобится небольшая настройка:
```
mkdir ~/.elinks
printf 'set terminal.xterm.charset = "koi8-r"\nset ui.language = "Russian"\nset document.browse.search.regex = 0' >> ~/.elinks/elinks.conf
```
Как таковой авторизации при каждом запуске нам не понадобится. С этим справится сам elinks. Вполне достаточно один раз авторизоваться на странице «elinks [mail.google.com/mail/u/0](https://mail.google.com/mail/u/0/)\?ui=html\&zy=c», и далее эти данные будут использоваться во всех последующих сессиях.
Далее, поскольку у нас уже есть вызов sh скрипта, приведу его код:
/root/exec.sh
```
#!/bin/sh
su -l
setenv LANG ru_RU.KOI8-R
/usr/local/bin/python /root/headless.py
```
Непрямой вызов python скрипта связан с некоторыми особенностями работы механизмов смены прав и особенностями работы кодировок в headless режиме.
##### Переход на страницу создания письма, заполнение соответствующих полей письма, отсылка формы с последующей отправкой письма
Последние пункты объединены, поскольку, логика работы скриптов не позволяет их разграничить именно таким образом. Для лучшего понимания механизма, мне придется сначала привести код, связанный с заполнением формы отправки, а уже потом приводить скрипт вызовов браузера и управления им.
###### Заполнение соответствующих полей письма
Скриптование пользовательских функций — весьма удобный механизм в elinks. Он позволяет выполнять некие макросы в ответ на возникновение некоторых событий. В частности, событие pre\_format\_html\_hook возникает тогда, когда браузер уже загрузил содержимое страницы, но перед началом ее интерпретации из HTML вида в тот вид, в котором мы его увидим. Но, как сказано в документации к Lua части скриптования elinks, не все механизмы Lua вполне корректно работают в рамках взаимодействия Lua<->elinks. Например, при попытке вызовов встроенных в Lua функций чтений фалов, оба исполняемых файла ведут себя непредсказуемым образом, так что приходится обходить это ограничение, путем использования специально для этого написанной функции pipe\_read, которая по сути есть простой приемник потока stdout от исполнения любого бинарного elf кода. Так же, стоит отметить момент с кодировками: по сути ничего сложного, но работать с полученными HTML строками приходится в той кодировке, в которой они пришли, потому строки поиска будут выглядеть совершенно нечитаемо.
Все пользовательские скрипты располагаются в папке ~/.elinks и именуются hooks.lang, где lang — это имя языка скриптования. В моем случае это ~/.elinks/hooks.lua, содержимое которого ниже и приводится:
/root/.elinks/hooks.lua
```
function pre_format_html_hook (url, html)
toaddress = pipe_read("head -n 1 /tmp/msg.exchange")
nstr = pipe_read("cat /tmp/msg.exchange | tail -n+2 | /usr/local/bin/iconv -f windows-1251 -t koi8-r | /usr/local/bin/iconv -f koi8-r -t utf-8")
theme = pipe_read("head -n 2 /tmp/msg.exchange | tail -n+2 | /usr/local/bin/iconv -f windows-1251 -t koi8-r | /usr/local/bin/iconv -f koi8-r -t utf-8")
html1 = string.gsub (html, 'aria%-labelledby=l%-to>', 'aria%-labelledby=l%-to>' .. toaddress)
html1 = string.gsub (html1, 'input name=subject value=""', 'input name=subject value="' .. theme .. '"')
html1 = string.gsub (html1, 'aria%-label="п╒п╣п╩п╬ п©п╦я│я▄п╪п╟">', 'aria%-label="п╒п╣п╩п╬ п©п╦я│я▄п╪п╟">' .. nstr)
return html1
end
```
Итого, на каждой странице, содержащей нужные имена полей, будет происходить автозаполнение таковых. В этом легко убедиться, запустив elinks, и перейдя на страницу отправки почты.
###### Переход на страницу создания письма, отсылка формы с последующей отправкой письма
Этот этап был, пожалуй, самым сложным. Перепробовав все средства в попытках отправить уже порожденному процессу спецсимволы, такие как Enter и нажатие клавиши «вправо», наткнулся на замечательную библиотеку для python, под названием pyexpect. С ней все моментально стало очень просто и понятно. Просто приведу код:
/root/headless.py
```
#!/usr/bin/python
# -*- coding: koi8-r -*-
from pexpect import spawn
import time
import datetime
import base64
import pickle
'''
fd = open('/tmp/msg.exchange', 'r+')
with fd as f:
lines = f.read().splitlines()
theme = lines[1]
theme = theme.replace("=?windows-1251?B?", "")
theme = theme.replace("?=", "")
lines[1] = base64.b64decode(theme)
fd = open('/tmp/msg.exchange', 'r+')
fd.truncate()
for item in lines:
fd.write("%s\n" % item)
fd.close()
'''
#KEY_UP = '\x1b[A'
#KEY_DOWN = '\x1b[B'
#KEY_RIGHT = '\x1b[C'
#KEY_LEFT = '\x1b[D'
#KEY_ESCAPE = '\x1b'
#KEY_BACKSPACE = '\x7f'
child = spawn('/usr/local/bin/elinks https://mail.google.com/mail/u/0/?ui=html&zy=c')
#child.logfile = open('/tmp/elinks.log', 'r+')
print 'waiting for gmail.com to load'
child.expect('ORGNAME')
time.sleep(0.5)
child.sendline('/аписать')
print 'search of "new message" string has been reached'
child.sendline('')
print 'the enter key after searching "new message" button has been emulated'
child.expect('тправить')
print 'weve got "send" string back from server'
child.sendline('/тправить')
print 'search of "send" string has been reached'
child.sendline('')
print 'emulated enter key for submitting completed form'
child.sendline('')
print 'emulated enter key for accepting dialog'
child.expect('тправить')
print 'got signal about sucssefull message sending'
#child.interact()
time.sleep(2)
child.sendline('q')
print 'sent quit key emulation'
child.sendline('')
print 'accepted quit with enter key'
```
Здесь я намеренно оставил много интересных закомментированных строк. Многострочный комментарий это код, специфичный для движка Bitrix. Дело в том, что битрикс с его системой почтовых шаблонов автоматически кодирует строку с темой письма в base64 кодировку. В этом куске кода происходит расшифровка из base64 в plain text, с последующей записью обратно в файл обмена. KEY\_UP, KEY\_DOWN, и т. д. — это коды спецсимволов для соответствующих клавиш, вверх, вниз и т. д. Строка «child.logfile = open('/tmp/elinks.log', 'r+')» весьма и весьма полезна для отладки скрипта в headless режиме. Строка «child.interact()» полезна при отладке скрипта в режиме обычного исполнения из консоли.
Для использования этого скрипта «as is», замените ORGNAME на название вашей организации в том виде, в котором оно отображается в шапке Gmail.
Касательно ограничений данного метода, да, их не мало. Во-первых скорость. На отправку каждого письма уходит весьма солидное количество времени и вычислительных ресурсов. Нет возможности отправки красиво отформатированных HTML писем. Скрипты требуют доработки для отправки приложений.
Но и плюсов достаточно много, например, данным метод может использоваться даже в том случае, если у Вас динамический IP адрес, работающий, скажем, в связке с No-IP. Но, пожалуй, главное преимущество данного метода, это полная имитация ручного ввода в веб-интерфейс Gmail, а как следствие спам-фильтрация будет работать исключительно с текстом письма, а те с формальными признаками отправителя. В моем случае, письма, отправленные таким методом приходят не просто в инбокс, а в инбокс с пометкой важно.
Спасибо за внимание, товарищи Хабровчане, успешных вам доставок. | https://habr.com/ru/post/232261/ | null | ru | null |